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) ReadSchema(name string, c *XAppConfig) (err error) {
  70         return
  71 }
  72
  73 func (cm *MockedConfigMapper) UploadConfig() (cfg []XAppConfig) {
  74         return
  75 }
  76
  77 func (cm *MockedConfigMapper) CreateConfigMap(r XAppConfig) (errList []CMError, err error){
  78         return
  79 }
  80
  81 func (cm *MockedConfigMapper) GetConfigMap(m XappDeploy, c *interface{}) (err error) {
  82         return
  83 }
  84
  85 func (cm *MockedConfigMapper) UpdateConfigMap(r XAppConfig) (errList []CMError, err error) {
  86         return
  87 }
  88
  89 func (cm *MockedConfigMapper) DeleteConfigMap(r XAppConfig) (c interface{}, err error) {
  90         return
  91 }
  92
  93 func (cm *MockedConfigMapper) PurgeConfigMap(m XappDeploy) (c interface{}, err error) {
  94         return
  95 }
  96
  97 func (cm *MockedConfigMapper) RestoreConfigMap(m XappDeploy, c interface{}) (err error) {
  98         return
  99 }
 100
 101 func (cm *MockedConfigMapper) ReadConfigMap(name string, ns string, c *interface{}) (err error) {
 102         return
 103 }
 104
 105 func (cm *MockedConfigMapper) ApplyConfigMap(r XAppConfig, action string) (err error) {
 106         return
 107 }
 108
 109 func (cm *MockedConfigMapper) FetchChart(name string) (err error) {
 110         return
 111 }
 112
 113 func (cm *MockedConfigMapper) GetMessages(name string) (msgs MessageTypes) {
 114         return
 115 }
 116
 117 func (cm *MockedConfigMapper) GetNamespace(ns string) (n string) {
 118         return
 119 }
 120
 121 // Test cases
 122 func TestGetMessages(t *testing.T) {
 123         cm := ConfigMap{}
 124         expectedMsgs := MessageTypes{
 125                 TxMessages: []string{"RIC_X2_LOAD_INFORMATION"},
 126                 RxMessages: []string{"RIC_X2_LOAD_INFORMATION"},
 127         }
 128
 129         KubectlExec = func(args string) (out []byte, err error) {
 130                 return []byte(kubectlConfigmapOutput), nil
 131         }
 132
 133     result := cm.GetMessages("dummy-xapp")
 134         if !reflect.DeepEqual(result, expectedMsgs) {
 135                 t.Errorf("TestGetMessages failed: expected: %v, got: %v", expectedMsgs, result)
 136         }
 137 }
 138
 139 func TestHelmNamespace(t *testing.T) {
 140         cm := ConfigMap{}
 141
 142         if cm.GetNamespace("pltxapp") != "pltxapp" {
 143         t.Errorf("getNamespace failed!")
 144         }
 145
 146     if cm.GetNamespace("") != "ricxapp" {
 147         t.Errorf("getNamespace failed!")
 148         }
 149 }
 150
 151 func TestFetchChartFails(t *testing.T) {
 152         cm := ConfigMap{}
 153
 154         if cm.FetchChart("dummy-xapp") == nil {
 155                 t.Errorf("TestFetchChart failed!")
 156         }
 157 }
 158
 159 func TestFetchChartSuccess(t *testing.T) {
 160         cm := ConfigMap{}
 161
 162         HelmExec = func(args string) (out []byte, err error) {
 163                 return
 164         }
 165
 166         if cm.FetchChart("dummy-xapp") != nil {
 167                 t.Errorf("TestFetchChart failed!")
 168         }
 169 }
 170
 171 func TestGetNamesFromHelmRepoSuccess(t *testing.T) {
 172         cm := ConfigMap{}
 173         expectedResult := []string{"anr", "appmgr", "dualco", "reporter", "uemgr"}
 174         HelmExec = func(args string) (out []byte, err error) {
 175                 return []byte(helmSearchOutput), nil
 176         }
 177
 178         names := cm.GetNamesFromHelmRepo()
 179         if !reflect.DeepEqual(names, expectedResult) {
 180                 t.Errorf("GetNamesFromHelmRepo failed: expected %v, got %v", expectedResult, names)
 181         }
 182 }
 183
 184 func TestGetNamesFromHelmRepoFailure(t *testing.T) {
 185         cm := ConfigMap{}
 186         expectedResult := []string{}
 187         HelmExec = func(args string) (out []byte, err error) {
 188                 return []byte(helmSearchOutput), errors.New("Command failed!")
 189         }
 190
 191         names := cm.GetNamesFromHelmRepo()
 192         if names != nil {
 193                 t.Errorf("GetNamesFromHelmRepo failed: expected %v, got %v", expectedResult, names)
 194         }
 195 }
 196
 197 func TestApplyConfigMapSuccess(t *testing.T) {
 198         cm := ConfigMap{}
 199         m := ConfigMetadata{Name: "dummy-xapp", Namespace: "ricxapp"}
 200         s := ConfigSample{5, "localhost"}
 201
 202         KubectlExec = func(args string) (out []byte, err error) {
 203                 log.Println("TestApplyConfigMapSuccess: ", args)
 204                 return []byte(`{"logger": {"level": 2}}`), nil
 205         }
 206
 207         err := cm.ApplyConfigMap(XAppConfig{Metadata: m, Configuration: s}, "create")
 208         if err != nil {
 209                 t.Errorf("ApplyConfigMap failed: %v", err)
 210         }
 211 }
 212
 213 func TestRestoreConfigMapSuccess(t *testing.T) {
 214         cm := ConfigMap{}
 215         m := XappDeploy{Name: "dummy-xapp", Namespace: "ricxapp"}
 216         s := ConfigSample{5, "localhost"}
 217
 218         KubectlExec = func(args string) (out []byte, err error) {
 219                 log.Println("TestRestoreConfigMapSuccess: ", args)
 220                 return []byte(`{"logger": {"level": 2}}`), nil
 221         }
 222
 223         err := cm.RestoreConfigMap(m, s)
 224         if err != nil {
 225                 t.Errorf("RestoreConfigMap failed: %v", err)
 226         }
 227 }
 228
 229 func TestDeleteConfigMapSuccess(t *testing.T) {
 230         cm := ConfigMap{}
 231
 232         HelmExec = func(args string) (out []byte, err error) {
 233                 return []byte("ok"), nil
 234         }
 235
 236         KubectlExec = func(args string) (out []byte, err error) {
 237                 log.Println("TestDeleteConfigMapSuccess: ", args)
 238                 return []byte(`{"logger": {"level": 2}}`), nil
 239         }
 240
 241         c, err := cm.DeleteConfigMap(XAppConfig{})
 242         if err != nil {
 243                 t.Errorf("DeleteConfigMap failed: %v -> %v", err, c)
 244         }
 245 }
 246
 247 func TestPurgeConfigMapSuccess(t *testing.T) {
 248         cm := ConfigMap{}
 249
 250         HelmExec = func(args string) (out []byte, err error) {
 251                 return []byte("ok"), nil
 252         }
 253
 254         KubectlExec = func(args string) (out []byte, err error) {
 255                 return []byte(`{"logger": {"level": 2}}`), nil
 256         }
 257
 258         c, err := cm.PurgeConfigMap(XappDeploy{})
 259         if err != nil {
 260                 t.Errorf("PurgeConfigMap failed: %v -> %v", err, c)
 261         }
 262 }
 263
 264 func TestCreateConfigMapFails(t *testing.T) {
 265         cm := ConfigMap{}
 266
 267         c, err := cm.CreateConfigMap(XAppConfig{})
 268         if err == nil {
 269                 t.Errorf("CreateConfigMap failed: %v -> %v", err, c)
 270         }
 271 }
 272
 273 func TestUpdateConfigMapFails(t *testing.T) {
 274         cm := ConfigMap{}
 275
 276         c, err := cm.UpdateConfigMap(XAppConfig{})
 277         if err == nil {
 278                 t.Errorf("CreateConfigMap failed: %v -> %v", err, c)
 279         }
 280 }
 281
 282 func TestValidationSuccess(t *testing.T) {
 283         cm := ConfigMap{}
 284         var d interface{}
 285         var cfg map[string]interface{}
 286
 287         err := json.Unmarshal([]byte(`{"local": {"host": ":8080"}, "logger": {"level": 3}}`), &cfg)
 288
 289         err = cm.ReadFile("./test/schema.json", &d)
 290         if err != nil {
 291                 t.Errorf("ReadFile failed: %v -> %v", err, d)
 292         }
 293
 294         feedback, err := cm.doValidate(d, cfg)
 295         if err != nil {
 296                 t.Errorf("doValidate failed: %v -> %v", err, feedback)
 297         }
 298 }
 299
 300 func TestValidationFails(t *testing.T) {
 301         cm := ConfigMap{}
 302         var d interface{}
 303         var cfg map[string]interface{}
 304
 305         err := json.Unmarshal([]byte(`{"local": {"host": ":8080"}, "logger": {"level": "INVALID"}}`), &cfg)
 306
 307         err = cm.ReadFile("./test/schema.json", &d)
 308         if err != nil {
 309                 t.Errorf("ConfigMetadata failed: %v -> %v", err, d)
 310         }
 311
 312         feedback, err := cm.doValidate(d, cfg)
 313         if err == nil {
 314                 t.Errorf("doValidate should faile but didn't: %v -> %v", err, feedback)
 315         }
 316
 317         log.Println("Feedbacks: ", feedback)
 318 }