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 type SdlMock struct {
 207         mock.Mock
 208 }
 209
 210 func (s *SdlMock) GetAll(ns string) ([]string, error) {
 211         args := s.MethodCalled("GetAll", ns)
 212         return args.Get(0).([]string), nil
 213 }
 214
 215 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 216         a1.Logger.Debug("Get Called ")
 217         args := s.MethodCalled("Get", ns, keys)
 218         a1.Logger.Debug("keys :%+v", args.Get(1))
 219         policytypeid := int64(20001)
 220         policyInstanceID := "123456"
 221         var policySchemaString string
 222         var key string
 223         if keys[0] == "a1.policy_instance.20001.123456" {
 224                 policySchemaString = `{
 225                         "enforce":true,
 226                         "window_length":20,
 227                    "blocking_rate":20,
 228                         "trigger_threshold":10
 229                         }`
 230                 key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 231         } else if keys[0] == "a1.policy_type.20001" {
 232                 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}`
 233                 key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
 234         }
 235         a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
 236         policyTypeSchema, _ := json.Marshal((policySchemaString))
 237         a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
 238
 239         a1.Logger.Debug(" key for policy type %+v", key)
 240         mp := map[string]interface{}{key: string(policySchemaString)}
 241         a1.Logger.Debug("Get Called and mp return %+v ", mp)
 242
 243         return mp, nil
 244 }
 245
 246 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
 247         args := s.MethodCalled("SetIfNotExists", ns, key, data)
 248         return args.Bool(0), args.Error(1)
 249 }
 250
 251 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
 252         args := s.MethodCalled("Set", ns, pairs)
 253         return args.Error(0)
 254 }
 255 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
 256         args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
 257         return args.Bool(0), args.Error(1)
 258 }
 259
 260 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string) bool {
 261         args := rmr.MethodCalled("RmrSendToXapp", httpBodyString)
 262         return args.Bool(0)
 263 }
 264
 265 func (s *SdlMock) Remove(ns string, keys []string) error {
 266         args := s.MethodCalled("Remove", ns, keys)
 267         return args.Error(0)
 268 }