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").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 type SdlMock struct {
 229         mock.Mock
 230 }
 231
 232 func (s *SdlMock) GetAll(ns string) ([]string, error) {
 233         args := s.MethodCalled("GetAll", ns)
 234         return args.Get(0).([]string), nil
 235 }
 236
 237 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 238         a1.Logger.Debug("Get Called ")
 239         args := s.MethodCalled("Get", ns, keys)
 240         a1.Logger.Debug("ns :%+v", args.Get(0))
 241         policytypeid := int64(20001)
 242         policyInstanceID := "123456"
 243         var policySchemaString string
 244         var key string
 245         if keys[0] == "a1.policy_instance.20001.123456" {
 246                 policySchemaString = `{
 247                         "enforce":true,
 248                         "window_length":20,
 249                    "blocking_rate":20,
 250                         "trigger_threshold":10
 251                         }`
 252                 key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 253         } else if keys[0] == "a1.policy_type.20001" {
 254                 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}`
 255                 key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
 256         } else if keys[0] == "a1.policy_inst_metadata.20001.123456" {
 257                 policySchemaString = `{
 258                         "created_at":"0001-01-01T00:00:00.000Z",
 259                         "instance_status":"NOT IN EFFECT"
 260                         }`
 261                 key = a1InstanceMetadataPrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 262         }
 263         a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
 264         policyTypeSchema, _ := json.Marshal((policySchemaString))
 265         a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
 266
 267         a1.Logger.Debug(" key for policy type %+v", key)
 268         mp := map[string]interface{}{key: string(policySchemaString)}
 269         a1.Logger.Debug("Get Called and mp return %+v ", mp)
 270         return mp, nil
 271 }
 272 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
 273         args := s.MethodCalled("SetIfNotExists", ns, key, data)
 274         return args.Bool(0), args.Error(1)
 275 }
 276
 277 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
 278         args := s.MethodCalled("Set", ns, pairs)
 279         return args.Error(0)
 280 }
 281 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
 282         args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
 283         return args.Bool(0), args.Error(1)
 284 }
 285
 286 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string) bool {
 287         args := rmr.MethodCalled("RmrSendToXapp", httpBodyString)
 288         return args.Bool(0)
 289 }
 290
 291 func (s *SdlMock) Remove(ns string, keys []string) error {
 292         args := s.MethodCalled("Remove", ns, keys)
 293         return args.Error(0)
 294 }