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 var rh *Resthook
  37 var sdlInst *SdlMock
  38
  39 func TestMain(m *testing.M) {
  40         sdlInst = new(SdlMock)
  41
  42         sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos",
  43                 "a1.policy_instance.20005.123456",
  44                 "a1.policy_instance.20005.234567",
  45                 "a1.policy_type.1006001",
  46                 "a1.policy_type.20000",
  47                 "a1.policy_inst_metadata.1006001.qos",
  48         }, nil)
  49
  50         a1.Init()
  51         rh = createResthook(sdlInst)
  52         code := m.Run()
  53         os.Exit(code)
  54 }
  55
  56 func TestGetAllPolicyType(t *testing.T) {
  57         resp := rh.GetAllPolicyType()
  58         assert.Equal(t, 2, len(resp))
  59 }
  60
  61 func TestGetPolicyType(t *testing.T) {
  62
  63         policyTypeId := models.PolicyTypeID(20001)
  64
  65         var policyTypeSchema models.PolicyTypeSchema
  66         name := "admission_control_policy_mine"
  67         policyTypeSchema.Name = &name
  68         policytypeid := int64(20001)
  69         policyTypeSchema.PolicyTypeID = &policytypeid
  70         description := "various parameters to control admission of dual connection"
  71         policyTypeSchema.Description = &description
  72         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)",},
  73 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
  74         policyTypeSchema.CreateSchema = schema
  75         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
  76         var keys [1]string
  77         keys[0] = key
  78         //Setup Expectations
  79         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
  80         resp := rh.GetPolicyType(policyTypeId)
  81         assert.NotNil(t, resp)
  82
  83         sdlInst.AssertExpectations(t)
  84
  85 }
  86
  87 func TestCreatePolicyType(t *testing.T) {
  88         var policyTypeId models.PolicyTypeID
  89         policyTypeId = 20001
  90         var policyTypeSchema models.PolicyTypeSchema
  91         name := "admission_control_policy_mine"
  92         policyTypeSchema.Name = &name
  93         policytypeid := int64(20001)
  94         policyTypeSchema.PolicyTypeID = &policytypeid
  95         description := "various parameters to control admission of dual connection"
  96         policyTypeSchema.Description = &description
  97         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)",},
  98 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
  99
 100         data, err := policyTypeSchema.MarshalBinary()
 101         a1.Logger.Debug("error : %+v ", err)
 102         a1.Logger.Debug("data : %+v ", data)
 103         key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
 104         a1.Logger.Debug("key : %+v ", key)
 105         //Setup Expectations
 106         sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil)
 107
 108         errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
 109         //Data Assertion
 110         assert.Nil(t, errresp)
 111         //Mock Assertion :Behavioral
 112         sdlInst.AssertExpectations(t)
 113 }
 114
 115 func TestCreatePolicyTypeInstance(t *testing.T) {
 116         var policyInstanceID models.PolicyInstanceID
 117         policyInstanceID = "123456"
 118         var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
 119         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 120         var policyTypeId models.PolicyTypeID
 121         policyTypeId = 20001
 122
 123         var instancedata map[string]interface{}
 124
 125         json.Unmarshal([]byte(httpBody), &instancedata)
 126
 127         data, _ := json.Marshal(instancedata)
 128         a1.Logger.Debug("Marshaled data : %+v", string(data))
 129         a1.Logger.Debug("instancekey   : %+v", instancekey)
 130         instancearr := []interface{}{instancekey, string(data)}
 131         sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
 132
 133         metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 134         creation_timestamp := time.Now()
 135         var metadatajson []interface{}
 136         metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
 137         metadata, _ := json.Marshal(metadatajson)
 138         a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
 139         a1.Logger.Debug("metadatainstancekey   : %+v", metadatainstancekey)
 140         metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
 141         sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
 142
 143         errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata)
 144
 145         assert.Nil(t, errresp)
 146         sdlInst.AssertExpectations(t)
 147 }
 148
 149 func TestGetPolicyInstance(t *testing.T) {
 150
 151         var policyTypeId models.PolicyTypeID
 152         policyTypeId = 20001
 153         var policyInstanceID models.PolicyInstanceID
 154         policyInstanceID = "123456"
 155         httpBody := `{
 156                 "enforce":true,
 157                 "window_length":20,
 158            "blocking_rate":20,
 159                 "trigger_threshold":10
 160                 }`
 161         instancekey := a1PolicyPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 162         a1.Logger.Debug("httpBody String : %+v", httpBody)
 163         a1.Logger.Debug("key   : %+v", instancekey)
 164         var keys [1]string
 165         keys[0] = instancekey
 166         //Setup Expectations
 167         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody, nil)
 168
 169         resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 170         a1.Logger.Error("err : %+v", err)
 171         assert.NotNil(t, resp)
 172
 173         sdlInst.AssertExpectations(t)
 174 }
 175
 176 func TestGetAllPolicyIntances(t *testing.T) {
 177         var policyTypeId models.PolicyTypeID
 178         policyTypeId = 20005
 179         resp, err := rh.GetAllPolicyInstance(policyTypeId)
 180         a1.Logger.Error("err : %+v", err)
 181         assert.Equal(t, 2, len(resp))
 182 }
 183
 184 type SdlMock struct {
 185         mock.Mock
 186 }
 187
 188 func (s *SdlMock) GetAll(ns string) ([]string, error) {
 189         args := s.MethodCalled("GetAll", ns)
 190         return args.Get(0).([]string), nil
 191 }
 192
 193 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 194         a1.Logger.Debug("Get Called ")
 195         args := s.MethodCalled("Get", ns, keys)
 196         a1.Logger.Debug("keys :%+v", args.Get(1))
 197         policytypeid := int64(20001)
 198         policyInstanceID := "123456"
 199         var policySchemaString string
 200         var key string
 201         if keys[0] == "a1.policy_instance.20001.123456" {
 202                 policySchemaString = `{
 203                         "enforce":true,
 204                         "window_length":20,
 205                    "blocking_rate":20,
 206                         "trigger_threshold":10
 207                         }`
 208                 key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID)
 209         } else if keys[0] == "a1.policy_type.20001" {
 210                 policySchemaString = `{"name":"admission_control_policy_mine",
 211                 "description":"various parameters to control admission of dual connection",
 212                 "policy_type_id": 20001,
 213                 "create_schema":{"$schema": "http://json-schema.org/draft-07/schema#","type":    "object",
 214                 "properties": {"enforce": {"type":    "boolean","default": "true"},
 215                 "window_length": {"type":"integer","default":     1,"minimum":     1,"maximum":     60,
 216                 "description": "Sliding window length (in minutes)"},
 217                 "blocking_rate": {"type":        "number","default":     10,"minimum":     1,"maximum":     1001,
 218                 "description": "% Connections to block"},
 219                 "additionalProperties": false}}}`
 220                 key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10)
 221         }
 222         a1.Logger.Error(" policy SchemaString %+v", policySchemaString)
 223         policyTypeSchema, _ := json.Marshal((policySchemaString))
 224         a1.Logger.Error(" policyTypeSchema %+v", string(policyTypeSchema))
 225         a1.Logger.Error(" key for policy type %+v", key)
 226         mp := map[string]interface{}{key: string(policyTypeSchema)}
 227         a1.Logger.Error("Get Called and mp return %+v ", mp)
 228         return mp, nil
 229 }
 230
 231 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
 232         args := s.MethodCalled("SetIfNotExists", ns, key, data)
 233         return args.Bool(0), args.Error(1)
 234 }
 235
 236 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
 237         args := s.MethodCalled("Set", ns, pairs)
 238         return args.Error(0)
 239 }
 240 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
 241         args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
 242         return args.Bool(0), args.Error(1)
 243 }