path: root/pkg/model/messages_test.go

// -
//   ========================LICENSE_START=================================
//   Copyright (C) 2024-2025: Deutsche Telekom
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
//   SPDX-License-Identifier: Apache-2.0
//   ========================LICENSE_END===================================
//

package model

import (
	"encoding/json"
	"errors"
	"github.com/stretchr/testify/assert"
	"testing"
)

func (p *PdpStatus) Validate() error {
	if p.PdpType == "" {
		return errors.New("PdpType is required")
	}

	// Check if State is set to a valid non-zero value
	if p.State != Passive && p.State != Safe && p.State != Test && p.State != Active && p.State != Terminated {
		return errors.New("State is required and must be a valid PdpState")
	}

	// Check if Healthy is set to a valid non-zero value
	if p.Healthy != Healthy && p.Healthy != NotHealthy && p.Healthy != TestInProgress && p.Healthy != Unknown {
		return errors.New("Healthy status is required and must be a valid PdpHealthStatus")
	}

	if p.Name == "" {
		return errors.New("Name is required")
	}
	if p.RequestID == "" {
		return errors.New("RequestID is required")
	}
	if p.PdpGroup == "" {
		return errors.New("PdpGroup is required")
	}
	if p.TimestampMs == "" {
		return errors.New("TimestampMs is required")
	}

	return nil
}

// TestPdpStatusSerialization_Positive tests the successful serialization of PdpStatus.
func TestPdpStatusSerialization_Success(t *testing.T) {
	pdpStatus := PdpStatus{
		MessageType: PDP_STATUS,
		PdpType:     "examplePdpType",
		State:       Active,
		Healthy:     Healthy,
		Description: "PDP is healthy",
		PdpResponse: nil, // Set to nil for simplicity
		Policies:    []ToscaConceptIdentifier{},
		Name:        "ExamplePDP",
		RequestID:   "12345",
		PdpGroup:    "Group1",
		PdpSubgroup: nil,
		TimestampMs: "1633017600000",
	}

	_, err := json.Marshal(pdpStatus)
	if err != nil {
		t.Errorf("Expected no error while marshaling valid PdpStatus, got: %v", err)
	}
}

// TestPdpStatusSerialization_Negative tests the serialization of PdpStatus with invalid fields.
func TestPdpStatusValidation_Failure(t *testing.T) {
	// Example of invalid state and health strings that will fail conversion
	state, err := ConvertStringToEnumState("INVALID_STATE")
	if err == nil {
		t.Fatal("Expected error for invalid state")
	}

	// Example with missing fields or invalid enums
	pdpStatus := PdpStatus{
		PdpType:     "",
		State:       state,
		Name:        "",
		RequestID:   "",
		PdpGroup:    "",
		TimestampMs: "",
	}

	err = pdpStatus.Validate()
	if err == nil {
		t.Error("Expected an error while validating invalid PdpStatus, but got none")
	}
}

func (p *PdpUpdate) Validate() error {
	if p.Source == "" {
		return errors.New("Source is required")
	}
	if p.PdpHeartbeatIntervalMs <= 0 {
		return errors.New("PdpHeartbeatIntervalMs must be a positive integer")
	}
	if p.MessageType == "" {
		return errors.New("MessageType is required")
	}
	if len(p.PoliciesToBeDeployed) == 0 {
		return errors.New("PoliciesToBeDeployed is required and must contain at least one policy")
	}
	if p.Name == "" {
		return errors.New("Name is required")
	}
	if p.TimestampMs <= 0 {
		return errors.New("TimestampMs is required and must be a positive integer")
	}
	if p.PdpGroup == "" {
		return errors.New("PdpGroup is required")
	}
	if p.PdpSubgroup == "" {
		return errors.New("PdpSubgroup is required")
	}
	if p.RequestId == "" {
		return errors.New("RequestId is required")
	}

	return nil
}

// TestPdpUpdateSerialization_Positive tests the successful serialization of PdpUpdate.
func TestPdpUpdateSerialization_Success(t *testing.T) {
	policies := []ToscaPolicy{
		{
			Type:        "onap.policies.native.opa",
			TypeVersion: "1.0",
			Properties: PolicyProperties{
				Data: map[string]string{
					"key1": "value1",
					"key2": "value2",
				},
				Policy: map[string]string{
					"policyKey1": "policyValue1",
				},
			},
			Name:    "MySecurityPolicy",
			Version: "1.0.0",
			Metadata: Metadata{
				PolicyID:      "policy-id-001",
				PolicyVersion: "1.0",
			},
		},
		{
			Type:        "onap.policies.native.opa",
			TypeVersion: "1.0",
			Properties: PolicyProperties{
				Data: map[string]string{
					"threshold": "75",
					"duration":  "30",
				},
				Policy: map[string]string{
					"policyKey2": "policyValue2",
				},
			},
			Name:    "MyPerformancePolicy",
			Version: "1.0.0",
			Metadata: Metadata{
				PolicyID:      "policy-id-002",
				PolicyVersion: "1.0",
			},
		},
	}

	pdpUpdate := PdpUpdate{
		Source:                 "source1",
		PdpHeartbeatIntervalMs: 5000,
		MessageType:            "PDP_UPDATE",
		PoliciesToBeDeployed:   policies,
		Name:                   "ExamplePDP",
		TimestampMs:            1633017600000,
		PdpGroup:               "Group1",
		PdpSubgroup:            "SubGroup1",
		RequestId:              "54321",
	}

	_, err := json.Marshal(pdpUpdate)
	if err != nil {
		t.Errorf("Expected no error while marshaling valid PdpUpdate, got: %v", err)
	}
}

