2 ==================================================================================
3 Copyright (c) 2021 Samsung
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
17 This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 platform project (RICP).
19 ==================================================================================
30 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
31 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
32 "github.com/stretchr/testify/assert"
33 "github.com/stretchr/testify/mock"
36 type RmrSenderMock struct {
42 var rmrSenderInst *RmrSenderMock
44 func TestMain(m *testing.M) {
45 sdlInst = new(SdlMock)
47 sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos",
48 "a1.policy_instance.20005.123456",
49 "a1.policy_instance.20005.234567",
50 "a1.policy_type.1006001",
51 "a1.policy_type.20000",
52 "a1.policy_inst_metadata.1006001.qos",
54 RMRclient = new(RMRClientMock)
56 rh = createResthook(sdlInst, RMRclient)
61 func TestGetAllPolicyType(t *testing.T) {
62 resp := rh.GetAllPolicyType()
63 assert.Equal(t, 2, len(resp))
66 func TestGetPolicyType(t *testing.T) {
68 policyTypeId := models.PolicyTypeID(20001)
70 var policyTypeSchema models.PolicyTypeSchema
71 name := "admission_control_policy_mine"
72 policyTypeSchema.Name = &name
73 policytypeid := int64(20001)
74 policyTypeSchema.PolicyTypeID = &policytypeid
75 description := "various parameters to control admission of dual connection"
76 policyTypeSchema.Description = &description
77 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)",},
78 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
79 policyTypeSchema.CreateSchema = schema
80 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
84 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
85 resp := rh.GetPolicyType(policyTypeId)
86 assert.NotNil(t, resp)
88 sdlInst.AssertExpectations(t)
92 func TestCreatePolicyType(t *testing.T) {
93 var policyTypeId models.PolicyTypeID
95 var policyTypeSchema models.PolicyTypeSchema
96 name := "admission_control_policy_mine"
97 policyTypeSchema.Name = &name
98 policytypeid := int64(20001)
99 policyTypeSchema.PolicyTypeID = &policytypeid
100 description := "various parameters to control admission of dual connection"
101 policyTypeSchema.Description = &description
102 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)",},
103 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
105 data, err := policyTypeSchema.MarshalBinary()
106 a1.Logger.Debug("error : %+v ", err)
107 a1.Logger.Debug("data : %+v ", data)
108 key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
109 a1.Logger.Debug("key : %+v ", key)
111 sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil)
113 errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
115 assert.Nil(t, errresp)
116 //Mock Assertion :Behavioral
117 sdlInst.AssertExpectations(t)
120 func TestCreatePolicyTypeInstance(t *testing.T) {
121 var policyInstanceID models.PolicyInstanceID
122 policyInstanceID = "123456"
123 var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
124 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
125 var policyTypeId models.PolicyTypeID
128 var instancedata map[string]interface{}
130 json.Unmarshal([]byte(httpBody), &instancedata)
132 data, _ := json.Marshal(instancedata)
133 a1.Logger.Debug("Marshaled data : %+v", string(data))
134 a1.Logger.Debug("instancekey : %+v", instancekey)
135 instancearr := []interface{}{instancekey, string(data)}
136 sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
138 metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
139 creation_timestamp := time.Now()
140 var metadatajson []interface{}
141 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
142 metadata, _ := json.Marshal(metadatajson)
143 a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
144 a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey)
145 metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
146 sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
147 rmrSenderInst.On("RmrSendToXapp", "httpBodyString").Return(true)
149 errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata)
151 assert.Nil(t, errresp)
152 sdlInst.AssertExpectations(t)
155 func TestGetPolicyInstance(t *testing.T) {
157 var policyTypeId models.PolicyTypeID
159 var policyInstanceID models.PolicyInstanceID
160 policyInstanceID = "123456"
165 "trigger_threshold":10
167 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
168 a1.Logger.Debug("httpBody String : %+v", httpBody)
169 a1.Logger.Debug("key : %+v", instancekey)
171 keys[0] = instancekey
173 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody, nil)
175 resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
176 a1.Logger.Error("err : %+v", err)
177 assert.NotNil(t, resp)
179 sdlInst.AssertExpectations(t)
182 func TestGetAllPolicyIntances(t *testing.T) {
183 var policyTypeId models.PolicyTypeID
185 resp, err := rh.GetAllPolicyInstance(policyTypeId)
186 a1.Logger.Error("err : %+v", err)
187 assert.Equal(t, 2, len(resp))
190 func TestDeletePolicyType(t *testing.T) {
192 policyTypeId := models.PolicyTypeID(20001)
193 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
198 sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(nil)
200 errresp := rh.DeletePolicyType(policyTypeId)
202 assert.Nil(t, errresp)
203 sdlInst.AssertExpectations(t)
206 func TestGetPolicyInstanceStatus(t *testing.T) {
207 var policyTypeId models.PolicyTypeID
209 var policyInstanceID models.PolicyInstanceID
210 policyInstanceID = "123456"
212 "created_at":"0001-01-01T00:00:00.000Z",
213 "instance_status":"NOT IN EFFECT"
215 instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
216 a1.Logger.Debug("httpBody String : %+v", httpBody)
217 a1.Logger.Debug("key : %+v", instancekey)
219 keys[0] = instancekey
220 sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody)
222 resp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
224 assert.NotNil(t, resp)
225 sdlInst.AssertExpectations(t)
228 func TestDeletePolicyInstance(t *testing.T) {
229 var policyTypeId models.PolicyTypeID
231 var policyInstanceID models.PolicyInstanceID
232 policyInstanceID = "123456"
233 var policyTypeSchema models.PolicyTypeSchema
234 name := "admission_control_policy_mine"
235 policyTypeSchema.Name = &name
236 policytypeid := int64(20001)
237 policyTypeSchema.PolicyTypeID = &policytypeid
238 description := "various parameters to control admission of dual connection"
239 policyTypeSchema.Description = &description
240 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)",},
241 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
242 policyTypeSchema.CreateSchema = schema
244 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
245 var policytypekeys [1]string
246 policytypekeys[0] = key
248 sdlInst.On("Get", a1MediatorNs, policytypekeys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
254 "trigger_threshold":10
256 instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
257 var instancekeys [1]string
258 instancekeys[0] = instancekey
260 sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(httpBody, nil)
262 var instanceMetadataKeys [1]string
263 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
264 instanceMetadataKeys[0] = instanceMetadataKey
266 "created_at":"2022-11-02 10:30:20",
267 "instance_status":"NOT IN EFFECT"
270 sdlInst.On("Get", a1MediatorNs, instanceMetadataKeys[:]).Return(httpBody, nil)
272 sdlInst.On("Remove", a1MediatorNs, instanceMetadataKeys[:]).Return(nil)
274 var metadatainstancekeys [1]string
275 metadatainstancekeys[0] = instancekey
277 sdlInst.On("Remove", a1MediatorNs, metadatainstancekeys[:]).Return(nil)
279 metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
280 deleted_timestamp := time.Now()
281 var metadatajson interface{}
282 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"}
283 metadata, _ := json.Marshal(metadatajson)
284 metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
286 sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
288 httpBodyString := `{"operation":"DELETE","payload":"","policy_instance_id":"123456","policy_type_id":"20001"}`
290 rmrSenderInst.On("RmrSendToXapp", httpBodyString).Return(true)
292 errresp := rh.DeletePolicyInstance(policyTypeId, policyInstanceID)
294 assert.Nil(t, errresp)
295 sdlInst.AssertExpectations(t)
298 type SdlMock struct {
302 func (s *SdlMock) GetAll(ns string) ([]string, error) {
303 args := s.MethodCalled("GetAll", ns)
304 return args.Get(0).([]string), nil
307 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
308 a1.Logger.Debug("Get Called ")
309 args := s.MethodCalled("Get", ns, keys)
310 a1.Logger.Debug("ns :%+v", args.Get(0))
311 policytypeid := int64(20001)
312 policyInstanceID := "123456"
313 var policySchemaString string
315 if keys[0] == "a1.policy_instance.20001.123456" {
316 policySchemaString = `{
320 "trigger_threshold":10
322 key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
323 } else if keys[0] == "a1.policy_type.20001" {
324 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}`
325 key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
326 } else if keys[0] == "a1.policy_inst_metadata.20001.123456" {
327 policySchemaString = `{
328 "created_at":"2022-11-02 10:30:20",
329 "instance_status":"NOT IN EFFECT"
331 key = a1InstanceMetadataPrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
333 a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
334 policyTypeSchema, _ := json.Marshal((policySchemaString))
335 a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
337 a1.Logger.Debug(" key for policy type %+v", key)
338 mp := map[string]interface{}{key: string(policySchemaString)}
339 a1.Logger.Debug("Get Called and mp return %+v ", mp)
342 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
343 args := s.MethodCalled("SetIfNotExists", ns, key, data)
344 return args.Bool(0), args.Error(1)
347 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
348 args := s.MethodCalled("Set", ns, pairs)
351 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
352 args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
353 return args.Bool(0), args.Error(1)
356 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string) bool {
357 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString)
361 func (s *SdlMock) Remove(ns string, keys []string) error {
362 args := s.MethodCalled("Remove", ns, keys)