a1-go/pkg/resthooks/resthooks_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2021 Samsung
   4
   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
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  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.
  16
  17    This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18    platform project (RICP).
  19 ==================================================================================
  20 */
  21 package resthooks
  22
  23 import (
  24         "encoding/json"
  25         "os"
  26         "strconv"
  27         "testing"
  28         "time"
  29
  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"
  34 )
  35
  36 type RmrSenderMock struct {
  37         mock.Mock
  38 }
  39
  40 var rh *Resthook
  41 var sdlInst *SdlMock
  42 var rmrSenderInst *RmrSenderMock
  43
  44 func TestMain(m *testing.M) {
  45         sdlInst = new(SdlMock)
  46
  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",
  53         }, nil)
  54         RMRclient = new(RMRClientMock)
  55         a1.Init()
  56         rh = createResthook(sdlInst, RMRclient)
  57         code := m.Run()
  58         os.Exit(code)
  59 }
  60
  61 func TestGetAllPolicyType(t *testing.T) {
  62         resp := rh.GetAllPolicyType()
  63         assert.Equal(t, 2, len(resp))
  64 }
  65
  66 func TestGetPolicyType(t *testing.T) {
  67
  68         policyTypeId := models.PolicyTypeID(20001)
  69
  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)
  81         var keys [1]string
  82         keys[0] = key
  83         //Setup Expectations
  84         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
  85         resp := rh.GetPolicyType(policyTypeId)
  86         assert.NotNil(t, resp)
  87
  88         sdlInst.AssertExpectations(t)
  89
  90 }
  91
  92 func TestCreatePolicyType(t *testing.T) {
  93         var policyTypeId models.PolicyTypeID
  94         policyTypeId = 20001
  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,},}`
 104
 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)
 110         //Setup Expectations
 111         sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil)
 112
 113         errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
 114         //Data Assertion
 115         assert.Nil(t, errresp)
 116         //Mock Assertion :Behavioral
 117         sdlInst.AssertExpectations(t)
 118 }
 119
 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
 126         policyTypeId = 20001
 127
 128         var instancedata map[string]interface{}
 129
 130         json.Unmarshal([]byte(httpBody), &instancedata)
 131
 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)
 137
 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", 20010).Return(true)
 148
 149         errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata)
 150
 151         assert.Nil(t, errresp)
 152         sdlInst.AssertExpectations(t)
 153 }
 154
 155 func TestGetPolicyInstance(t *testing.T) {
 156
 157         var policyTypeId models.PolicyTypeID
 158         policyTypeId = 20001
 159         var policyInstanceID models.PolicyInstanceID
 160         policyInstanceID = "123456"
 161         httpBody := `{
 162                 "enforce":true,
 163                 "window_length":20,
 164            "blocking_rate":20,
 165                 "trigger_threshold":10
 166                 }`
 167         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 168         a1.Logger.Debug("httpBody String : %+v", httpBody)
 169         a1.Logger.Debug("key   : %+v", instancekey)
 170         var keys [1]string
 171         keys[0] = instancekey
 172         //Setup Expectations
 173         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody, nil)
 174
 175         resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 176         a1.Logger.Error("err : %+v", err)
 177         assert.NotNil(t, resp)
 178
 179         sdlInst.AssertExpectations(t)
 180 }
 181
 182 func TestGetAllPolicyIntances(t *testing.T) {
 183         var policyTypeId models.PolicyTypeID
 184         policyTypeId = 20005
 185         resp, err := rh.GetAllPolicyInstance(policyTypeId)
 186         a1.Logger.Error("err : %+v", err)
 187         assert.Equal(t, 2, len(resp))
 188 }
 189
 190 func TestDeletePolicyType(t *testing.T) {
 191
 192         policyTypeId := models.PolicyTypeID(20001)
 193         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 194         var keys [1]string
 195         keys[0] = key
 196
 197         //Setup Expectations
 198         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(nil)
 199
 200         errresp := rh.DeletePolicyType(policyTypeId)
 201
 202         assert.Nil(t, errresp)
 203         sdlInst.AssertExpectations(t)
 204 }
 205
 206 func TestGetPolicyInstanceStatus(t *testing.T) {
 207         var policyTypeId models.PolicyTypeID
 208         policyTypeId = 20001
 209         var policyInstanceID models.PolicyInstanceID
 210         policyInstanceID = "123456"
 211         httpBody := `{
 212                 "created_at":"0001-01-01T00:00:00.000Z",
 213                 "instance_status":"NOT IN EFFECT"
 214                 }`
 215         instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 216         a1.Logger.Debug("httpBody String : %+v", httpBody)
 217         a1.Logger.Debug("key   : %+v", instancekey)
 218         var keys [1]string
 219         keys[0] = instancekey
 220         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody)
 221
 222         resp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
 223
 224         assert.NotNil(t, resp)
 225         sdlInst.AssertExpectations(t)
 226 }
 227
 228 func TestDeletePolicyInstance(t *testing.T) {
 229         var policyTypeId models.PolicyTypeID
 230         policyTypeId = 20001
 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
 243
 244         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 245         var policytypekeys [1]string
 246         policytypekeys[0] = key
 247
 248         sdlInst.On("Get", a1MediatorNs, policytypekeys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
 249
 250         httpBody := `{
 251                 "enforce":true,
 252                 "window_length":20,
 253            "blocking_rate":20,
 254                 "trigger_threshold":10
 255                 }`
 256         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 257         var instancekeys [1]string
 258         instancekeys[0] = instancekey
 259
 260         sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(httpBody, nil)
 261
 262         var instanceMetadataKeys [1]string
 263         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 264         instanceMetadataKeys[0] = instanceMetadataKey
 265         httpBody = `{
 266                 "created_at":"2022-11-02 10:30:20",
 267                         "instance_status":"NOT IN EFFECT"
 268                 }`
 269
 270         sdlInst.On("Get", a1MediatorNs, instanceMetadataKeys[:]).Return(httpBody, nil)
 271
 272         sdlInst.On("Remove", a1MediatorNs, instanceMetadataKeys[:]).Return(nil)
 273
 274         var metadatainstancekeys [1]string
 275         metadatainstancekeys[0] = instancekey
 276
 277         sdlInst.On("Remove", a1MediatorNs, metadatainstancekeys[:]).Return(nil)
 278
 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)}
 285
 286         sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
 287
 288         httpBodyString := `{"operation":"DELETE","payload":"","policy_instance_id":"123456","policy_type_id":"20001"}`
 289
 290         rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20010).Return(true)
 291
 292         errresp := rh.DeletePolicyInstance(policyTypeId, policyInstanceID)
 293
 294         assert.Nil(t, errresp)
 295         sdlInst.AssertExpectations(t)
 296 }
 297 func TestDataDelivery(t *testing.T) {
 298
 299         httpBody := `{
 300                 "job":"1",
 301                 "payload":"payload"
 302                 }
 303                 `
 304         var instancedata interface{}
 305
 306         json.Unmarshal([]byte(httpBody), &instancedata)
 307         a1.Logger.Debug("Marshaled data : %+v", (instancedata))
 308         httpBodyString := `{"ei_job_id":"1","payload":"payload"}`
 309         rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20017).Return(true)
 310         errresp := rh.DataDelivery(instancedata)
 311
 312         assert.Nil(t, errresp)
 313         sdlInst.AssertExpectations(t)
 314 }
 315
 316 type SdlMock struct {
 317         mock.Mock
 318 }
 319
 320 func (s *SdlMock) GetAll(ns string) ([]string, error) {
 321         args := s.MethodCalled("GetAll", ns)
 322         return args.Get(0).([]string), nil
 323 }
 324
 325 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 326         a1.Logger.Debug("Get Called ")
 327         args := s.MethodCalled("Get", ns, keys)
 328         a1.Logger.Debug("ns :%+v", args.Get(0))
 329         policytypeid := int64(20001)
 330         policyInstanceID := "123456"
 331         var policySchemaString string
 332         var key string
 333         if keys[0] == "a1.policy_instance.20001.123456" {
 334                 policySchemaString = `{
 335                         "enforce":true,
 336                         "window_length":20,
 337                    "blocking_rate":20,
 338                         "trigger_threshold":10
 339                         }`
 340                 key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 341         } else if keys[0] == "a1.policy_type.20001" {
 342                 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}`
 343                 key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
 344         } else if keys[0] == "a1.policy_inst_metadata.20001.123456" {
 345                 policySchemaString = `{
 346                         "created_at":"2022-11-02 10:30:20",
 347                         "instance_status":"NOT IN EFFECT"
 348                         }`
 349                 key = a1InstanceMetadataPrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 350         }
 351         a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
 352         policyTypeSchema, _ := json.Marshal((policySchemaString))
 353         a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
 354
 355         a1.Logger.Debug(" key for policy type %+v", key)
 356         mp := map[string]interface{}{key: string(policySchemaString)}
 357         a1.Logger.Debug("Get Called and mp return %+v ", mp)
 358         return mp, nil
 359 }
 360 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
 361         args := s.MethodCalled("SetIfNotExists", ns, key, data)
 362         return args.Bool(0), args.Error(1)
 363 }
 364
 365 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
 366         args := s.MethodCalled("Set", ns, pairs)
 367         return args.Error(0)
 368 }
 369 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
 370         args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
 371         return args.Bool(0), args.Error(1)
 372 }
 373
 374 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string, mtype int) bool {
 375         if httpBodyString == `{"blocking_rate":20,"enforce":true,"trigger_threshold":10,"window_length":20}` {
 376                 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString, mtype)
 377                 return args.Bool(0)
 378         } else if httpBodyString == `{"ei_job_id":"1","payload":"payload"}` {
 379                 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString, mtype)
 380                 return args.Bool(0)
 381         }
 382         return true
 383 }
 384
 385 func (s *SdlMock) Remove(ns string, keys []string) error {
 386         args := s.MethodCalled("Remove", ns, keys)
 387         return args.Error(0)
 388 }