pkg/cm/cm_test.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2019 AT&T Intellectual Property.
   4   Copyright (c) 2019 Nokia
   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 */
  19
  20 package cm
  21
  22 import (
  23         "encoding/json"
  24         "errors"
  25         "os"
  26         "reflect"
  27         "testing"
  28
  29         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/appmgr"
  30         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/models"
  31         "gerrit.oran-osc.org/r/ric-plt/appmgr/pkg/util"
  32 )
  33
  34 var helmSearchOutput = `
  35 helm-repo/anr           0.0.1           1.0             Helm Chart for Nokia ANR (Automatic Neighbour Relation) xAPP
  36 helm-repo/appmgr        0.0.2           1.0             Helm Chart for xAppManager
  37 helm-repo/dualco        0.0.1           1.0             Helm Chart for Nokia dualco xAPP
  38 helm-repo/reporter      0.0.1           1.0             Helm Chart for Reporting xAPP
  39 helm-repo/uemgr         0.0.1           1.0             Helm Chart for Nokia uemgr xAPP
  40 `
  41
  42 var kubectlConfigmapOutput = `
  43 {
  44     "local": {
  45         "host": ":8080"
  46     },
  47     "logger": {
  48         "level": 3
  49     },
  50     "rmr": {
  51        "protPort": "tcp:4560",
  52        "maxSize": 2072,
  53        "numWorkers": 1,
  54        "txMessages": ["RIC_X2_LOAD_INFORMATION"],
  55        "rxMessages": ["RIC_X2_LOAD_INFORMATION"],
  56            "policies":   [11, 22, 33]
  57     },
  58     "db": {
  59         "namespace": "ricxapp",
  60         "host": "dbaas",
  61         "port": 6379
  62     }
  63 }
  64 `
  65
  66 type ConfigSample struct {
  67         Level int
  68         Host  string
  69 }
  70
  71 type MockedConfigMapper struct {
  72 }
  73
  74 func (cm *MockedConfigMapper) ReadSchema(name string, c *models.XAppConfig) (err error) {
  75         return
  76 }
  77
  78 func (cm *MockedConfigMapper) UploadConfig() (cfg []models.XAppConfig) {
  79         return
  80 }
  81
  82 func (cm *MockedConfigMapper) CreateConfigMap(r models.XAppConfig) (errList models.ConfigValidationErrors, err error) {
  83         return
  84 }
  85
  86 func (cm *MockedConfigMapper) GetConfigMap(m models.XappDescriptor, c *interface{}) (err error) {
  87         return
  88 }
  89
  90 func (cm *MockedConfigMapper) UpdateConfigMap(r models.XAppConfig) (errList models.ConfigValidationErrors, err error) {
  91         return
  92 }
  93
  94 func (cm *MockedConfigMapper) DeleteConfigMap(r models.XAppConfig) (c interface{}, err error) {
  95         return
  96 }
  97
  98 func (cm *MockedConfigMapper) PurgeConfigMap(m models.XappDescriptor) (c interface{}, err error) {
  99         return
 100 }
 101
 102 func (cm *MockedConfigMapper) RestoreConfigMap(m models.XappDescriptor, c interface{}) (err error) {
 103         return
 104 }
 105
 106 func (cm *MockedConfigMapper) ReadConfigMap(name string, ns string, c *interface{}) (err error) {
 107         return
 108 }
 109
 110 func (cm *MockedConfigMapper) ApplyConfigMap(r models.XAppConfig, action string) (err error) {
 111         return
 112 }
 113
 114 func (cm *MockedConfigMapper) FetchChart(name string) (err error) {
 115         return
 116 }
 117
 118 func (cm *MockedConfigMapper) GetRtmData(name string) (msgs appmgr.RtmData) {
 119         return
 120 }
 121
 122 func (cm *MockedConfigMapper) GetNamespace(ns string) (n string) {
 123         return
 124 }
 125
 126 func (cm *MockedConfigMapper) GetNamesFromHelmRepo() (names []string) {
 127         return
 128 }
 129
 130 // Test cases
 131 func TestMain(m *testing.M) {
 132         appmgr.Init()
 133         appmgr.Logger.SetLevel(0)
 134
 135         code := m.Run()
 136         os.Exit(code)
 137 }
 138
 139 func TestGetRtmData(t *testing.T) {
 140         expectedMsgs := appmgr.RtmData{
 141                 TxMessages: []string{"RIC_X2_LOAD_INFORMATION"},
 142                 RxMessages: []string{"RIC_X2_LOAD_INFORMATION"},
 143                 Policies:   []int64{11, 22, 33},
 144         }
 145
 146         util.KubectlExec = func(args string) (out []byte, err error) {
 147                 return []byte(kubectlConfigmapOutput), nil
 148         }
 149
 150         result := NewCM().GetRtmData("dummy-xapp")
 151         if !reflect.DeepEqual(result, expectedMsgs) {
 152                 t.Errorf("TestGetRtmData failed: expected: %v, got: %v", expectedMsgs, result)
 153         }
 154 }
 155
 156 func TestHelmNamespace(t *testing.T) {
 157         if NewCM().GetNamespace("pltxapp") != "pltxapp" {
 158                 t.Errorf("getNamespace failed!")
 159         }
 160
 161         if NewCM().GetNamespace("") != "ricxapp" {
 162                 t.Errorf("getNamespace failed!")
 163         }
 164 }
 165
 166 func TestFetchChartFails(t *testing.T) {
 167         if NewCM().FetchChart("dummy-xapp") == nil {
 168                 t.Errorf("TestFetchChart failed!")
 169         }
 170 }
 171
 172 func TestFetchChartSuccess(t *testing.T) {
 173         util.HelmExec = func(args string) (out []byte, err error) {
 174                 return
 175         }
 176
 177         if NewCM().FetchChart("dummy-xapp") != nil {
 178                 t.Errorf("TestFetchChart failed!")
 179         }
 180 }
 181
 182 func TestGetNamesFromHelmRepoSuccess(t *testing.T) {
 183         expectedResult := []string{"anr", "appmgr", "dualco", "reporter", "uemgr"}
 184         util.HelmExec = func(args string) (out []byte, err error) {
 185                 return []byte(helmSearchOutput), nil
 186         }
 187
 188         names := NewCM().GetNamesFromHelmRepo()
 189         if !reflect.DeepEqual(names, expectedResult) {
 190                 t.Errorf("GetNamesFromHelmRepo failed: expected %v, got %v", expectedResult, names)
 191         }
 192 }
 193
 194 func TestGetNamesFromHelmRepoFailure(t *testing.T) {
 195         expectedResult := []string{}
 196         util.HelmExec = func(args string) (out []byte, err error) {
 197                 return []byte(helmSearchOutput), errors.New("Command failed!")
 198         }
 199
 200         names := NewCM().GetNamesFromHelmRepo()
 201         if names != nil {
 202                 t.Errorf("GetNamesFromHelmRepo failed: expected %v, got %v", expectedResult, names)
 203         }
 204 }
 205
 206 func TestApplyConfigMapSuccess(t *testing.T) {
 207         name := "dummy-xapp"
 208         m := models.ConfigMetadata{Name: &name, Namespace: "ricxapp"}
 209         s := ConfigSample{5, "localhost"}
 210
 211         util.KubectlExec = func(args string) (out []byte, err error) {
 212                 return []byte(`{"logger": {"level": 2}}`), nil
 213         }
 214
 215         err := NewCM().ApplyConfigMap(models.XAppConfig{Metadata: &m, Config: s}, "create")
 216         if err != nil {
 217                 t.Errorf("ApplyConfigMap failed: %v", err)
 218         }
 219 }
 220
 221 func TestRestoreConfigMapSuccess(t *testing.T) {
 222         name := "dummy-xapp"
 223         m := models.XappDescriptor{XappName: &name, Namespace: "ricxapp"}
 224         s := ConfigSample{5, "localhost"}
 225
 226         util.KubectlExec = func(args string) (out []byte, err error) {
 227                 return []byte(`{"logger": {"level": 2}}`), nil
 228         }
 229
 230         err := NewCM().RestoreConfigMap(m, s)
 231         if err != nil {
 232                 t.Errorf("RestoreConfigMap failed: %v", err)
 233         }
 234 }
 235
 236 func TestDeleteConfigMapSuccess(t *testing.T) {
 237         util.HelmExec = func(args string) (out []byte, err error) {
 238                 return []byte("ok"), nil
 239         }
 240
 241         util.KubectlExec = func(args string) (out []byte, err error) {
 242                 return []byte(`{"logger": {"level": 2}}`), nil
 243         }
 244
 245         validationErrors, err := NewCM().DeleteConfigMap(models.ConfigMetadata{})
 246         if err != nil {
 247                 t.Errorf("DeleteConfigMap failed: %v -> %v", err, validationErrors)
 248         }
 249 }
 250
 251 func TestPurgeConfigMapSuccess(t *testing.T) {
 252         util.HelmExec = func(args string) (out []byte, err error) {
 253                 return []byte("ok"), nil
 254         }
 255
 256         util.KubectlExec = func(args string) (out []byte, err error) {
 257                 return []byte(`{"logger": {"level": 2}}`), nil
 258         }
 259
 260         name := "dummy-xapp"
 261         validationErrors, err := NewCM().PurgeConfigMap(models.XappDescriptor{XappName: &name})
 262         if err != nil {
 263                 t.Errorf("PurgeConfigMap failed: %v -> %v", err, validationErrors)
 264         }
 265 }
 266
 267 func TestCreateConfigMapFails(t *testing.T) {
 268         name := "dummy-xapp"
 269         validationErrors, err := NewCM().CreateConfigMap(models.XAppConfig{Metadata: &models.ConfigMetadata{Name: &name}})
 270         if err == nil {
 271                 t.Errorf("CreateConfigMap failed: %v -> %v", err, validationErrors)
 272         }
 273 }
 274
 275 func TestUpdateConfigMapFails(t *testing.T) {
 276         name := "dummy-xapp"
 277         validationErrors, err := NewCM().UpdateConfigMap(models.XAppConfig{Metadata: &models.ConfigMetadata{Name: &name}})
 278         if err == nil {
 279                 t.Errorf("CreateConfigMap failed: %v -> %v", err, validationErrors)
 280         }
 281 }
 282
 283 func TestValidationSuccess(t *testing.T) {
 284         var d interface{}
 285         var cfg map[string]interface{}
 286         err := json.Unmarshal([]byte(`{"local": {"host": ":8080"}, "logger": {"level": 3}}`), &cfg)
 287
 288         err = NewCM().ReadFile("../../test/schema.json", &d)
 289         if err != nil {
 290                 t.Errorf("ReadFile failed: %v -> %v", err, d)
 291         }
 292
 293         feedback, err := NewCM().doValidate(d, cfg)
 294         if err != nil {
 295                 t.Errorf("doValidate failed: %v -> %v", err, feedback)
 296         }
 297 }
 298
 299 func TestValidationFails(t *testing.T) {
 300         var d interface{}
 301         var cfg map[string]interface{}
 302         err := json.Unmarshal([]byte(`{"local": {"host": ":8080"}, "logger": {"level": "INVALID"}}`), &cfg)
 303
 304         err = NewCM().ReadFile("../../test/schema.json", &d)
 305         if err != nil {
 306                 t.Errorf("ConfigMetadata failed: %v -> %v", err, d)
 307         }
 308
 309         feedback, err := NewCM().doValidate(d, cfg)
 310         if err == nil {
 311                 t.Errorf("doValidate should faile but didn't: %v -> %v", err, feedback)
 312         }
 313         appmgr.Logger.Debug("Feedbacks: %v", feedback)
 314 }