"strconv"
"testing"
"time"
-
+ "errors"
+ "fmt"
"gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
"gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
"github.com/stretchr/testify/assert"
"a1.policy_type.1006001",
"a1.policy_type.20000",
"a1.policy_inst_metadata.1006001.qos",
- }, nil)
+ }, nil).Once()
rmrSenderInst = new(RmrSenderMock)
a1.Init()
rh = createResthook(sdlInst, rmrSenderInst)
}
}
+func TestHealthFail(t *testing.T) {
+ keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
+ resp := rh.GetA1Health()
+ if resp == true {
+ a1.Logger.Debug("A1 is healthy ")
+ assert.Equal(t, true, resp)
+ } else {
+ a1.Logger.Debug("A1 is unhealthy")
+ assert.Equal(t, false, resp)
+ }
+}
+
func TestGetAllPolicyType(t *testing.T) {
+ keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
resp := rh.GetAllPolicyType()
assert.Equal(t, 2, len(resp))
}
+func TestGetAllPolicyTypeFail(t *testing.T) {
+ keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
+ resp := rh.GetAllPolicyType()
+ assert.Equal(t, 0, len(resp))
+}
+
func TestGetPolicyType(t *testing.T) {
policyTypeId := models.PolicyTypeID(20001)
keys[0] = key
//Setup Expectations
sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
- resp := rh.GetPolicyType(policyTypeId)
+ resp,err := rh.GetPolicyType(policyTypeId)
assert.NotNil(t, resp)
-
+ assert.Nil(t, err)
sdlInst.AssertExpectations(t)
}
key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
a1.Logger.Debug("key : %+v ", key)
//Setup Expectations
- sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil)
-
+ sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil).Once()
errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
//Data Assertion
assert.Nil(t, errresp)
sdlInst.AssertExpectations(t)
}
-func TestCreatePolicyTypeInstance(t *testing.T) {
- var policyInstanceID models.PolicyInstanceID
- policyInstanceID = "123456"
- var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
- instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
- var policyTypeId models.PolicyTypeID
- policyTypeId = 20001
-
- var instancedata map[string]interface{}
- json.Unmarshal([]byte(httpBody), &instancedata)
+func TestCreatePolicyType2(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20001
+ var policyTypeSchema models.PolicyTypeSchema
+ name := "admission_control_policy_mine"
+ policyTypeSchema.Name = &name
+ policytypeid := int64(20001)
+ policyTypeSchema.PolicyTypeID = &policytypeid
+ description := "various parameters to control admission of dual connection"
+ policyTypeSchema.Description = &description
+ policyTypeSchema.CreateSchema = `{"$schema": "http://json-schema.org/draft-07/schema#","type":"object","properties": {"enforce": {"type":"boolean","default":"true",},"window_length": {"type": "integer","default":1,"minimum":1,"maximum":60,"description": "Sliding window length (in minutes)",},
+"blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
- data, _ := json.Marshal(instancedata)
- a1.Logger.Debug("Marshaled data : %+v", string(data))
- a1.Logger.Debug("instancekey : %+v", instancekey)
- instancearr := []interface{}{instancekey, string(data)}
- sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
+ data, err := policyTypeSchema.MarshalBinary()
+ a1.Logger.Debug("error : %+v ", err)
+ a1.Logger.Debug("data : %+v ", data)
+ key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
+ a1.Logger.Debug("key : %+v ", key)
+ //Setup Expectations
+ sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(false, nil).Once()
+ resp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
+ //Data Assertion
+ assert.NotNil(t, resp)
+ //Mock Assertion :Behavioral
+ sdlInst.AssertExpectations(t)
+}
- metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
- creation_timestamp := time.Now()
- var metadatajson []interface{}
- metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
- metadata, _ := json.Marshal(metadatajson)
- a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
- a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey)
- metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
- sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
- rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
- errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, "")
- assert.Nil(t, errresp)
- sdlInst.AssertExpectations(t)
-}
func TestGetPolicyInstance(t *testing.T) {
sdlInst.AssertExpectations(t)
}
+func TestGetPolicyInstanceFail(t *testing.T) {
+
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ httpBody := `{
+ "enforce":true,
+ "window_length":20,
+ "blocking_rate":20,
+ "trigger_threshold":10
+ }`
+ instancekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ a1.Logger.Debug("httpBody String : %+v", httpBody)
+ a1.Logger.Debug("key : %+v", instancekey)
+ var keys [1]string
+ keys[0] = instancekey
+ testmp1 := map[string]interface{}{instancekey: string(httpBody)}
+ //Setup Expectations
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(testmp1, errors.New("Some Error"))
+
+ resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
+ a1.Logger.Error("err : %+v", err)
+ assert.Error(t, err)
+ assert.Equal(t, 0, len(resp))
+ sdlInst.AssertExpectations(t)
+}
+
func TestGetAllPolicyIntances(t *testing.T) {
- var policyTypeId models.PolicyTypeID
- policyTypeId = 20005
- resp, err := rh.GetAllPolicyInstance(policyTypeId)
- a1.Logger.Error("err : %+v", err)
- assert.Equal(t, 2, len(resp))
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20005
+ keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
+ resp, err := rh.GetAllPolicyInstance(policyTypeId)
+ fmt.Println("GETALL is ",resp)
+ assert.NoError(t, err)
+ assert.Equal(t, 2, len(resp))
}
+
func TestDeletePolicyType(t *testing.T) {
policyTypeId := models.PolicyTypeID(20001)
keys[0] = key
//Setup Expectations
+ sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",},nil).Once()
sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(nil)
errresp := rh.DeletePolicyType(policyTypeId)
a1.Logger.Debug("key : %+v", instancekey)
var keys [1]string
keys[0] = instancekey
- sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody)
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody,nil)
instancekey = a1HandlerPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
var instancekeys [1]string
instancekeys[0] = instancekey
assert.Nil(t, errresp)
sdlInst.AssertExpectations(t)
}
+/*
+func TestDataDeliveryFail(t *testing.T) {
+
+ httpBody := `{
+ "job":"1",
+ "payload":"payload"
+ }`
+ var instancedata interface{}
+
+ json.Unmarshal([]byte(httpBody), &instancedata)
+ a1.Logger.Debug("Marshaled data : %+v", (instancedata))
+ httpBodyString := `{"ei_job_id1":"1","payload":"payload"}`
+ rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20017, -1).Return(false)
+ errresp := rh.DataDelivery(instancedata)
+
+ assert.NotNil(t, errresp)
+ sdlInst.AssertExpectations(t)
+}
+*/
func TestGetMetaData(t *testing.T) {
var policyTypeId models.PolicyTypeID
policyInstanceID = "123456"
instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
a1.Logger.Debug("key : %+v", instanceMetadataKey)
-
var keys [1]string
keys[0] = instanceMetadataKey
-
policySchemaString := `{
"created_at":"2022-11-02 10:30:20",
"instance_status":"NOT IN EFFECT"
}`
-
sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{instanceMetadataKey: policySchemaString}, nil)
-
resp, errresp := rh.getMetaData(policyTypeId, policyInstanceID)
-
assert.Nil(t, errresp)
assert.NotNil(t, resp)
sdlInst.AssertExpectations(t)
}
+func TestGetMetaDataFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ a1.Logger.Debug("key : %+v", instanceMetadataKey)
+ var keys [1]string
+ keys[0] = instanceMetadataKey
+ policySchemaString := `{
+ "created_at":"2022-11-02 10:30:20",
+ "instance_status":"NOT IN EFFECT"
+ }`
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{instanceMetadataKey: policySchemaString}, errors.New("Some Error"))
+ _, errresp := rh.getMetaData(policyTypeId, policyInstanceID)
+ assert.NotNil(t, errresp)
+}
+
+
+
+func TestGetAllPolicyIntancesFail1(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20009
+ keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
+ resp, err := rh.GetAllPolicyInstance(policyTypeId)
+ fmt.Println("GETALL is ",resp)
+ fmt.Println("GETALL is ",err)
+ assert.Equal(t, 0, len(resp))
+}
+
+func TestGetAllPolicyIntancesFail2(t *testing.T) {
+ keys := []string{"",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys, errors.New("Some Error")).Once()
+ resp, err := rh.GetAllPolicyInstance(0)
+ fmt.Println("GETALL is ",resp)
+ fmt.Println("GETALL is ",err)
+ assert.Error(t, err)
+ assert.Equal(t, 0, len(resp))
+}
+
+
+
+func TestGetPolicyTypeFail(t *testing.T) {
+
+ policyTypeId := models.PolicyTypeID(0)
+
+ var policyTypeSchema models.PolicyTypeSchema
+ name := "admission_control_policy_mine"
+ policyTypeSchema.Name = &name
+ policytypeid := int64(0)
+ policyTypeSchema.PolicyTypeID = &policytypeid
+ description := "various parameters to control admission of dual connection"
+ policyTypeSchema.Description = &description
+ schema := `{"$schema": "http://json-schema.org/draft-07/schema#","type":"object","properties": {"enforce": {"type":"boolean","default":"true",},"window_length": {"type": "integer","default":1,"minimum":1,"maximum":60,"description": "Sliding window length (in minutes)",},
+"blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
+ policyTypeSchema.CreateSchema = schema
+ key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ var keys [1]string
+ keys[0] = key
+ //Setup Expectations
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, errors.New("Some Error")).Once()
+ resp,err := rh.GetPolicyType(policyTypeId)
+ assert.Nil(t, resp)
+ assert.NotNil(t, err)
+ //sdlInst.AssertExpectations(t)
+
+}
+
+func TestCreatePolicyTypeFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyTypeSchema models.PolicyTypeSchema
+ name := "admission_control_policy_mine"
+ policyTypeSchema.Name = &name
+ policytypeid := int64(0)
+ policyTypeSchema.PolicyTypeID = &policytypeid
+ description := "various parameters to control admission of dual connection"
+ policyTypeSchema.Description = &description
+ policyTypeSchema.CreateSchema = `{"$schema": "http://json-schema.org/draft-07/schema#","type":"object","properties": {"enforce": {"type":"boolean","default":"true",},"window_length": {"type": "integer","default":1,"minimum":1,"maximum":60,"description": "Sliding window length (in minutes)",},
+"blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
+
+ data, err := policyTypeSchema.MarshalBinary()
+ a1.Logger.Debug("error : %+v ", err)
+ a1.Logger.Debug("data : %+v ", data)
+ key := a1PolicyPrefix + strconv.FormatInt(0, 10)
+ a1.Logger.Debug("key : %+v ", key)
+ //Setup Expectations
+ sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(false, errors.New("Some Error")).Once()
+ errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
+ //Data Assertion
+ assert.NotNil(t, errresp)
+ //Mock Assertion :Behavioral
+ //sdlInst.AssertExpectations(t)
+}
+
+func TestValidateInvalidJson(t *testing.T) {
+
+ schemaString := `{"$schema": "http://json-schema.org/draft-07/schema#","type":"object","properties": {"enforce": {"type":"boolean","default":"true",},"window_length": {"type": "integer","default":1,"minimum":1,"maximum":60,"description": "Sliding window length (in minutes)",},
+"blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
+ httpBodyString := `{"blocking_rate"::20,"enforce"::true,"trigger_threshold":10,"window_length":20}`
+ resp := validate(httpBodyString , schemaString)
+ assert.Equal(t, false, resp)
+}
+
+func TestValidateInvalidSchema(t *testing.T) {
+ schemaString := `{"$schema": "http://json-schema.org/draft-07/sc"}`
+ httpBodyString := `{"blocking_rate":20, 20:true, 30:10,"window_length":20}`
+ resp := validate(httpBodyString , schemaString)
+ assert.Equal(t, false, resp)
+}
+
+func TestValidateIntKeys(t *testing.T) {
+ schemaString := `{"$schema": "http://json-schema.org/draft-07/sc"}`
+ httpBodyString := `{20:20}`
+ resp := validate(httpBodyString , schemaString)
+ assert.Equal(t, false, resp)
+}
+
+func TestStorePolicyInstanceFail(t *testing.T) {
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
+ key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ var keys [1]string
+ keys[0] = key
+ //Setup Expectations
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: httpBody}, errors.New("Some Error")).Once()
+ notificationDestination :="abc"
+ _,err := rh.storePolicyInstance(policyTypeId,policyInstanceID ,httpBody ,notificationDestination )
+ assert.NotNil(t, err)
+}
+
+func TestStorePolicyInstanceMetadataFail(t *testing.T) {
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ sdlInst.On("Set", "A1m_ns", mock.Anything).Return(errors.New("Some Error")).Once()
+ resp,err := rh.storePolicyInstanceMetadata(policyTypeId,policyInstanceID)
+ assert.NotNil(t, err)
+ assert.Equal(t, false, resp)
+}
+
+func TestStoreDeletedPolicyInstanceMetadataFail(t *testing.T) {
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ sdlInst.On("Set", "A1m_ns", mock.Anything).Return(errors.New("Some Error")).Once()
+ err := rh.storeDeletedPolicyInstanceMetadata(policyTypeId,policyInstanceID,"")
+ assert.NotNil(t, err)
+
+}
+
+
+
+
+func TestToString(t *testing.T) {
+ var instance_map []interface{}
+ instancekey := "testkey"
+ data := "testdata"
+ instance_map = append(instance_map, instancekey, data)
+ resp,err := toStringKeys(instance_map)
+ assert.Nil(t, err)
+ assert.NotNil(t, resp)
+}
+
+func TestToStringFail(t *testing.T) {
+ m := make(map[interface{}]interface{})
+ m[12] = "bar"
+ _,err := toStringKeys(m)
+ assert.NotNil(t, err)
+}
+/*
+func TestToStringFail2(t *testing.T) {
+ var keys [1]string
+ keys[0] = ""
+ _,err := toStringKeys(keys[:])
+ assert.NotNil(t, err)
+}
+*/
+func TestTypeValidityFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 123
+ httpBody := `{
+ "enforce":true,
+ "window_length":20,
+ "blocking_rate":20,
+ "trigger_threshold":10
+ }`
+ instancekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ a1.Logger.Debug("httpBody String : %+v", httpBody)
+ a1.Logger.Debug("key : %+v", instancekey)
+ var keys [1]string
+ keys[0] = instancekey
+ testmp1 := map[string]interface{}{instancekey: string(httpBody)}
+ //Setup Expectations
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(testmp1, errors.New("Some Error")).Once()
+ err:= rh.typeValidity(policyTypeId)
+ a1.Logger.Debug("err from get test : %+v", err)
+ assert.NotNil(t, err)
+}
+
+func TestDeletePolicyTypeFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20009
+ keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
+ sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
+ err := rh.DeletePolicyType(policyTypeId)
+ assert.NotNil(t, err)
+}
+
+func TestDeletePolicyTypeFail2(t *testing.T) {
+
+ policyTypeId := models.PolicyTypeID(20005)
+ key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ var keys [1]string
+ keys[0] = key
+
+ //Setup Expectations
+ sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",},nil).Once()
+ sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error")).Once()
+
+ errresp := rh.DeletePolicyType(policyTypeId)
+
+ assert.NotNil(t, errresp)
+}
+
+func TestDeletePolicyTypeFail3(t *testing.T) {
+
+ policyTypeId := models.PolicyTypeID(20000)
+ key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ var keys [1]string
+ keys[0] = key
+
+ //Setup Expectations
+ sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",},nil).Once()
+ sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error")).Once()
+ errresp := rh.DeletePolicyType(policyTypeId)
+ assert.NotNil(t, errresp)
+}
+
+func TestGetPolicyInstanceStatusFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ httpBody := `{
+ "created_at":"0001-01-01T00:00:00.000Z",
+ "instance_status":"NOT IN EFFECT"
+ }`
+ instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
+ a1.Logger.Debug("httpBody String : %+v", httpBody)
+ a1.Logger.Debug("key : %+v", instancekey)
+ var keys [1]string
+ keys[0] = instancekey
+ sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody,nil)
+ instancekey = a1HandlerPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
+ var instancekeys [1]string
+ instancekeys[0] = instancekey
+ instancearr := []interface{}{instancekey, "OK"}
+ sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(instancearr, errors.New("Some Error"))
+ _, errresp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
+ assert.NotNil(t, errresp)
+}
+
+func TestDeleteInstanceDataFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ var keys [1]string
+ keys[0] = instancekey
+
+ //Setup Expectations
+ sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
+
+ errresp := rh.deleteInstancedata(policyTypeId,policyInstanceID)
+
+ assert.NotNil(t, errresp)
+}
+
+
+func TestDeleteNotificationDestinationFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ var keys [1]string
+ keys[0] = notificationDestinationkey
+
+ //Setup Expectations
+ sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
+
+ errresp := rh.deleteNotificationDestination(policyTypeId,policyInstanceID)
+
+ assert.NotNil(t, errresp)
+}
+
+func TestDeleteMetadataFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 0
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = ""
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ var keys [1]string
+ keys[0] = instanceMetadataKey
+
+ //Setup Expectations
+ sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
+
+ errresp := rh.deleteMetadata(policyTypeId,policyInstanceID)
+
+ assert.NotNil(t, errresp)
+}
+
+
+func TestGetPolicyInstanceStFail(t *testing.T) {
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 200
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = "123"
+ policyString := "testval"
+ instancekey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ a1.Logger.Debug("policyString String : %+v", policyString)
+ a1.Logger.Debug("key from get test : %+v", instancekey)
+ var keys [1]string
+ keys[0] = instancekey
+ instancearr := []interface{}{instancekey, "NOK"}
+ //Setup Expectations
+ sdlInst.On("Get", "A1m_ns", keys[:]).Return(instancearr, errors.New("Some Error")).Once()
+ resp, errresp := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
+ a1.Logger.Debug("resp from get test : %+v", resp)
+ a1.Logger.Debug("errresp from get test : %+v", errresp)
+ assert.NotNil(t, errresp)
+}
+
+func TestCreatePolicyTypeInstance(t *testing.T) {
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = "123456"
+ var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
+ instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20001
+
+ var instancedata map[string]interface{}
+
+ json.Unmarshal([]byte(httpBody), &instancedata)
+
+ data, _ := json.Marshal(instancedata)
+ a1.Logger.Debug("Marshaled data : %+v", string(data))
+ a1.Logger.Debug("instancekey : %+v", instancekey)
+ instancearr := []interface{}{instancekey, string(data)}
+ sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
+
+ metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
+ creation_timestamp := time.Now()
+ var metadatajson []interface{}
+ metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
+ metadata, _ := json.Marshal(metadatajson)
+ a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
+ a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey)
+ metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
+ sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
+ sdlInst.On("SetIfNotExists", a1MediatorNs, instancekey, string(httpBody), string(data)).Return(true, nil)
+ notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ notificationDestination := "https://www.abc.com"
+ notificationarr := []interface{}{notificationDestinationkey, string(notificationDestination)}
+ sdlInst.On("Set", "A1m_ns", notificationarr).Return(nil)
+
+ rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
+
+ errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, notificationDestination)
+
+ assert.Nil(t, errresp)
+}
+
+func TestCreatePolicyTypeInstance2(t *testing.T) {
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = "123"
+ var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
+ instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20001
+
+ var instancedata map[string]interface{}
+
+ json.Unmarshal([]byte(httpBody), &instancedata)
+
+ data, _ := json.Marshal(instancedata)
+ a1.Logger.Debug("Marshaled data : %+v", string(data))
+ a1.Logger.Debug("instancekey : %+v", instancekey)
+ instancearr := []interface{}{instancekey, string(data)}
+ sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
+ sdlInst.On("Get", "A1m_ns", mock.Anything).Return(instancearr, nil).Once()
+
+ metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
+ creation_timestamp := time.Now()
+ var metadatajson []interface{}
+ metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
+ metadata, _ := json.Marshal(metadatajson)
+ a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
+ a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey)
+ metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
+ sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
+ sdlInst.On("SetIfNotExists", a1MediatorNs, instancekey, string(httpBody), string(data)).Return(true, nil)
+ notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ notificationDestination := "https://www.abc.com"
+ notificationarr := []interface{}{notificationDestinationkey, string(notificationDestination)}
+ sdlInst.On("Set", "A1m_ns", notificationarr).Return(nil)
+
+ rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
+
+ errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, notificationDestination)
+
+ assert.Nil(t, errresp)
+}
+
+func TestCreatePolicyTypeInstanceFail(t *testing.T) {
+ var policyInstanceID models.PolicyInstanceID
+ policyInstanceID = "123456"
+ var policyTypeId models.PolicyTypeID
+ policyTypeId = 20001
+ errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, "", "")
+ assert.NotNil(t, errresp)
+}
+
type SdlMock struct {
mock.Mock
}
func (s *SdlMock) GetAll(ns string) ([]string, error) {
- args := s.MethodCalled("GetAll", ns)
- return args.Get(0).([]string), nil
+ args := s.MethodCalled("GetAll", ns)
+ return args.Get(0).([]string), args.Error(1)
}
func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
a1.Logger.Debug("Get Called ")
args := s.MethodCalled("Get", ns, keys)
a1.Logger.Debug("ns :%+v", args.Get(0))
- policytypeid := int64(20001)
- policyInstanceID := "123456"
var policySchemaString string
var key string
if keys[0] == "a1.policy_instance.20001.123456" {
- policySchemaString = `{
- "enforce":true,
- "window_length":20,
- "blocking_rate":20,
- "trigger_threshold":10
- }`
- key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
+ policySchemaString = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
+ key = a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + "123456"
} else if keys[0] == "a1.policy_type.20001" {
policySchemaString = `{"create_schema":{"$schema":"http://json-schema.org/draft-07/schema#","properties":{"additionalProperties":false,"blocking_rate":{"default":10,"description":"% Connections to block","maximum":1001,"minimum":1,"type":"number"},"enforce":{"default":"true","type":"boolean"},"window_length":{"default":1,"description":"Sliding window length (in minutes)","maximum":60,"minimum":1,"type":"integer"}},"type":"object"},"description":"various parameters to control admission of dual connection","name":"admission_control_policy_mine","policy_type_id":20001}`
- key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
+ key = a1PolicyPrefix + strconv.FormatInt((20001), 10)
} else if keys[0] == "a1.policy_inst_metadata.20001.123456" {
policySchemaString = `{
"created_at":"2022-11-02 10:30:20",
"instance_status":"NOT IN EFFECT"
}`
- key = a1InstanceMetadataPrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
+ key = a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + "123456"
}
a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
policyTypeSchema, _ := json.Marshal((policySchemaString))
a1.Logger.Debug(" key for policy type %+v", key)
mp := map[string]interface{}{key: string(policySchemaString)}
a1.Logger.Debug("Get Called and mp return %+v ", mp)
- return mp, nil
+ return mp, args.Error(1)
}
func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
args := s.MethodCalled("SetIfNotExists", ns, key, data)
Code Review / ric-plt / a1.git / blobdiff