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 type SdlMock struct {
 191         mock.Mock
 192 }
 193
 194 func (s *SdlMock) GetAll(ns string) ([]string, error) {
 195         args := s.MethodCalled("GetAll", ns)
 196         return args.Get(0).([]string), nil
 197 }
 198
 199 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 200         a1.Logger.Debug("Get Called ")
 201         args := s.MethodCalled("Get", ns, keys)
 202         a1.Logger.Debug("keys :%+v", args.Get(1))
 203         policytypeid := int64(20001)
 204         policyInstanceID := "123456"
 205         var policySchemaString string
 206         var key string
 207         if keys[0] == "a1.policy_instance.20001.123456" {
 208                 policySchemaString = `{
 209                         "enforce":true,
 210                         "window_length":20,
 211                    "blocking_rate":20,
 212                         "trigger_threshold":10
 213                         }`
 214                 key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 215         } else if keys[0] == "a1.policy_type.20001" {
 216                 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}`
 217                 key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
 218         }
 219         a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
 220         policyTypeSchema, _ := json.Marshal((policySchemaString))
 221         a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
 222
 223         a1.Logger.Debug(" key for policy type %+v", key)
 224         mp := map[string]interface{}{key: string(policySchemaString)}
 225         a1.Logger.Debug("Get Called and mp return %+v ", mp)
 226
 227         return mp, nil
 228 }
 229
 230 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
 231         args := s.MethodCalled("SetIfNotExists", ns, key, data)
 232         return args.Bool(0), args.Error(1)
 233 }
 234
 235 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
 236         args := s.MethodCalled("Set", ns, pairs)
 237         return args.Error(0)
 238 }
 239 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
 240         args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
 241         return args.Bool(0), args.Error(1)
 242 }
 243
 244 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string) bool {
 245         args := rmr.MethodCalled("RmrSendToXapp", httpBodyString)
 246         return args.Bool(0)
 247 }