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