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