pkg/resthooks/resthooks_test.go

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2021 Samsung
   5
   6          Licensed under the Apache License, Version 2.0 (the "License");
   7          you may not use this file except in compliance with the License.
   8          You may obtain a copy of the License at
   9
  10              http://www.apache.org/licenses/LICENSE-2.0
  11
  12          Unless required by applicable law or agreed to in writing, software
  13          distributed under the License is distributed on an "AS IS" BASIS,
  14          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15          See the License for the specific language governing permissions and
  16          limitations under the License.
  17
  18          This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19          platform project (RICP).
  20
  21 ==================================================================================
  22 */
  23 package resthooks
  24
  25 import (
  26         "encoding/json"
  27         "os"
  28         "strconv"
  29         "testing"
  30         "time"
  31         "errors"
  32         "fmt"
  33         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
  34         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
  35         "github.com/stretchr/testify/assert"
  36         "github.com/stretchr/testify/mock"
  37 )
  38
  39 type RmrSenderMock struct {
  40         mock.Mock
  41 }
  42
  43 var rh *Resthook
  44 var sdlInst *SdlMock
  45 var rmrSenderInst *RmrSenderMock
  46
  47 func TestMain(m *testing.M) {
  48         sdlInst = new(SdlMock)
  49
  50         sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos",
  51                 "a1.policy_instance.20005.123456",
  52                 "a1.policy_instance.20005.234567",
  53                 "a1.policy_type.1006001",
  54                 "a1.policy_type.20000",
  55                 "a1.policy_inst_metadata.1006001.qos",
  56         }, nil).Once()
  57         rmrSenderInst = new(RmrSenderMock)
  58         a1.Init()
  59         rh = createResthook(sdlInst, rmrSenderInst)
  60         code := m.Run()
  61         os.Exit(code)
  62 }
  63
  64 func TestHealth(t *testing.T) {
  65         resp := rh.GetA1Health()
  66         if resp == true {
  67                 a1.Logger.Debug("A1 is healthy ")
  68                 assert.Equal(t, true, resp)
  69         } else {
  70                 a1.Logger.Debug("A1 is unhealthy")
  71                 assert.Equal(t, false, resp)
  72         }
  73 }
  74
  75 func TestHealthFail(t *testing.T) {
  76         keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
  77         sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
  78         resp := rh.GetA1Health()
  79         if resp == true {
  80                 a1.Logger.Debug("A1 is healthy ")
  81                 assert.Equal(t, true, resp)
  82         } else {
  83                 a1.Logger.Debug("A1 is unhealthy")
  84                 assert.Equal(t, false, resp)
  85         }
  86 }
  87
  88 func TestGetAllPolicyType(t *testing.T) {
  89         keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
  90         sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
  91         resp := rh.GetAllPolicyType()
  92         assert.Equal(t, 2, len(resp))
  93 }
  94
  95 func TestGetAllPolicyTypeFail(t *testing.T) {
  96         keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
  97         sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
  98         resp := rh.GetAllPolicyType()
  99         assert.Equal(t, 0, len(resp))
 100 }
 101
 102 func TestGetPolicyType(t *testing.T) {
 103
 104         policyTypeId := models.PolicyTypeID(20001)
 105
 106         var policyTypeSchema models.PolicyTypeSchema
 107         name := "admission_control_policy_mine"
 108         policyTypeSchema.Name = &name
 109         policytypeid := int64(20001)
 110         policyTypeSchema.PolicyTypeID = &policytypeid
 111         description := "various parameters to control admission of dual connection"
 112         policyTypeSchema.Description = &description
 113         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)",},
 114 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 115         policyTypeSchema.CreateSchema = schema
 116         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 117         var keys [1]string
 118         keys[0] = key
 119         //Setup Expectations
 120         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
 121         resp,err := rh.GetPolicyType(policyTypeId)
 122         assert.NotNil(t, resp)
 123         assert.Nil(t, err)
 124         sdlInst.AssertExpectations(t)
 125
 126 }
 127
 128 func TestCreatePolicyType(t *testing.T) {
 129         var policyTypeId models.PolicyTypeID
 130         policyTypeId = 20001
 131         var policyTypeSchema models.PolicyTypeSchema
 132         name := "admission_control_policy_mine"
 133         policyTypeSchema.Name = &name
 134         policytypeid := int64(20001)
 135         policyTypeSchema.PolicyTypeID = &policytypeid
 136         description := "various parameters to control admission of dual connection"
 137         policyTypeSchema.Description = &description
 138         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)",},
 139 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 140
 141         data, err := policyTypeSchema.MarshalBinary()
 142         a1.Logger.Debug("error : %+v ", err)
 143         a1.Logger.Debug("data : %+v ", data)
 144         key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
 145         a1.Logger.Debug("key : %+v ", key)
 146         //Setup Expectations
 147         sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(true, nil).Once()
 148         errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
 149         //Data Assertion
 150         assert.Nil(t, errresp)
 151         //Mock Assertion :Behavioral
 152         sdlInst.AssertExpectations(t)
 153 }
 154
 155
 156 func TestCreatePolicyType2(t *testing.T) {
 157         var policyTypeId models.PolicyTypeID
 158         policyTypeId = 20001
 159         var policyTypeSchema models.PolicyTypeSchema
 160         name := "admission_control_policy_mine"
 161         policyTypeSchema.Name = &name
 162         policytypeid := int64(20001)
 163         policyTypeSchema.PolicyTypeID = &policytypeid
 164         description := "various parameters to control admission of dual connection"
 165         policyTypeSchema.Description = &description
 166         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)",},
 167 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 168
 169         data, err := policyTypeSchema.MarshalBinary()
 170         a1.Logger.Debug("error : %+v ", err)
 171         a1.Logger.Debug("data : %+v ", data)
 172         key := a1PolicyPrefix + strconv.FormatInt(20001, 10)
 173         a1.Logger.Debug("key : %+v ", key)
 174         //Setup Expectations
 175         sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(false, nil).Once()
 176         resp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
 177         //Data Assertion
 178         assert.NotNil(t, resp)
 179         //Mock Assertion :Behavioral
 180         sdlInst.AssertExpectations(t)
 181 }
 182
 183
 184
 185
 186 func TestGetPolicyInstance(t *testing.T) {
 187
 188         var policyTypeId models.PolicyTypeID
 189         policyTypeId = 20001
 190         var policyInstanceID models.PolicyInstanceID
 191         policyInstanceID = "123456"
 192         httpBody := `{
 193                 "enforce":true,
 194                 "window_length":20,
 195            "blocking_rate":20,
 196                 "trigger_threshold":10
 197                 }`
 198         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 199         a1.Logger.Debug("httpBody String : %+v", httpBody)
 200         a1.Logger.Debug("key   : %+v", instancekey)
 201         var keys [1]string
 202         keys[0] = instancekey
 203         //Setup Expectations
 204         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody, nil)
 205
 206         resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 207         a1.Logger.Error("err : %+v", err)
 208         assert.NotNil(t, resp)
 209
 210         sdlInst.AssertExpectations(t)
 211 }
 212
 213 func TestGetPolicyInstanceFail(t *testing.T) {
 214
 215         var policyTypeId models.PolicyTypeID
 216         policyTypeId = 0
 217         var policyInstanceID models.PolicyInstanceID
 218         policyInstanceID = ""
 219         httpBody := `{
 220                 "enforce":true,
 221                 "window_length":20,
 222            "blocking_rate":20,
 223                 "trigger_threshold":10
 224                 }`
 225         instancekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 226         a1.Logger.Debug("httpBody String : %+v", httpBody)
 227         a1.Logger.Debug("key   : %+v", instancekey)
 228         var keys [1]string
 229         keys[0] = instancekey
 230         testmp1 := map[string]interface{}{instancekey: string(httpBody)}
 231         //Setup Expectations
 232         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(testmp1, errors.New("Some Error"))
 233
 234         resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 235         a1.Logger.Error("err : %+v", err)
 236         assert.Error(t, err)
 237         assert.Equal(t, 0, len(resp))
 238         sdlInst.AssertExpectations(t)
 239 }
 240
 241 func TestGetAllPolicyIntances(t *testing.T) {
 242         var policyTypeId models.PolicyTypeID
 243         policyTypeId = 20005
 244         keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
 245         sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
 246         resp, err := rh.GetAllPolicyInstance(policyTypeId)
 247         fmt.Println("GETALL is ",resp)
 248         assert.NoError(t, err)
 249         assert.Equal(t, 2, len(resp))
 250 }
 251
 252
 253 func TestDeletePolicyType(t *testing.T) {
 254
 255         policyTypeId := models.PolicyTypeID(20001)
 256         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 257         var keys [1]string
 258         keys[0] = key
 259
 260         //Setup Expectations
 261         sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",},nil).Once()
 262         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(nil)
 263
 264         errresp := rh.DeletePolicyType(policyTypeId)
 265
 266         assert.Nil(t, errresp)
 267         sdlInst.AssertExpectations(t)
 268 }
 269
 270 func TestGetPolicyInstanceStatus(t *testing.T) {
 271         var policyTypeId models.PolicyTypeID
 272         policyTypeId = 20001
 273         var policyInstanceID models.PolicyInstanceID
 274         policyInstanceID = "123456"
 275         httpBody := `{
 276                 "created_at":"0001-01-01T00:00:00.000Z",
 277                 "instance_status":"NOT IN EFFECT"
 278                 }`
 279         instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 280         a1.Logger.Debug("httpBody String : %+v", httpBody)
 281         a1.Logger.Debug("key   : %+v", instancekey)
 282         var keys [1]string
 283         keys[0] = instancekey
 284         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody,nil)
 285         instancekey = a1HandlerPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 286         var instancekeys [1]string
 287         instancekeys[0] = instancekey
 288         instancearr := []interface{}{instancekey, "OK"}
 289         sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(instancearr, nil)
 290         resp, errresp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
 291
 292         assert.Nil(t, errresp)
 293         assert.NotNil(t, resp)
 294         sdlInst.AssertExpectations(t)
 295 }
 296
 297 func TestDeletePolicyInstance(t *testing.T) {
 298         var policyTypeId models.PolicyTypeID
 299         policyTypeId = 20001
 300         var policyInstanceID models.PolicyInstanceID
 301         policyInstanceID = "123456"
 302         var policyTypeSchema models.PolicyTypeSchema
 303         name := "admission_control_policy_mine"
 304         policyTypeSchema.Name = &name
 305         policytypeid := int64(20001)
 306         policyTypeSchema.PolicyTypeID = &policytypeid
 307         description := "various parameters to control admission of dual connection"
 308         policyTypeSchema.Description = &description
 309         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)",},
 310
 311 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 312
 313         policyTypeSchema.CreateSchema = schema
 314
 315         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 316         var policytypekeys [1]string
 317         policytypekeys[0] = key
 318
 319         sdlInst.On("Get", a1MediatorNs, policytypekeys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil)
 320
 321         httpBody := `{
 322                         "enforce":true,
 323                         "window_length":20,
 324                    "blocking_rate":20,
 325                         "trigger_threshold":10
 326                         }`
 327         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 328         var instancekeys [1]string
 329         instancekeys[0] = instancekey
 330
 331         sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(httpBody, nil)
 332
 333         var instanceMetadataKeys [1]string
 334         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 335         instanceMetadataKeys[0] = instanceMetadataKey
 336         httpBody = `{
 337                         "created_at":"2022-11-02 10:30:20",
 338                                 "instance_status":"NOT IN EFFECT"
 339                         }`
 340
 341         sdlInst.On("Get", a1MediatorNs, instanceMetadataKeys[:]).Return(httpBody, nil)
 342
 343         sdlInst.On("Remove", a1MediatorNs, instanceMetadataKeys[:]).Return(nil)
 344
 345         var metadatainstancekeys [1]string
 346         metadatainstancekeys[0] = instancekey
 347
 348         sdlInst.On("Remove", a1MediatorNs, metadatainstancekeys[:]).Return(nil)
 349
 350         metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 351         deleted_timestamp := time.Now()
 352         var metadatajson interface{}
 353         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"}
 354         metadata, _ := json.Marshal(metadatajson)
 355         metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
 356
 357         sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
 358
 359         httpBodyString := `{"operation":"DELETE","payload":"","policy_instance_id":"123456","policy_type_id":"20001"}`
 360
 361         rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20010, int(policyTypeId)).Return(true)
 362         notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 363         var notificationDestinationkeys [1]string
 364         notificationDestinationkeys[0] = notificationDestinationkey
 365         sdlInst.On("Remove", a1MediatorNs, notificationDestinationkeys[:]).Return(nil)
 366         errresp := rh.DeletePolicyInstance(policyTypeId, policyInstanceID)
 367
 368         assert.Nil(t, errresp)
 369         sdlInst.AssertExpectations(t)
 370 }
 371 func TestDataDelivery(t *testing.T) {
 372
 373         httpBody := `{
 374                 "job":"1",
 375                 "payload":"payload"
 376                 }
 377                 `
 378         var instancedata interface{}
 379
 380         json.Unmarshal([]byte(httpBody), &instancedata)
 381         a1.Logger.Debug("Marshaled data : %+v", (instancedata))
 382         httpBodyString := `{"ei_job_id":"1","payload":"payload"}`
 383         rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20017, -1).Return(true)
 384         errresp := rh.DataDelivery(instancedata)
 385
 386         assert.Nil(t, errresp)
 387         sdlInst.AssertExpectations(t)
 388 }
 389 /*
 390 func TestDataDeliveryFail(t *testing.T) {
 391
 392         httpBody := `{
 393                 "job":"1",
 394                 "payload":"payload"
 395                 }`
 396         var instancedata interface{}
 397
 398         json.Unmarshal([]byte(httpBody), &instancedata)
 399         a1.Logger.Debug("Marshaled data : %+v", (instancedata))
 400         httpBodyString := `{"ei_job_id1":"1","payload":"payload"}`
 401         rmrSenderInst.On("RmrSendToXapp", httpBodyString, 20017, -1).Return(false)
 402         errresp := rh.DataDelivery(instancedata)
 403
 404         assert.NotNil(t, errresp)
 405         sdlInst.AssertExpectations(t)
 406 }
 407 */
 408
 409 func TestGetMetaData(t *testing.T) {
 410         var policyTypeId models.PolicyTypeID
 411         policyTypeId = 20001
 412         var policyInstanceID models.PolicyInstanceID
 413         policyInstanceID = "123456"
 414         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 415         a1.Logger.Debug("key : %+v", instanceMetadataKey)
 416         var keys [1]string
 417         keys[0] = instanceMetadataKey
 418         policySchemaString := `{
 419                 "created_at":"2022-11-02 10:30:20",
 420                 "instance_status":"NOT IN EFFECT"
 421                 }`
 422         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{instanceMetadataKey: policySchemaString}, nil)
 423         resp, errresp := rh.getMetaData(policyTypeId, policyInstanceID)
 424         assert.Nil(t, errresp)
 425         assert.NotNil(t, resp)
 426         sdlInst.AssertExpectations(t)
 427 }
 428
 429 func TestGetMetaDataFail(t *testing.T) {
 430         var policyTypeId models.PolicyTypeID
 431         policyTypeId = 0
 432         var policyInstanceID models.PolicyInstanceID
 433         policyInstanceID = ""
 434         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 435         a1.Logger.Debug("key : %+v", instanceMetadataKey)
 436         var keys [1]string
 437         keys[0] = instanceMetadataKey
 438         policySchemaString := `{
 439                 "created_at":"2022-11-02 10:30:20",
 440                 "instance_status":"NOT IN EFFECT"
 441                 }`
 442         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{instanceMetadataKey: policySchemaString}, errors.New("Some Error"))
 443         _, errresp := rh.getMetaData(policyTypeId, policyInstanceID)
 444         assert.NotNil(t, errresp)
 445 }
 446
 447
 448
 449 func TestGetAllPolicyIntancesFail1(t *testing.T) {
 450         var policyTypeId models.PolicyTypeID
 451         policyTypeId = 20009
 452         keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
 453         sdlInst.On("GetAll", "A1m_ns").Return(keys,nil).Once()
 454         resp, err := rh.GetAllPolicyInstance(policyTypeId)
 455         fmt.Println("GETALL is ",resp)
 456         fmt.Println("GETALL is ",err)
 457         assert.Equal(t, 0, len(resp))
 458 }
 459
 460 func TestGetAllPolicyIntancesFail2(t *testing.T) {
 461         keys := []string{"",}
 462         sdlInst.On("GetAll", "A1m_ns").Return(keys, errors.New("Some Error")).Once()
 463         resp, err := rh.GetAllPolicyInstance(0)
 464         fmt.Println("GETALL is ",resp)
 465         fmt.Println("GETALL is ",err)
 466         assert.Error(t, err)
 467         assert.Equal(t, 0, len(resp))
 468 }
 469
 470
 471
 472 func TestGetPolicyTypeFail(t *testing.T) {
 473
 474         policyTypeId := models.PolicyTypeID(0)
 475
 476         var policyTypeSchema models.PolicyTypeSchema
 477         name := "admission_control_policy_mine"
 478         policyTypeSchema.Name = &name
 479         policytypeid := int64(0)
 480         policyTypeSchema.PolicyTypeID = &policytypeid
 481         description := "various parameters to control admission of dual connection"
 482         policyTypeSchema.Description = &description
 483         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)",},
 484 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 485         policyTypeSchema.CreateSchema = schema
 486         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 487         var keys [1]string
 488         keys[0] = key
 489         //Setup Expectations
 490         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, errors.New("Some Error")).Once()
 491         resp,err := rh.GetPolicyType(policyTypeId)
 492         assert.Nil(t, resp)
 493         assert.NotNil(t, err)
 494         //sdlInst.AssertExpectations(t)
 495
 496 }
 497
 498 func TestCreatePolicyTypeFail(t *testing.T) {
 499         var policyTypeId models.PolicyTypeID
 500         policyTypeId = 0
 501         var policyTypeSchema models.PolicyTypeSchema
 502         name := "admission_control_policy_mine"
 503         policyTypeSchema.Name = &name
 504         policytypeid := int64(0)
 505         policyTypeSchema.PolicyTypeID = &policytypeid
 506         description := "various parameters to control admission of dual connection"
 507         policyTypeSchema.Description = &description
 508         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)",},
 509 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 510
 511         data, err := policyTypeSchema.MarshalBinary()
 512         a1.Logger.Debug("error : %+v ", err)
 513         a1.Logger.Debug("data : %+v ", data)
 514         key := a1PolicyPrefix + strconv.FormatInt(0, 10)
 515         a1.Logger.Debug("key : %+v ", key)
 516         //Setup Expectations
 517         sdlInst.On("SetIfNotExists", a1MediatorNs, key, string(data)).Return(false, errors.New("Some Error")).Once()
 518         errresp := rh.CreatePolicyType(policyTypeId, policyTypeSchema)
 519         //Data Assertion
 520         assert.NotNil(t, errresp)
 521         //Mock Assertion :Behavioral
 522         //sdlInst.AssertExpectations(t)
 523 }
 524
 525 func TestValidateInvalidJson(t *testing.T) {
 526
 527          schemaString := `{"$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)",},
 528 "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}`
 529          httpBodyString := `{"blocking_rate"::20,"enforce"::true,"trigger_threshold":10,"window_length":20}`
 530          resp := validate(httpBodyString , schemaString)
 531          assert.Equal(t, false, resp)
 532 }
 533
 534 func TestValidateInvalidSchema(t *testing.T) {
 535          schemaString := `{"$schema": "http://json-schema.org/draft-07/sc"}`
 536          httpBodyString := `{"blocking_rate":20, 20:true, 30:10,"window_length":20}`
 537          resp := validate(httpBodyString , schemaString)
 538          assert.Equal(t, false, resp)
 539 }
 540
 541 func TestValidateIntKeys(t *testing.T) {
 542          schemaString := `{"$schema": "http://json-schema.org/draft-07/sc"}`
 543          httpBodyString := `{20:20}`
 544          resp := validate(httpBodyString , schemaString)
 545          assert.Equal(t, false, resp)
 546 }
 547
 548 func TestStorePolicyInstanceFail(t *testing.T) {
 549         var policyInstanceID models.PolicyInstanceID
 550         policyInstanceID = ""
 551         var policyTypeId models.PolicyTypeID
 552         policyTypeId = 0
 553         var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
 554         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 555         var keys [1]string
 556         keys[0] = key
 557         //Setup Expectations
 558         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: httpBody}, errors.New("Some Error")).Once()
 559         notificationDestination :="abc"
 560         _,err := rh.storePolicyInstance(policyTypeId,policyInstanceID ,httpBody ,notificationDestination )
 561         assert.NotNil(t, err)
 562 }
 563
 564 func TestStorePolicyInstanceMetadataFail(t *testing.T) {
 565         var policyInstanceID models.PolicyInstanceID
 566         policyInstanceID = ""
 567         var policyTypeId models.PolicyTypeID
 568         policyTypeId = 0
 569         sdlInst.On("Set", "A1m_ns", mock.Anything).Return(errors.New("Some Error")).Once()
 570         resp,err := rh.storePolicyInstanceMetadata(policyTypeId,policyInstanceID)
 571         assert.NotNil(t, err)
 572         assert.Equal(t, false, resp)
 573 }
 574
 575 func TestStoreDeletedPolicyInstanceMetadataFail(t *testing.T) {
 576         var policyInstanceID models.PolicyInstanceID
 577         policyInstanceID = ""
 578         var policyTypeId models.PolicyTypeID
 579         policyTypeId = 0
 580         sdlInst.On("Set", "A1m_ns", mock.Anything).Return(errors.New("Some Error")).Once()
 581         err := rh.storeDeletedPolicyInstanceMetadata(policyTypeId,policyInstanceID,"")
 582         assert.NotNil(t, err)
 583
 584 }
 585
 586
 587
 588
 589 func TestToString(t *testing.T) {
 590          var instance_map []interface{}
 591          instancekey := "testkey"
 592          data := "testdata"
 593          instance_map = append(instance_map, instancekey, data)
 594          resp,err := toStringKeys(instance_map)
 595          assert.Nil(t, err)
 596          assert.NotNil(t, resp)
 597 }
 598
 599 func TestToStringFail(t *testing.T) {
 600          m := make(map[interface{}]interface{})
 601          m[12] = "bar"
 602          _,err := toStringKeys(m)
 603          assert.NotNil(t, err)
 604 }
 605 /*
 606 func TestToStringFail2(t *testing.T) {
 607          var keys [1]string
 608          keys[0] = ""
 609          _,err := toStringKeys(keys[:])
 610          assert.NotNil(t, err)
 611 }
 612 */
 613 func TestTypeValidityFail(t *testing.T) {
 614         var policyTypeId models.PolicyTypeID
 615         policyTypeId = 123
 616         httpBody := `{
 617                 "enforce":true,
 618                 "window_length":20,
 619            "blocking_rate":20,
 620                 "trigger_threshold":10
 621                 }`
 622         instancekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 623         a1.Logger.Debug("httpBody String : %+v", httpBody)
 624         a1.Logger.Debug("key   : %+v", instancekey)
 625         var keys [1]string
 626         keys[0] = instancekey
 627         testmp1 := map[string]interface{}{instancekey: string(httpBody)}
 628         //Setup Expectations
 629         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(testmp1, errors.New("Some Error")).Once()
 630         err:= rh.typeValidity(policyTypeId)
 631         a1.Logger.Debug("err from get test  : %+v", err)
 632         assert.NotNil(t, err)
 633 }
 634
 635 func TestDeletePolicyTypeFail(t *testing.T) {
 636         var policyTypeId models.PolicyTypeID
 637         policyTypeId = 20009
 638         keys := []string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",}
 639         sdlInst.On("GetAll", "A1m_ns").Return(keys,errors.New("Some Error")).Once()
 640         err := rh.DeletePolicyType(policyTypeId)
 641         assert.NotNil(t, err)
 642 }
 643
 644 func TestDeletePolicyTypeFail2(t *testing.T) {
 645
 646         policyTypeId := models.PolicyTypeID(20005)
 647         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 648         var keys [1]string
 649         keys[0] = key
 650
 651         //Setup Expectations
 652         sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",},nil).Once()
 653         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error")).Once()
 654
 655         errresp := rh.DeletePolicyType(policyTypeId)
 656
 657         assert.NotNil(t, errresp)
 658 }
 659
 660 func TestDeletePolicyTypeFail3(t *testing.T) {
 661
 662         policyTypeId := models.PolicyTypeID(20000)
 663         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 664         var keys [1]string
 665         keys[0] = key
 666
 667         //Setup Expectations
 668         sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos","a1.policy_instance.20005.123456","a1.policy_instance.20005.234567","a1.policy_type.1006001","a1.policy_type.20000","a1.policy_inst_metadata.1006001.qos",},nil).Once()
 669         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error")).Once()
 670         errresp := rh.DeletePolicyType(policyTypeId)
 671         assert.NotNil(t, errresp)
 672 }
 673
 674 func TestGetPolicyInstanceStatusFail(t *testing.T) {
 675         var policyTypeId models.PolicyTypeID
 676         policyTypeId = 0
 677         var policyInstanceID models.PolicyInstanceID
 678         policyInstanceID = ""
 679         httpBody := `{
 680                 "created_at":"0001-01-01T00:00:00.000Z",
 681                 "instance_status":"NOT IN EFFECT"
 682                 }`
 683         instancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 684         a1.Logger.Debug("httpBody String : %+v", httpBody)
 685         a1.Logger.Debug("key   : %+v", instancekey)
 686         var keys [1]string
 687         keys[0] = instancekey
 688         sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody,nil)
 689         instancekey = a1HandlerPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 690         var instancekeys [1]string
 691         instancekeys[0] = instancekey
 692         instancearr := []interface{}{instancekey, "OK"}
 693         sdlInst.On("Get", a1MediatorNs, instancekeys[:]).Return(instancearr, errors.New("Some Error"))
 694         _, errresp := rh.GetPolicyInstanceStatus(policyTypeId, policyInstanceID)
 695         assert.NotNil(t, errresp)
 696 }
 697
 698 func TestDeleteInstanceDataFail(t *testing.T) {
 699         var policyTypeId models.PolicyTypeID
 700         policyTypeId = 0
 701         var policyInstanceID models.PolicyInstanceID
 702         policyInstanceID = ""
 703         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 704         var keys [1]string
 705         keys[0] = instancekey
 706
 707         //Setup Expectations
 708         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
 709
 710         errresp := rh.deleteInstancedata(policyTypeId,policyInstanceID)
 711
 712         assert.NotNil(t, errresp)
 713 }
 714
 715
 716 func TestDeleteNotificationDestinationFail(t *testing.T) {
 717         var policyTypeId models.PolicyTypeID
 718         policyTypeId = 0
 719         var policyInstanceID models.PolicyInstanceID
 720         policyInstanceID = ""
 721         notificationDestinationkey  := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 722         var keys [1]string
 723         keys[0] = notificationDestinationkey
 724
 725         //Setup Expectations
 726         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
 727
 728         errresp := rh.deleteNotificationDestination(policyTypeId,policyInstanceID)
 729
 730         assert.NotNil(t, errresp)
 731 }
 732
 733 func TestDeleteMetadataFail(t *testing.T) {
 734         var policyTypeId models.PolicyTypeID
 735         policyTypeId = 0
 736         var policyInstanceID models.PolicyInstanceID
 737         policyInstanceID = ""
 738         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 739         var keys [1]string
 740         keys[0] = instanceMetadataKey
 741
 742         //Setup Expectations
 743         sdlInst.On("Remove", a1MediatorNs, keys[:]).Return(errors.New("Some Error"))
 744
 745         errresp := rh.deleteMetadata(policyTypeId,policyInstanceID)
 746
 747         assert.NotNil(t, errresp)
 748 }
 749
 750
 751 func TestGetPolicyInstanceStFail(t *testing.T) {
 752         var policyTypeId models.PolicyTypeID
 753         policyTypeId = 200
 754         var policyInstanceID models.PolicyInstanceID
 755         policyInstanceID = "123"
 756         policyString := "testval"
 757         instancekey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 758         a1.Logger.Debug("policyString String : %+v", policyString)
 759         a1.Logger.Debug("key from get test  : %+v", instancekey)
 760         var keys [1]string
 761         keys[0] = instancekey
 762         instancearr := []interface{}{instancekey, "NOK"}
 763         //Setup Expectations
 764         sdlInst.On("Get", "A1m_ns", keys[:]).Return(instancearr, errors.New("Some Error")).Once()
 765         resp, errresp := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
 766         a1.Logger.Debug("resp from get test  : %+v", resp)
 767         a1.Logger.Debug("errresp from get test  : %+v", errresp)
 768         assert.NotNil(t, errresp)
 769 }
 770
 771 func TestCreatePolicyTypeInstance(t *testing.T) {
 772         var policyInstanceID models.PolicyInstanceID
 773         policyInstanceID = "123456"
 774         var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
 775         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 776         var policyTypeId models.PolicyTypeID
 777         policyTypeId = 20001
 778
 779         var instancedata map[string]interface{}
 780
 781         json.Unmarshal([]byte(httpBody), &instancedata)
 782
 783         data, _ := json.Marshal(instancedata)
 784         a1.Logger.Debug("Marshaled data : %+v", string(data))
 785         a1.Logger.Debug("instancekey   : %+v", instancekey)
 786         instancearr := []interface{}{instancekey, string(data)}
 787         sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
 788
 789         metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 790         creation_timestamp := time.Now()
 791         var metadatajson []interface{}
 792         metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
 793         metadata, _ := json.Marshal(metadatajson)
 794         a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
 795         a1.Logger.Debug("metadatainstancekey   : %+v", metadatainstancekey)
 796         metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
 797         sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
 798         sdlInst.On("SetIfNotExists", a1MediatorNs, instancekey, string(httpBody), string(data)).Return(true, nil)
 799         notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 800         notificationDestination := "https://www.abc.com"
 801         notificationarr := []interface{}{notificationDestinationkey, string(notificationDestination)}
 802         sdlInst.On("Set", "A1m_ns", notificationarr).Return(nil)
 803
 804         rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
 805
 806         errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, notificationDestination)
 807
 808         assert.Nil(t, errresp)
 809 }
 810
 811 func TestCreatePolicyTypeInstance2(t *testing.T) {
 812         var policyInstanceID models.PolicyInstanceID
 813         policyInstanceID = "123"
 814         var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
 815         instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 816         var policyTypeId models.PolicyTypeID
 817         policyTypeId = 20001
 818
 819         var instancedata map[string]interface{}
 820
 821         json.Unmarshal([]byte(httpBody), &instancedata)
 822
 823         data, _ := json.Marshal(instancedata)
 824         a1.Logger.Debug("Marshaled data : %+v", string(data))
 825         a1.Logger.Debug("instancekey   : %+v", instancekey)
 826         instancearr := []interface{}{instancekey, string(data)}
 827         sdlInst.On("Set", "A1m_ns", instancearr).Return(nil)
 828         sdlInst.On("Get", "A1m_ns", mock.Anything).Return(instancearr, nil).Once()
 829
 830         metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID)
 831         creation_timestamp := time.Now()
 832         var metadatajson []interface{}
 833         metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
 834         metadata, _ := json.Marshal(metadatajson)
 835         a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata))
 836         a1.Logger.Debug("metadatainstancekey   : %+v", metadatainstancekey)
 837         metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)}
 838         sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil)
 839         sdlInst.On("SetIfNotExists", a1MediatorNs, instancekey, string(httpBody), string(data)).Return(true, nil)
 840         notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 841         notificationDestination := "https://www.abc.com"
 842         notificationarr := []interface{}{notificationDestinationkey, string(notificationDestination)}
 843         sdlInst.On("Set", "A1m_ns", notificationarr).Return(nil)
 844
 845         rmrSenderInst.On("RmrSendToXapp", "httpBodyString", 20010, int(policyTypeId)).Return(true)
 846
 847         errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata, notificationDestination)
 848
 849         assert.Nil(t, errresp)
 850 }
 851
 852 func TestCreatePolicyTypeInstanceFail(t *testing.T) {
 853         var policyInstanceID models.PolicyInstanceID
 854         policyInstanceID = "123456"
 855         var policyTypeId models.PolicyTypeID
 856         policyTypeId = 20001
 857         errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, "", "")
 858         assert.NotNil(t, errresp)
 859 }
 860
 861 type SdlMock struct {
 862         mock.Mock
 863 }
 864
 865 func (s *SdlMock) GetAll(ns string) ([]string, error) {
 866         args := s.MethodCalled("GetAll", ns)
 867         return args.Get(0).([]string), args.Error(1)
 868 }
 869
 870 func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) {
 871         a1.Logger.Debug("Get Called ")
 872         args := s.MethodCalled("Get", ns, keys)
 873         a1.Logger.Debug("ns :%+v", args.Get(0))
 874         var policySchemaString string
 875         var key string
 876         if keys[0] == "a1.policy_instance.20001.123456" {
 877                 policySchemaString = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}`
 878                 key = a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + "123456"
 879         } else if keys[0] == "a1.policy_type.20001" {
 880                 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}`
 881                 key = a1PolicyPrefix + strconv.FormatInt((20001), 10)
 882         } else if keys[0] == "a1.policy_inst_metadata.20001.123456" {
 883                 policySchemaString = `{
 884                         "created_at":"2022-11-02 10:30:20",
 885                         "instance_status":"NOT IN EFFECT"
 886                         }`
 887                 key = a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + "123456"
 888         }
 889         a1.Logger.Debug(" policy SchemaString %+v", policySchemaString)
 890         policyTypeSchema, _ := json.Marshal((policySchemaString))
 891         a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema))
 892
 893         a1.Logger.Debug(" key for policy type %+v", key)
 894         mp := map[string]interface{}{key: string(policySchemaString)}
 895         a1.Logger.Debug("Get Called and mp return %+v ", mp)
 896         return mp, args.Error(1)
 897 }
 898 func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, error) {
 899         args := s.MethodCalled("SetIfNotExists", ns, key, data)
 900         return args.Bool(0), args.Error(1)
 901 }
 902
 903 func (s *SdlMock) Set(ns string, pairs ...interface{}) error {
 904         args := s.MethodCalled("Set", ns, pairs)
 905         return args.Error(0)
 906 }
 907 func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) {
 908         args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData)
 909         return args.Bool(0), args.Error(1)
 910 }
 911
 912 func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string, mtype int, subid int) bool {
 913         if httpBodyString == `{"blocking_rate":20,"enforce":true,"trigger_threshold":10,"window_length":20}` {
 914                 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString, mtype, subid)
 915                 return args.Bool(0)
 916         } else if httpBodyString == `{"ei_job_id":"1","payload":"payload"}` {
 917                 args := rmr.MethodCalled("RmrSendToXapp", httpBodyString, mtype, subid)
 918                 return args.Bool(0)
 919         }
 920         return true
 921 }
 922
 923 func (s *SdlMock) Remove(ns string, keys []string) error {
 924         args := s.MethodCalled("Remove", ns, keys)
 925         return args.Error(0)
 926 }