// TestPdpUpdateSerialization_Negative tests the serialization of PdpUpdate with invalid fields.
func TestPdpUpdateSerialization_Failure(t *testing.T) {
	pdpUpdate := PdpUpdate{
		Source:                 "",
		PdpHeartbeatIntervalMs: 5000,
		MessageType:            "",
		PoliciesToBeDeployed:   nil,
		Name:                   "",
		TimestampMs:            0,
		PdpGroup:               "",
		PdpSubgroup:            "",
		RequestId:              "",
	}
	err := pdpUpdate.Validate()
	if err == nil {
		t.Error("Expected an error while validating invalid PdpStatus, but got none")
	}

}

func (p *PdpStateChange) Validate() error {
	if p.Source == "" {
		return errors.New("Source is required")
	}
	if p.State == "" {
		return errors.New("State is required")
	}
	if p.MessageType == "" {
		return errors.New("MessageType is required")
	}
	if p.Name == "" {
		return errors.New("Name is required")
	}
	if p.TimestampMs <= 0 {
		return errors.New("TimestampMs is required and must be a positive integer")
	}
	if p.PdpGroup == "" {
		return errors.New("PdpGroup is required")
	}
	if p.PdpSubgroup == "" {
		return errors.New("PdpSubgroup is required")
	}
	if p.RequestId == "" {
		return errors.New("RequestId is required")
	}

	return nil
}

// TestPdpStateChangeSerialization_Positive tests the successful serialization of PdpStateChange.
func TestPdpStateChangeSerialization_Success(t *testing.T) {
	pdpStateChange := PdpStateChange{
		Source:      "source1",
		State:       "active",
		MessageType: "PDP_STATE_CHANGE",
		Name:        "ExamplePDP",
		TimestampMs: 1633017600000,
		PdpGroup:    "Group1",
		PdpSubgroup: "SubGroup1",
		RequestId:   "98765",
	}

	_, err := json.Marshal(pdpStateChange)
	if err != nil {
		t.Errorf("Expected no error while marshaling valid PdpStateChange, got: %v", err)
	}
}

// TestPdpStateChangeSerialization_Negative tests the serialization of PdpStateChange with invalid fields.
func TestPdpStateChangeSerialization_Failure(t *testing.T) {
	pdpStateChange := PdpStateChange{
		Source:      "",
		State:       "",
		MessageType: "",
		Name:        "",
		TimestampMs: 0,
		PdpGroup:    "",
		PdpSubgroup: "",
		RequestId:   "",
	}
	err := pdpStateChange.Validate()
	if err == nil {
		t.Error("Expected an error while validating invalid PdpStatus, but got none")
	}
}

func TestPdpStateEnum(t *testing.T) {

	// Using enums instead of string constants

	state, err := ConvertStringToEnumState("ACTIVE")

	assert.Nil(t, err)

	assert.Equal(t, Active, state)

}

func TestPdpHealthStatusEnum(t *testing.T) {

	// Using enums instead of string constants

	healthStatus := Healthy // Use the enum directly

	assert.Equal(t, Healthy, healthStatus)

}

// TestPdpMessageType_String_Success validates the string representation of valid PdpMessageType values.

func TestPdpMessageType_String_Success(t *testing.T) {

	tests := []struct {
		msgType PdpMessageType

		expected string
	}{

		{PDP_STATUS, "PDP_STATUS"},

		{PDP_UPDATE, "PDP_UPDATE"},

		{PDP_STATE_CHANGE, "PDP_STATE_CHANGE"},

		{PDP_HEALTH_CHECK, "PDP_HEALTH_CHECK"},

		{PDP_TOPIC_CHECK, "PDP_TOPIC_CHECK"},
	}

	for _, test := range tests {

		if got := test.msgType.String(); got != test.expected {

			t.Errorf("PdpMessageType.String() = %v, want %v", got, test.expected)
			assert.Equal(t, test.expected, got, "PdpMessageType.String() = %v, want %v", got, test.expected)

		}

	}

}

// TestPdpMessageType_String_Failure tests string representation for an invalid PdpMessageType value.

func TestPdpMessageType_String_Failure(t *testing.T) {

	invalidType := PdpMessageType(100)

	expected := "Unknown PdpMessageType: 100"

	if got := invalidType.String(); got != expected {

		t.Errorf("PdpMessageType.String() = %v, want %v", got, expected)
		assert.Equal(t, expected, got, "PdpMessageType.String() should match the expected value")

	}

}