2 ==================================================================================
4 Copyright (c) 2021 Samsung
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
18 This source code is part of the near-RT RIC (RAN Intelligent Controller)
19 platform project (RICP).
21 ==================================================================================
33 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
34 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
35 "github.com/stretchr/testify/assert"
36 "github.com/stretchr/testify/mock"
39 type RmrSenderMock struct {
45 var rmrSenderInst *RmrSenderMock
47 func TestMain(m *testing.M) {
48 sdlInst = new(SdlMock)
50 sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos",
51 "a1.policy_instance.20005.123456",
52 "a1.policy_instance.20005.234567",
53 "a1.policy_type.1006001",
54 "a1.policy_type.20000",
55 "a1.policy_inst_metadata.1006001.qos",
57 rmrSenderInst = new(RmrSenderMock)
59 rh = createResthook(sdlInst, rmrSenderInst)
64 func TestHealth(t *testing.T) {
65 resp := rh.GetA1Health()
67 a1.Logger.Debug("A1 is healthy ")
68 assert.Equal(t, true, resp)
70 a1.Logger.Debug("A1 is unhealthy")
71 assert.Equal(t, false, resp)
75 func TestHealthFail(t *testing.T) {
76 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",}
77 sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
78 resp := rh.GetA1Health()
80 a1.Logger.Debug("A1 is healthy ")
81 assert.Equal(t, true, resp)
83 a1.Logger.Debug("A1 is unhealthy")
84 assert.Equal(t, false, resp)
88 func TestGetAllPolicyType(t *testing.T) {
89 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",}
90 sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
91 resp := rh.GetAllPolicyType()
92 assert.Equal(t, 2, len(resp))
95 func TestGetAllPolicyTypeFail(t *testing.T) {
96 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",}
97 sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
98 resp := rh.GetAllPolicyType()
99 assert.Equal(t, 0, len(resp))
102 func TestGetPolicyType(t *testing.T) {
104 policyTypeId := models.PolicyTypeID(20001)
106 var policyTypeSchema models.PolicyTypeSchema
107 name := "admission_control_policy_mine"
108 policyTypeSchema.Name = &name
109 policytypeid := int64(20001)
110 policyTypeSchema.PolicyTypeID = &policytypeid
111 description := "various parameters to control admission of dual connection"
112 policyTypeSchema.Description = &description
113 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)",},
114 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
115 policyTypeSchema.CreateSchema = schema
116 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
120 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
121 resp,err := rh.GetPolicyType(policyTypeId)
122 assert.NotNil(t, resp)
124 sdlInst.AssertExpectations(t)
128 func TestCreatePolicyType(t *testing.T) {
129 var policyTypeId models.PolicyTypeID
131 var policyTypeSchema models.PolicyTypeSchema
132 name := "admission_control_policy_mine"
133 policyTypeSchema.Name = &name
134 policytypeid := int64(20001)
135 policyTypeSchema.PolicyTypeID = &policytypeid
136 description := "various parameters to control admission of dual connection"
137 policyTypeSchema.Description = &description
138 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)",},
139 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
141 data, err := policyTypeSchema.MarshalBinary()
142 a1.Logger.Debug("error : %+v ", err)
143 a1.Logger.Debug("data : %+v ", data)
144 key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
145 a1.Logger.Debug("key : %+v ", key)
147 sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil).Once()
148 errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
150 assert.Nil(t, errresp)
151 //Mock Assertion :Behavioral
152 sdlInst.AssertExpectations(t)
156 func TestCreatePolicyType2(t *testing.T) {
157 var policyTypeId models.PolicyTypeID
159 var policyTypeSchema models.PolicyTypeSchema
160 name := "admission_control_policy_mine"
161 policyTypeSchema.Name = &name
162 policytypeid := int64(20001)
163 policyTypeSchema.PolicyTypeID = &policytypeid
164 description := "various parameters to control admission of dual connection"
165 policyTypeSchema.Description = &description
166 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)",},
167 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
169 data, err := policyTypeSchema.MarshalBinary()
170 a1.Logger.Debug("error : %+v ", err)
171 a1.Logger.Debug("data : %+v ", data)
172 key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
173 a1.Logger.Debug("key : %+v ", key)
175 sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(false, nil).Once()
176 resp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
178 assert.NotNil(t, resp)
179 //Mock Assertion :Behavioral
180 sdlInst.AssertExpectations(t)
186 func TestGetPolicyInstance(t *testing.T) {
188 var policyTypeId models.PolicyTypeID
190 var policyInstanceID models.PolicyInstanceID
191 policyInstanceID = "123456"
196 "trigger_threshold":10
198 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
199 a1.Logger.Debug("httpBody String : %+v", httpBody)
200 a1.Logger.Debug("key : %+v", instancekey)
202 keys[0] = instancekey
204 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody, nil)
206 resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
207 a1.Logger.Error("err : %+v", err)
208 assert.NotNil(t, resp)
210 sdlInst.AssertExpectations(t)
213 func TestGetPolicyInstanceFail(t *testing.T) {
215 var policyTypeId models.PolicyTypeID
217 var policyInstanceID models.PolicyInstanceID
218 policyInstanceID = ""
223 "trigger_threshold":10
225 instancekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
226 a1.Logger.Debug("httpBody String : %+v", httpBody)
227 a1.Logger.Debug("key : %+v", instancekey)
229 keys[0] = instancekey
230 testmp1 := map[string]interface{}{instancekey: string(httpBody)}
232 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(testmp1, errors.New("Some Error"))
234 resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
235 a1.Logger.Error("err : %+v", err)
237 assert.Equal(t, 0, len(resp))
238 sdlInst.AssertExpectations(t)
241 func TestGetAllPolicyIntances(t *testing.T) {
242 var policyTypeId models.PolicyTypeID
244 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",}
245 sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
246 resp, err := rh.GetAllPolicyInstance(policyTypeId)
247 fmt.Println("GETALL is ",resp)
248 assert.NoError(t, err)
249 assert.Equal(t, 2, len(resp))
253 func TestDeletePolicyType(t *testing.T) {
255 policyTypeId := models.PolicyTypeID(20001)
256 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
261 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()
262 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(nil)
264 errresp := rh.DeletePolicyType(policyTypeId)
266 assert.Nil(t, errresp)
267 sdlInst.AssertExpectations(t)
270 func TestGetPolicyInstanceStatus(t *testing.T) {
271 var policyTypeId models.PolicyTypeID
273 var policyInstanceID models.PolicyInstanceID
274 policyInstanceID = "123456"
276 "created_at":"0001-01-01T00:00:00.000Z",
277 "instance_status":"NOT IN EFFECT"
279 instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
280 a1.Logger.Debug("httpBody String : %+v", httpBody)
281 a1.Logger.Debug("key : %+v", instancekey)
283 keys[0] = instancekey
284 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody,nil)
285 instancekey = a1HandlerPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
286 var instancekeys [1]string
287 instancekeys[0] = instancekey
288 instancearr := []interface{}{instancekey, "OK"}
289 sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(instancearr, nil)
290 resp, errresp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
292 assert.Nil(t, errresp)
293 assert.NotNil(t, resp)
294 sdlInst.AssertExpectations(t)
297 func TestDeletePolicyInstance(t *testing.T) {
298 var policyTypeId models.PolicyTypeID
300 var policyInstanceID models.PolicyInstanceID
301 policyInstanceID = "123456"
302 var policyTypeSchema models.PolicyTypeSchema
303 name := "admission_control_policy_mine"
304 policyTypeSchema.Name = &name
305 policytypeid := int64(20001)
306 policyTypeSchema.PolicyTypeID = &policytypeid
307 description := "various parameters to control admission of dual connection"
308 policyTypeSchema.Description = &description
309 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)",},
311 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
313 policyTypeSchema.CreateSchema = schema
315 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
316 var policytypekeys [1]string
317 policytypekeys[0] = key
319 sdlInst.On("Get", a1MediatorNs, policytypekeys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
325 "trigger_threshold":10
327 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
328 var instancekeys [1]string
329 instancekeys[0] = instancekey
331 sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(httpBody, nil)
333 var instanceMetadataKeys [1]string
334 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
335 instanceMetadataKeys[0] = instanceMetadataKey
337 "created_at":"2022-11-02 10:30:20",
338 "instance_status":"NOT IN EFFECT"
341 sdlInst.On("Get", a1MediatorNs, instanceMetadataKeys[:]).Return(httpBody, nil)
343 sdlInst.On("Remove", a1MediatorNs, instanceMetadataKeys[:]).Return(nil)
345 var metadatainstancekeys [1]string
346 metadatainstancekeys[0] = instancekey
348 sdlInst.On("Remove", a1MediatorNs, metadatainstancekeys[:]).Return(nil)
350 metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
351 deleted_timestamp := time.Now()
352 var metadatajson interface{}
353 metadatajson = map[string]string{"created_at": "2022-11-02 10:30:20", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "True"}
354 metadata, _ := json.Marshal(metadatajson)
355 metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
357 sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
359 httpBodyString := `{"operation":"DELETE","payload":"","policy_instance_id":"123456","policy_type_id":"20001"}`
361 rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20010, int(policyTypeId)).Return(true)
362 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
363 var notificationDestinationkeys [1]string
364 notificationDestinationkeys[0] = notificationDestinationkey
365 sdlInst.On("Remove", a1MediatorNs, notificationDestinationkeys[:]).Return(nil)
366 errresp := rh.DeletePolicyInstance(policyTypeId, policyInstanceID)
368 assert.Nil(t, errresp)
369 sdlInst.AssertExpectations(t)
371 func TestDataDelivery(t *testing.T) {
378 var instancedata interface{}
380 json.Unmarshal([]byte(httpBody), &instancedata)
381 a1.Logger.Debug("Marshaled data : %+v", (instancedata))
382 httpBodyString := `{"ei_job_id":"1","payload":"payload"}`
383 rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20017, -1).Return(true)
384 errresp := rh.DataDelivery(instancedata)
386 assert.Nil(t, errresp)
387 sdlInst.AssertExpectations(t)
390 func TestDataDeliveryFail(t *testing.T) {
396 var instancedata interface{}
398 json.Unmarshal([]byte(httpBody), &instancedata)
399 a1.Logger.Debug("Marshaled data : %+v", (instancedata))
400 httpBodyString := `{"ei_job_id1":"1","payload":"payload"}`
401 rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20017, -1).Return(false)
402 errresp := rh.DataDelivery(instancedata)
404 assert.NotNil(t, errresp)
405 sdlInst.AssertExpectations(t)
409 func TestGetMetaData(t *testing.T) {
410 var policyTypeId models.PolicyTypeID
412 var policyInstanceID models.PolicyInstanceID
413 policyInstanceID = "123456"
414 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
415 a1.Logger.Debug("key : %+v", instanceMetadataKey)
417 keys[0] = instanceMetadataKey
418 policySchemaString := `{
419 "created_at":"2022-11-02 10:30:20",
420 "instance_status":"NOT IN EFFECT"
422 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{instanceMetadataKey: policySchemaString}, nil)
423 resp, errresp := rh.getMetaData(policyTypeId, policyInstanceID)
424 assert.Nil(t, errresp)
425 assert.NotNil(t, resp)
426 sdlInst.AssertExpectations(t)
429 func TestGetMetaDataFail(t *testing.T) {
430 var policyTypeId models.PolicyTypeID
432 var policyInstanceID models.PolicyInstanceID
433 policyInstanceID = ""
434 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
435 a1.Logger.Debug("key : %+v", instanceMetadataKey)
437 keys[0] = instanceMetadataKey
438 policySchemaString := `{
439 "created_at":"2022-11-02 10:30:20",
440 "instance_status":"NOT IN EFFECT"
442 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{instanceMetadataKey: policySchemaString}, errors.New("Some Error"))
443 _, errresp := rh.getMetaData(policyTypeId, policyInstanceID)
444 assert.NotNil(t, errresp)
449 func TestGetAllPolicyIntancesFail1(t *testing.T) {
450 var policyTypeId models.PolicyTypeID
452 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",}
453 sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
454 resp, err := rh.GetAllPolicyInstance(policyTypeId)
455 fmt.Println("GETALL is ",resp)
456 fmt.Println("GETALL is ",err)
457 assert.Equal(t, 0, len(resp))
460 func TestGetAllPolicyIntancesFail2(t *testing.T) {
461 keys := []string{"",}
462 sdlInst.On("GetAll", "A1m_ns").Return(keys, errors.New("Some Error")).Once()
463 resp, err := rh.GetAllPolicyInstance(0)
464 fmt.Println("GETALL is ",resp)
465 fmt.Println("GETALL is ",err)
467 assert.Equal(t, 0, len(resp))
472 func TestGetPolicyTypeFail(t *testing.T) {
474 policyTypeId := models.PolicyTypeID(0)
476 var policyTypeSchema models.PolicyTypeSchema
477 name := "admission_control_policy_mine"
478 policyTypeSchema.Name = &name
479 policytypeid := int64(0)
480 policyTypeSchema.PolicyTypeID = &policytypeid
481 description := "various parameters to control admission of dual connection"
482 policyTypeSchema.Description = &description
483 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)",},
484 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
485 policyTypeSchema.CreateSchema = schema
486 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
490 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, errors.New("Some Error")).Once()
491 resp,err := rh.GetPolicyType(policyTypeId)
493 assert.NotNil(t, err)
494 //sdlInst.AssertExpectations(t)
498 func TestCreatePolicyTypeFail(t *testing.T) {
499 var policyTypeId models.PolicyTypeID
501 var policyTypeSchema models.PolicyTypeSchema
502 name := "admission_control_policy_mine"
503 policyTypeSchema.Name = &name
504 policytypeid := int64(0)
505 policyTypeSchema.PolicyTypeID = &policytypeid
506 description := "various parameters to control admission of dual connection"
507 policyTypeSchema.Description = &description
508 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)",},
509 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
511 data, err := policyTypeSchema.MarshalBinary()
512 a1.Logger.Debug("error : %+v ", err)
513 a1.Logger.Debug("data : %+v ", data)
514 key := a1PolicyPrefix + strconv.FormatInt(0, 10)
515 a1.Logger.Debug("key : %+v ", key)
517 sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(false, errors.New("Some Error")).Once()
518 errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
520 assert.NotNil(t, errresp)
521 //Mock Assertion :Behavioral
522 //sdlInst.AssertExpectations(t)
525 func TestValidateInvalidJson(t *testing.T) {
527 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)",},
528 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
529 httpBodyString := `{"blocking_rate"::20,"enforce"::true,"trigger_threshold":10,"window_length":20}`
530 resp := validate(httpBodyString , schemaString)
531 assert.Equal(t, false, resp)
534 func TestValidateInvalidSchema(t *testing.T) {
535 schemaString := `{"$schema": "http://json-schema.org/draft-07/sc"}`
536 httpBodyString := `{"blocking_rate":20, 20:true, 30:10,"window_length":20}`
537 resp := validate(httpBodyString , schemaString)
538 assert.Equal(t, false, resp)
541 func TestValidateIntKeys(t *testing.T) {
542 schemaString := `{"$schema": "http://json-schema.org/draft-07/sc"}`
543 httpBodyString := `{20:20}`
544 resp := validate(httpBodyString , schemaString)
545 assert.Equal(t, false, resp)
548 func TestStorePolicyInstanceFail(t *testing.T) {
549 var policyInstanceID models.PolicyInstanceID
550 policyInstanceID = ""
551 var policyTypeId models.PolicyTypeID
553 var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
554 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
558 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: httpBody}, errors.New("Some Error")).Once()
559 notificationDestination :="abc"
560 _,err := rh.storePolicyInstance(policyTypeId,policyInstanceID ,httpBody ,notificationDestination )
561 assert.NotNil(t, err)
564 func TestStorePolicyInstanceMetadataFail(t *testing.T) {
565 var policyInstanceID models.PolicyInstanceID
566 policyInstanceID = ""
567 var policyTypeId models.PolicyTypeID
569 sdlInst.On("Set", "A1m_ns", mock.Anything).Return(errors.New("Some Error")).Once()
570 resp,err := rh.storePolicyInstanceMetadata(policyTypeId,policyInstanceID)
571 assert.NotNil(t, err)
572 assert.Equal(t, false, resp)
575 func TestStoreDeletedPolicyInstanceMetadataFail(t *testing.T) {
576 var policyInstanceID models.PolicyInstanceID
577 policyInstanceID = ""
578 var policyTypeId models.PolicyTypeID
580 sdlInst.On("Set", "A1m_ns", mock.Anything).Return(errors.New("Some Error")).Once()
581 err := rh.storeDeletedPolicyInstanceMetadata(policyTypeId,policyInstanceID,"")
582 assert.NotNil(t, err)
589 func TestToString(t *testing.T) {
590 var instance_map []interface{}
591 instancekey := "testkey"
593 instance_map = append(instance_map, instancekey, data)
594 resp,err := toStringKeys(instance_map)
596 assert.NotNil(t, resp)
599 func TestToStringFail(t *testing.T) {
600 m := make(map[interface{}]interface{})
602 _,err := toStringKeys(m)
603 assert.NotNil(t, err)
606 func TestToStringFail2(t *testing.T) {
609 _,err := toStringKeys(keys[:])
610 assert.NotNil(t, err)
613 func TestTypeValidityFail(t *testing.T) {
614 var policyTypeId models.PolicyTypeID
620 "trigger_threshold":10
622 instancekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
623 a1.Logger.Debug("httpBody String : %+v", httpBody)
624 a1.Logger.Debug("key : %+v", instancekey)
626 keys[0] = instancekey
627 testmp1 := map[string]interface{}{instancekey: string(httpBody)}
629 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(testmp1, errors.New("Some Error")).Once()
630 err:= rh.typeValidity(policyTypeId)
631 a1.Logger.Debug("err from get test : %+v", err)
632 assert.NotNil(t, err)
635 func TestDeletePolicyTypeFail(t *testing.T) {
636 var policyTypeId models.PolicyTypeID
638 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",}
639 sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
640 err := rh.DeletePolicyType(policyTypeId)
641 assert.NotNil(t, err)
644 func TestDeletePolicyTypeFail2(t *testing.T) {
646 policyTypeId := models.PolicyTypeID(20005)
647 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
652 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()
653 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error")).Once()
655 errresp := rh.DeletePolicyType(policyTypeId)
657 assert.NotNil(t, errresp)
660 func TestDeletePolicyTypeFail3(t *testing.T) {
662 policyTypeId := models.PolicyTypeID(20000)
663 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
668 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()
669 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error")).Once()
670 errresp := rh.DeletePolicyType(policyTypeId)
671 assert.NotNil(t, errresp)
674 func TestGetPolicyInstanceStatusFail(t *testing.T) {
675 var policyTypeId models.PolicyTypeID
677 var policyInstanceID models.PolicyInstanceID
678 policyInstanceID = ""
680 "created_at":"0001-01-01T00:00:00.000Z",
681 "instance_status":"NOT IN EFFECT"
683 instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
684 a1.Logger.Debug("httpBody String : %+v", httpBody)
685 a1.Logger.Debug("key : %+v", instancekey)
687 keys[0] = instancekey
688 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody,nil)
689 instancekey = a1HandlerPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
690 var instancekeys [1]string
691 instancekeys[0] = instancekey
692 instancearr := []interface{}{instancekey, "OK"}
693 sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(instancearr, errors.New("Some Error"))
694 _, errresp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
695 assert.NotNil(t, errresp)
698 func TestDeleteInstanceDataFail(t *testing.T) {
699 var policyTypeId models.PolicyTypeID
701 var policyInstanceID models.PolicyInstanceID
702 policyInstanceID = ""
703 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
705 keys[0] = instancekey
708 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
710 errresp := rh.deleteInstancedata(policyTypeId,policyInstanceID)
712 assert.NotNil(t, errresp)
716 func TestDeleteNotificationDestinationFail(t *testing.T) {
717 var policyTypeId models.PolicyTypeID
719 var policyInstanceID models.PolicyInstanceID
720 policyInstanceID = ""
721 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
723 keys[0] = notificationDestinationkey
726 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
728 errresp := rh.deleteNotificationDestination(policyTypeId,policyInstanceID)
730 assert.NotNil(t, errresp)
733 func TestDeleteMetadataFail(t *testing.T) {
734 var policyTypeId models.PolicyTypeID
736 var policyInstanceID models.PolicyInstanceID
737 policyInstanceID = ""
738 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
740 keys[0] = instanceMetadataKey
743 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
745 errresp := rh.deleteMetadata(policyTypeId,policyInstanceID)
747 assert.NotNil(t, errresp)
751 func TestGetPolicyInstanceStFail(t *testing.T) {
752 var policyTypeId models.PolicyTypeID
754 var policyInstanceID models.PolicyInstanceID
755 policyInstanceID = "123"
756 policyString := "testval"
757 instancekey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
758 a1.Logger.Debug("policyString String : %+v", policyString)
759 a1.Logger.Debug("key from get test : %+v", instancekey)
761 keys[0] = instancekey
762 instancearr := []interface{}{instancekey, "NOK"}
764 sdlInst.On("Get", "A1m_ns", keys[:]).Return(instancearr, errors.New("Some Error")).Once()
765 resp, errresp := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
766 a1.Logger.Debug("resp from get test : %+v", resp)
767 a1.Logger.Debug("errresp from get test : %+v", errresp)
768 assert.NotNil(t, errresp)
771 func TestCreatePolicyTypeInstance(t *testing.T) {
772 var policyInstanceID models.PolicyInstanceID
773 policyInstanceID = "123456"
774 var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
775 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
776 var policyTypeId models.PolicyTypeID
779 var instancedata map[string]interface{}
781 json.Unmarshal([]byte(httpBody), &instancedata)
783 data, _ := json.Marshal(instancedata)
784 a1.Logger.Debug("Marshaled data : %+v", string(data))
785 a1.Logger.Debug("instancekey : %+v", instancekey)
786 instancearr := []interface{}{instancekey, string(data)}
787 sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
789 metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
790 creation_timestamp := time.Now()
791 var metadatajson []interface{}
792 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
793 metadata, _ := json.Marshal(metadatajson)
794 a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
795 a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey)
796 metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
797 sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
798 sdlInst.On("SetIfNotExists", a1MediatorNs, instancekey, string(httpBody), string(data)).Return(true, nil)
799 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
800 notificationDestination := "https://www.abc.com"
801 notificationarr := []interface{}{notificationDestinationkey, string(notificationDestination)}
802 sdlInst.On("Set", "A1m_ns", notificationarr).Return(nil)
804 rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
806 errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, notificationDestination)
808 assert.Nil(t, errresp)
811 func TestCreatePolicyTypeInstance2(t *testing.T) {
812 var policyInstanceID models.PolicyInstanceID
813 policyInstanceID = "123"
814 var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
815 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
816 var policyTypeId models.PolicyTypeID
819 var instancedata map[string]interface{}
821 json.Unmarshal([]byte(httpBody), &instancedata)
823 data, _ := json.Marshal(instancedata)
824 a1.Logger.Debug("Marshaled data : %+v", string(data))
825 a1.Logger.Debug("instancekey : %+v", instancekey)
826 instancearr := []interface{}{instancekey, string(data)}
827 sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
828 sdlInst.On("Get", "A1m_ns", mock.Anything).Return(instancearr, nil).Once()
830 metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
831 creation_timestamp := time.Now()
832 var metadatajson []interface{}
833 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
834 metadata, _ := json.Marshal(metadatajson)
835 a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
836 a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey)
837 metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
838 sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
839 sdlInst.On("SetIfNotExists", a1MediatorNs, instancekey, string(httpBody), string(data)).Return(true, nil)
840 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
841 notificationDestination := "https://www.abc.com"
842 notificationarr := []interface{}{notificationDestinationkey, string(notificationDestination)}
843 sdlInst.On("Set", "A1m_ns", notificationarr).Return(nil)
845 rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
847 errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, notificationDestination)
849 assert.Nil(t, errresp)
852 func TestCreatePolicyTypeInstanceFail(t *testing.T) {
853 var policyInstanceID models.PolicyInstanceID
854 policyInstanceID = "123456"
855 var policyTypeId models.PolicyTypeID
857 errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, "", "")
858 assert.NotNil(t, errresp)
861 type SdlMock struct {
865 func (s *SdlMock) GetAll(ns string) ([]string, error) {
866 args := s.MethodCalled("GetAll", ns)
867 return args.Get(0).([]string), args.Error(1)
870 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
871 a1.Logger.Debug("Get Called ")
872 args := s.MethodCalled("Get", ns, keys)
873 a1.Logger.Debug("ns :%+v", args.Get(0))
874 var policySchemaString string
876 if keys[0] == "a1.policy_instance.20001.123456" {
877 policySchemaString = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
878 key = a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + "123456"
879 } else if keys[0] == "a1.policy_type.20001" {
880 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}`
881 key = a1PolicyPrefix + strconv.FormatInt((20001), 10)
882 } else if keys[0] == "a1.policy_inst_metadata.20001.123456" {
883 policySchemaString = `{
884 "created_at":"2022-11-02 10:30:20",
885 "instance_status":"NOT IN EFFECT"
887 key = a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + "123456"
889 a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
890 policyTypeSchema, _ := json.Marshal((policySchemaString))
891 a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
893 a1.Logger.Debug(" key for policy type %+v", key)
894 mp := map[string]interface{}{key: string(policySchemaString)}
895 a1.Logger.Debug("Get Called and mp return %+v ", mp)
896 return mp, args.Error(1)
898 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
899 args := s.MethodCalled("SetIfNotExists", ns, key, data)
900 return args.Bool(0), args.Error(1)
903 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
904 args := s.MethodCalled("Set", ns, pairs)
907 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
908 args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
909 return args.Bool(0), args.Error(1)
912 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string, mtype int, subid int) bool {
913 if httpBodyString == `{"blocking_rate":20,"enforce":true,"trigger_threshold":10,"window_length":20}` {
914 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString, mtype, subid)
916 } else if httpBodyString == `{"ei_job_id":"1","payload":"payload"}` {
917 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString, mtype, subid)
923 func (s *SdlMock) Remove(ns string, keys []string) error {
924 args := s.MethodCalled("Remove", ns, keys)