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