src/k8splugin/internal/app/instance_test.go

   1 /*
   2 Copyright 2018 Intel Corporation.
   3 Licensed under the Apache License, Version 2.0 (the "License");
   4 you may not use this file except in compliance with the License.
   5 You may obtain a copy of the License at
   6     http://www.apache.org/licenses/LICENSE-2.0
   7 Unless required by applicable law or agreed to in writing, software
   8 distributed under the License is distributed on an "AS IS" BASIS,
   9 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 See the License for the specific language governing permissions and
  11 limitations under the License.
  12 */
  13
  14 package app
  15
  16 import (
  17         "encoding/base64"
  18         "io/ioutil"
  19         "log"
  20         "reflect"
  21         "sort"
  22         "testing"
  23
  24         utils "github.com/onap/multicloud-k8s/src/k8splugin/internal"
  25         "github.com/onap/multicloud-k8s/src/k8splugin/internal/connection"
  26         "github.com/onap/multicloud-k8s/src/k8splugin/internal/db"
  27         "github.com/onap/multicloud-k8s/src/k8splugin/internal/helm"
  28         "github.com/onap/multicloud-k8s/src/k8splugin/internal/rb"
  29
  30         "k8s.io/apimachinery/pkg/runtime/schema"
  31 )
  32
  33 func TestInstanceCreate(t *testing.T) {
  34         oldkrdPluginData := utils.LoadedPlugins
  35         defer func() {
  36                 utils.LoadedPlugins = oldkrdPluginData
  37         }()
  38         err := LoadMockPlugins(utils.LoadedPlugins)
  39         if err != nil {
  40                 t.Fatalf("LoadMockPlugins returned an error (%s)", err)
  41         }
  42
  43         // Load the mock kube config file into memory
  44         fd, err := ioutil.ReadFile("../../mock_files/mock_configs/mock_kube_config")
  45         if err != nil {
  46                 t.Fatal("Unable to read mock_kube_config")
  47         }
  48
  49         t.Run("Successfully create Instance", func(t *testing.T) {
  50                 db.DBconn = &db.MockDB{
  51                         Items: map[string]map[string][]byte{
  52                                 rb.ProfileKey{RBName: "test-rbdef", RBVersion: "v1",
  53                                         ProfileName: "profile1"}.String(): {
  54                                         "profilemetadata": []byte(
  55                                                 "{\"profile-name\":\"profile1\"," +
  56                                                         "\"release-name\":\"testprofilereleasename\"," +
  57                                                         "\"namespace\":\"testnamespace\"," +
  58                                                         "\"rb-name\":\"test-rbdef\"," +
  59                                                         "\"rb-version\":\"v1\"," +
  60                                                         "\"kubernetesversion\":\"1.12.3\"}"),
  61                                         // base64 encoding of vagrant/tests/vnfs/testrb/helm/profile
  62                                         "profilecontent": []byte("H4sICLmjT1wAA3Byb2ZpbGUudGFyAO1Y32/bNhD2s/6Kg/KyYZZsy" +
  63                                                 "78K78lLMsxY5gRxmqIYhoKWaJsYJWokZdfo+r/vSFmunCZNBtQJ1vF7sXX36e54vDN5T" +
  64                                                 "knGFlTpcEtS3jgO2ohBr2c/EXc/29Gg1+h0e1F32Ol1B1Gj3Ymifr8B7SPFc4BCaSIBG" +
  65                                                 "lII/SXeY/r/KIIg8NZUKiayEaw7nt7mdOQBrAkvqBqBL1ArWULflRJbJz4SYpEt2FJSJ" +
  66                                                 "QoZ21cAAlgwTnOiVyPQWFQLwVuqmCdMthKac7FNaVZWmqWjkRWRuuSvScF1gFZVwYOEr" +
  67                                                 "luapjknaOazd186Z98S7tver+3j0f5v1/q/18f+7w56bdf/zwFF5ZqV/WtbH6YioVdCa" +
  68                                                 "hRkJEVBVSFBvUNRmyNpesgwors0lmkqM8KNzRG8iqLIWN45GUGv57l+fkFUP9PH9GF6f" +
  69                                                 "IgH+kP9b76b/o+GUb9r5J1O1I0a0D9mUBX+5/1/55g+io9/sf+DnuF1sA4Gbv+fA1++p" +
  70                                                 "n0dH4+c/92oPaztv+n/fn84dOf/c+AETkW+lWy50hC1O69gguc1R6HEw5xoHAuaKIq9E" +
  71                                                 "+8ELvCikCmaQJElVIJeURjnJMaPnaYJt+UoAVHYhu8Mwd+p/O9/RAtbUUBKtnj+aygUR" +
  72                                                 "RNM2ZkB6PuY5hpvCzhY4L2fkSymsGF6Zd3sjIRo4u3OhJhrgmyC/ByfFnUeEG0DLrHSO" +
  73                                                 "h+1WpvNJiQ23FDIZYuXVNW6mJyeT2fnAYZsX3qdcaoUSPpXwSQudr4FkmNEMZljnJxsQ" +
  74                                                 "EggOPmgTgsT8UYyzbJlE5RY6A2RFK0kTGnJ5oU+SFcVH666TsCEkQz88QwmMx9+Gs8ms" +
  75                                                 "ybaeDO5+eXy9Q28GV9fj6c3k/MZXF7D6eX0bHIzuZzi088wnr6FXyfTsyZQTBa6oe9za" +
  76                                                 "eLHIJlJJE1M1maUHgSwEGVAKqcxW7AY15UtC7KksDS3uQyXAzmVKVNmOxWGl6AVzlKmb" +
  77                                                 "VGozxcVeh7J2W01S2LOVAsHyj9ZlozgbP+74qVUk4RoMtrfMD98wCzGvEiwXHD3U5GFi" +
  78                                                 "4Jzo/QhhI8fd0yFu3c/fa/d8zmZU67KsRRDefCt/Qu7YdQSw1PzNTS3W1QGnyRVef+N5" +
  79                                                 "YHDKZao/4MP/ju/siEpp0SVQYbX5UNlxxJwizCFyzuMWXkLNySzIyZs4wBrTpXE23I62" +
  80                                                 "wlPRZHp0qJCC7EWslxpSnS8uqgt/YmLr2btnZXaDhnwA4NPzueT8lEt126AyExPY44rS" +
  81                                                 "YA1bJPl15JgRaEdM9CKv/f1YDHdE5e1cYVFdiUwoduDJC+5mBMe5nstbndCF9Zfxakpa" +
  82                                                 "1aNP2LK/Xffhuc3fTNfUYlfzH8a/h97qhmVaikNPi2+nItq8exGtLA+SdW9rgUvUvqbq" +
  83                                                 "YkDi6mRXNk/V1pUxy0uYsI1S+meU+XsPo2kJLnMOKZGy4J6Xt3XgZuHTayEKv3XZLjy+" +
  84                                                 "yJ66WPQwcHBwcHBwcHBwcHBwcHBwcHhm8Q/mTHqWgAoAAA="),
  85                                 },
  86                                 rb.DefinitionKey{RBName: "test-rbdef", RBVersion: "v1"}.String(): {
  87                                         "defmetadata": []byte(
  88                                                 "{\"rb-name\":\"test-rbdef\"," +
  89                                                         "\"rb-version\":\"v1\"," +
  90                                                         "\"chart-name\":\"vault-consul-dev\"," +
  91                                                         "\"description\":\"testresourcebundle\"}"),
  92                                         // base64 encoding of vagrant/tests/vnfs/testrb/helm/vault-consul-dev
  93                                         "defcontent": []byte("H4sICEetS1wAA3ZhdWx0LWNvbnN1bC1kZXYudGFyAO0c7XLbNjK/+R" +
  94                                                 "QYujdJehatb+V4czPnOmnPk9bO2Gk7nbaTgUhIxpgiGAK0o3P9QPca92S3C5AU9GXZiax" +
  95                                                 "c7rA/LJEAFovdxX4AK1/RIlGNSKSySBoxuzp4sn1oAgx6Pf0JsPipv7c63XZ70O61W4Mn" +
  96                                                 "zVZ7MGg9Ib1HoGUJCqloTsiTXAh1V79N7V8oXC3K/+iC5iqY0kmytTlQwP1ud538W51Wf" +
  97                                                 "0H+3QF8kObWKLgD/s/lv0eORDbN+fhCkXaz9YIcp4ol8DLPRE4VF+k+vIq8PW+PfM8jlk" +
  98                                                 "oWkyKNWU7UBSOHGY3go2zZJz+xXMIY0g6a5Bl28Msm//lfAcNUFGRCpyQVihSSAQouyYg" +
  99                                                 "njLAPEcsU4SmJxCRLOE0jRq65utDTlEgCQPFLiUIMFYXeFPpn8DSy+xGqNMEGLpTKwoOD" +
 100                                                 "6+vrgGpyA5GPDxLTVR58f3z06uT8VQNI1oN+TBMmJcnZ+4LnsNjhlNAMKIroEOhM6DURO" +
 101                                                 "aHjnEGbEkjxdc4VT8f7RIqRuqY5Aywxlyrnw0LNsauiD1ZtdwCG0ZT4h+fk+Nwn3xyeH5" +
 102                                                 "/vA46fj9/+4/THt+Tnw7Ozw5O3x6/OyekZOTo9eXn89vj0BJ6+JYcnv5DXxycv9wkDZsE" +
 103                                                 "07EOWI/1AJEdGshi5ds7YHAEjYQiSGYv4iEewrnRc0DEjY3HF8hSWQzKWT7hEcUogLwYs" +
 104                                                 "CZ9wpZVCLi8q8Dya8VIBQnLV8mImo5xnSj9ru4IMS2iRRhfkJzQ8iJcY44OMBPtDJiJmX" +
 105                                                 "konDFAs2CbAn9X4m8Ffgp53VT2C9EB+n3s3fXmwZP+vaFIwuVUHsMH+d1vd3oL977X6TW" +
 106                                                 "f/dwHO/jv7vzX7v/epAHN8l4ghTdApjPi4MCoIjmGEdkoGW5hirCcIPQJaGLM3Ildvcjb" +
 107                                                 "iH0LSabbhbYYqLBUDBQzJzS2sqpK/JoVPgEue/os4jOUMq88WuKE+vNZmtfRgYTNooXPK" +
 108                                                 "iiR5IwDRNCSHyTWdSsQ9SugY9YilWr9iNizGY2R/Y25aWWSwIVWtlp7u+EoPikMyoolk2" +
 109                                                 "xHAoTXr40nBYLY46OFWlSwH7QuJygumXyRi/C5hVww4fHzy7enqTjFV9F3M4dXTA4PtAF" +
 110                                                 "891Y3INWmwl6aAvOg1m9YLGZJGy6uFZuZQYP2MhBFsGhFoHOMmC4G+iCYXQqrQQgqTUnV" +
 111                                                 "RSt8sQysUEF32UFG2AtnTX8Pw9/BFu9l8WjeqRMLSJIrZXrF5824C81+W79HoGAGRtJgM" +
 112                                                 "YXOCUeQpuDfQZOnlTIv1SBQpKCasF7X/nCUsgqUaRaejEU+5mlZqn+ViyBZ0IKM5xGYK9" +
 113                                                 "oiX8CtYk9TMxXGcJi9ZQqfnDIbEsJ5W02wnLuL5d3skZUCTpPkUVb9cDakQlhNfXzDQe6" +
 114                                                 "bQtpJhzuhlJniqpEago0XcKrBOKcjrF2BRBZPpU9wi6NLBwaTwLQPJAVpcBfoLlsNoVu0" +
 115                                                 "awzfAHPOPWYhnm4olvKBPIikm7IxFCeWTauefMaQDWmmELPgBpIAvafwzeBF2CqigTfJ/" +
 116                                                 "wtv2dxy+T1Bib7RCHcQgbpajcjfSkawaz4uhaZcTaW8Az8Otwg1xapoBypPS5KH1W4qxP" +
 117                                                 "bNbTlY1AOPBLdAEB8MOamtlrwxoSLpdzwMx5SUX2bxd+txBjoO1sBT/KwZRA1UQGG1tjo" +
 118                                                 "ef/3UH/YE7/9sF3CH/GDyGmE5Y+qnHgZvyv2Z7MC9/sC6dvsv/dgF7Lv9z+d9jnP8Bz+T" +
 119                                                 "BVcu75CnEAS9rW+JB9EgxOgnrGOTmBrgYJUUM6gLSn4g0GEGuhI0+CcjtbdlTgvRWd69b" +
 120                                                 "6/4JHbKkjPuBlLWj6gEQ5OMJpe4YmEsQDISgsTF7U6n3HwTDaZiP+H/2if/Or3DkEFBTa" +
 121                                                 "YgMzsxDhUd3ABEBC8cLPc5NnIadUCJIdhmvS9PxJ3MqZwfxBqOsIniNfUJVdPG9tfR7Lr" +
 122                                                 "4y+iUWS0I6e5lDeG9+3osf1XLLLMvE6PVcDZNuh8S3mKBfBdpxARa/nmutMq2gS+N4YyX" +
 123                                                 "kFn5zQBDM0nUQd5VZVX2sRgsrzkdR3X/1NXn+vm+SVfiCztX/fZYh2mkpLrRevAmoLXrK" +
 124                                                 "ID6wQ3B7VpNm/IA6MYfRThyYig50rqr4hNV9Kp6tasGs6DRNplWWtFEg5TH+AyXSGFJIa" +
 125                                                 "cC67Ewyhk6QCMyTqntIxqwCvYjFngVxzWX/OxGIPdUKcldhwHMKPb31rjqrWCDoc4clDn" +
 126                                                 "YEd8T/ld355KugDfF/u99avP8ZdNz9/27Axf8u/n+s+38T+pex7f3i/tLmPHrov5Rf/Le" +
 127                                                 "F/+a4dkUUiA0GWx2oNGb8XOxdnedW89/c8BFh71dj9avTYZ80yv7ZQ4LR2XHwcsw2f9dm" +
 128                                                 "xW1+p9lG/q2YoxozI75BQLJsM3XswzJ1YObHTD0outYTpnE1Wy6UiEQSkrdHb5ZSr3smR" +
 129                                                 "XdqyGew/0v+X2+DLR7+Pvmo8982dHfnvzuAdfI32rsdNXi4/Hu9rpP/TmCD/LdSDbwh/m" +
 130                                                 "+1+93F+L876Ln4fxdgx////hemAANyOIlFJPfJNyyBTICmELa5+N/F/59Y/6sNSn3SLDU" +
 131                                                 "JOljSCgNsFJp+Y3/KCmBjhVyV7+PBBvu/lWrgjec/gyX7P+i2nP3fBTj77+z/F1P/S4w5" +
 132                                                 "glmpIhGwbAisTPWZihYUluqCyspiaKzYdsuF9/A3LCmwCKQOcxdpgXtBV+Vm5lQjr5rh+" +
 133                                                 "YqlyjTiUkB9ysJFrdPG1dXFmSQvUs1ybASF0pLBM4HLF5Kgh1S6bnFVvbIphsQ7MzyTEp" +
 134                                                 "IrkXMmzQWyeZyGJGUfCtkJREozVP6whWG3GVtXP4LnZdGlR2ZvziwMQkyAGLv12FwE1s8" +
 135                                                 "NPT40LlqjToSpZNYXbR6pnm20pqAxYAmVikdBJGbdSvxDRsEdoY3Ab2Ev6FXozarxvg/4" +
 136                                                 "jBd+eCa2osYa+1YKpK/g9JUXQYMOuzDXZzhTWMeI5VjJGesBsOvr6k5VXbPpnysBedpky" +
 137                                                 "YVacXN1vr5YU6P92GpvQubrvfUV4Dbs/wb/v5VqwIfn/4Net+Py/13AveX/rj5oD1T2sG" +
 138                                                 "BwU/7f73cW6v/anb7L/3cCNzcHX3suCHRB4LaCwK8Pbm89T6sVIWdMiuTKzFrbDx0/ATP" +
 139                                                 "1bz+oSfgD8vaCzX6/UneVxQhCHfz9gayRVHKuB0JbGQwi2TmPY5YSPrJ+ZPKMjQO93Do0" +
 140                                                 "fA44C4krRFQjkSTiGp90hBl6+latuiJKZXlrRcJqBns5JvgzC8cbI1gFBESrLijNvVXZx" +
 141                                                 "1Qt2VdABt3SrI0SL4Pgo7HtW6L72/9ZPPlQB7DB/nc6ve6i/e93Xf3HTsDZf2f/d2f/a9" +
 142                                                 "NtDoMX8tZpAEPQD2gjrMmzCp/LPsg2nXiDSEoruo+23AisXH9tpScM7FnK5aQaFsyb9rI" +
 143                                                 "6wUJv2/jKSi/SqUnDkwbdIOcwznqdVmgsjGY+nUeuRY6KgHwvW4YUUsy13mU2buZewPXd" +
 144                                                 "QY1V25DlPFUj4v9J+neNqPBi7YU1erHy1lrCevbWuHRZhe3WVirNEnMki3KG/0fkkqXr1" +
 145                                                 "WVp3iPcxKUKhHOHI9hicndoy0P915R7UCmvRQ7JdvWtLLHnSUgYfpBnQl9u0OT5PeQTGN" +
 146                                                 "LtKOArbCXh35aKRmyplqUjun+Ey4D+d69z1l9TCf3rYpu/+wZJoFtmHWkBRhY6zjQiRKU" +
 147                                                 "wfZEl5deKFeQPMux3WRrNcFRDb36D0b/5IXziQNz28GRe7v/mVxjsd5qb9gskp36+vfVL" +
 148                                                 "Tq0nx6zULKMm7VEDp/8RuH/8V5eKPTD733z/01zO/6G/i/92AS7+c/HfbuO/MuN/KkllU" +
 149                                                 "bzSj1de6pqDyg3ZLMk3Y59ZDh5f1PEJxDuSqecYDhyCqcdhqFditFxRqmkox0kM4Rbiwb" +
 150                                                 "mOq0LBsgN5xllgiHuuqasCAL3sVx8yWhJS9dcIddhYnlusjRjmSqCtWEFjsHy5XaW8ki3" +
 151                                                 "Lpw0Gx8q1/oFXCuAz+x39lU/O9ckL8Rv+oh/93CbLwRbhYef/H+H8n2z2/612e8H/w5P7" +
 152                                                 "/287Aef/nf9/PP9vOcIF97/e/y06vnv7uwe4sJpAyJfBugFR1Sz4w6ApeV/QBDgCUrFv5" +
 153                                                 "bUFxFgFp6EoM6pwNlyQhIAloqjOUgCBr4shMJBhnaPx/JwlMXAwZ4Z/Rm205j8D3UIGvQ" +
 154                                                 "RZQl9kOgrk+XoOzX68tJ3wYJb0N/RJ0NzPUr5y4YEDBw4cOHDgwIEDBw4cOHDgwIEDBw4" +
 155                                                 "cOHDgwIEDB18K/AcxEDJDAHgAAA=="),
 156                                 },
 157                                 connection.ConnectionKey{CloudRegion: "mock_connection"}.String(): {
 158                                         "metadata": []byte(
 159                                                 "{\"cloud-region\":\"mock_connection\"," +
 160                                                         "\"cloud-owner\":\"mock_owner\"," +
 161                                                         "\"kubeconfig\": \"" + base64.StdEncoding.EncodeToString(fd) + "\"}"),
 162                                 },
 163                         },
 164                 }
 165
 166                 ic := NewInstanceClient()
 167                 input := InstanceRequest{
 168                         RBName:      "test-rbdef",
 169                         RBVersion:   "v1",
 170                         ProfileName: "profile1",
 171                         CloudRegion: "mock_connection",
 172                 }
 173
 174                 ir, err := ic.Create(input)
 175                 if err != nil {
 176                         t.Fatalf("TestInstanceCreate returned an error (%s)", err)
 177                 }
 178
 179                 log.Println(ir)
 180
 181                 if len(ir.Resources) == 0 {
 182                         t.Fatalf("TestInstanceCreate returned empty data (%+v)", ir)
 183                 }
 184         })
 185
 186 }
 187
 188 func TestInstanceGet(t *testing.T) {
 189         oldkrdPluginData := utils.LoadedPlugins
 190
 191         defer func() {
 192                 utils.LoadedPlugins = oldkrdPluginData
 193         }()
 194
 195         err := LoadMockPlugins(utils.LoadedPlugins)
 196         if err != nil {
 197                 t.Fatalf("LoadMockPlugins returned an error (%s)", err)
 198         }
 199
 200         t.Run("Successfully Get Instance", func(t *testing.T) {
 201                 db.DBconn = &db.MockDB{
 202                         Items: map[string]map[string][]byte{
 203                                 InstanceKey{ID: "HaKpys8e"}.String(): {
 204                                         "instance": []byte(
 205                                                 `{
 206                                                         "id":"HaKpys8e",
 207                                                         "request": {
 208                                                                 "profile-name":"profile1",
 209                                                                 "rb-name":"test-rbdef",
 210                                                                 "rb-version":"v1",
 211                                                                 "cloud-region":"region1"
 212                                                         },
 213                                                         "namespace":"testnamespace",
 214                                                         "resources": [
 215                                                                 {
 216                                                                         "GVK": {
 217                                                                                 "Group":"apps",
 218                                                                                 "Version":"v1",
 219                                                                                 "Kind":"Deployment"
 220                                                                         },
 221                                                                         "Name": "deployment-1"
 222                                                                 },
 223                                                                 {
 224                                                                         "GVK": {
 225                                                                                 "Group":"",
 226                                                                                 "Version":"v1",
 227                                                                                 "Kind":"Service"
 228                                                                         },
 229                                                                         "Name": "service-1"
 230                                                                 }
 231                                                         ]
 232                                                 }`),
 233                                 },
 234                         },
 235                 }
 236
 237                 expected := InstanceResponse{
 238                         ID: "HaKpys8e",
 239                         Request: InstanceRequest{
 240                                 RBName:      "test-rbdef",
 241                                 RBVersion:   "v1",
 242                                 ProfileName: "profile1",
 243                                 CloudRegion: "region1",
 244                         },
 245                         Namespace: "testnamespace",
 246                         Resources: []helm.KubernetesResource{
 247                                 {
 248                                         GVK: schema.GroupVersionKind{
 249                                                 Group:   "apps",
 250                                                 Version: "v1",
 251                                                 Kind:    "Deployment"},
 252                                         Name: "deployment-1",
 253                                 },
 254                                 {
 255                                         GVK: schema.GroupVersionKind{
 256                                                 Group:   "",
 257                                                 Version: "v1",
 258                                                 Kind:    "Service"},
 259                                         Name: "service-1",
 260                                 },
 261                         },
 262                 }
 263                 ic := NewInstanceClient()
 264                 id := "HaKpys8e"
 265                 data, err := ic.Get(id)
 266                 if err != nil {
 267                         t.Fatalf("TestInstanceGet returned an error (%s)", err)
 268                 }
 269                 if !reflect.DeepEqual(expected, data) {
 270                         t.Fatalf("TestInstanceGet returned:\n result=%v\n expected=%v",
 271                                 data, expected)
 272                 }
 273         })
 274
 275         t.Run("Get non-existing Instance", func(t *testing.T) {
 276                 db.DBconn = &db.MockDB{
 277                         Items: map[string]map[string][]byte{
 278                                 InstanceKey{ID: "HaKpys8e"}.String(): {
 279                                         "instance": []byte(
 280                                                 `{
 281                                                         "id":"HaKpys8e",
 282                                                         "request": {
 283                                                                 "profile-name":"profile1",
 284                                                                 "rb-name":"test-rbdef",
 285                                                                 "rb-version":"v1",
 286                                                                 "cloud-region":"region1"
 287                                                         },
 288                                                         "namespace":"testnamespace",
 289                                                         "resources": [
 290                                                                 {
 291                                                                         "GVK": {
 292                                                                                 "Group":"apps",
 293                                                                                 "Version":"v1",
 294                                                                                 "Kind":"Deployment"
 295                                                                         },
 296                                                                         "Name": "deployment-1"
 297                                                                 },
 298                                                                 {
 299                                                                         "GVK": {
 300                                                                                 "Group":"",
 301                                                                                 "Version":"v1",
 302                                                                                 "Kind":"Service"
 303                                                                         },
 304                                                                         "Name": "service-1"
 305                                                                 }
 306                                                         ]
 307                                                 }`),
 308                                 },
 309                         },
 310                 }
 311
 312                 ic := NewInstanceClient()
 313                 id := "non-existing"
 314                 _, err := ic.Get(id)
 315                 if err == nil {
 316                         t.Fatal("Expected error, got pass", err)
 317                 }
 318         })
 319 }
 320
 321 func TestInstanceFind(t *testing.T) {
 322         oldkrdPluginData := utils.LoadedPlugins
 323
 324         defer func() {
 325                 utils.LoadedPlugins = oldkrdPluginData
 326         }()
 327
 328         err := LoadMockPlugins(utils.LoadedPlugins)
 329         if err != nil {
 330                 t.Fatalf("LoadMockPlugins returned an error (%s)", err)
 331         }
 332
 333         items := map[string]map[string][]byte{
 334                 InstanceKey{ID: "HaKpys8e"}.String(): {
 335                         "instance": []byte(
 336                                 `{
 337                                         "id":"HaKpys8e",
 338                                         "request": {
 339                                                 "profile-name":"profile1",
 340                                                 "rb-name":"test-rbdef",
 341                                                 "rb-version":"v1",
 342                                                 "cloud-region":"region1",
 343                                                 "labels":{
 344                                                         "vf_module_id": "test-vf-module-id"
 345                                                 }
 346                                         },
 347                                         "namespace":"testnamespace",
 348                                         "resources": [
 349                                                 {
 350                                                         "GVK": {
 351                                                                 "Group":"apps",
 352                                                                 "Version":"v1",
 353                                                                 "Kind":"Deployment"
 354                                                         },
 355                                                         "Name": "deployment-1"
 356                                                 },
 357                                                 {
 358                                                         "GVK": {
 359                                                                 "Group":"",
 360                                                                 "Version":"v1",
 361                                                                 "Kind":"Service"
 362                                                         },
 363                                                         "Name": "service-1"
 364                                                 }
 365                                         ]
 366                                 }`),
 367                 },
 368                 InstanceKey{ID: "HaKpys8f"}.String(): {
 369                         "instance": []byte(
 370                                 `{
 371                                         "id":"HaKpys8f",
 372                                         "request": {
 373                                                 "profile-name":"profile2",
 374                                                 "rb-name":"test-rbdef",
 375                                                 "rb-version":"v1",
 376                                                 "cloud-region":"region1"
 377                                         },
 378                                         "namespace":"testnamespace",
 379                                         "resources": [
 380                                                 {
 381                                                         "GVK": {
 382                                                                 "Group":"apps",
 383                                                                 "Version":"v1",
 384                                                                 "Kind":"Deployment"
 385                                                         },
 386                                                         "Name": "deployment-1"
 387                                                 },
 388                                                 {
 389                                                         "GVK": {
 390                                                                 "Group":"",
 391                                                                 "Version":"v1",
 392                                                                 "Kind":"Service"
 393                                                         },
 394                                                         "Name": "service-1"
 395                                                 }
 396                                         ]
 397                                 }`),
 398                 },
 399                 InstanceKey{ID: "HaKpys8g"}.String(): {
 400                         "instance": []byte(
 401                                 `{
 402                                         "id":"HaKpys8g",
 403                                         "request": {
 404                                                 "profile-name":"profile1",
 405                                                 "rb-name":"test-rbdef",
 406                                                 "rb-version":"v2",
 407                                                 "cloud-region":"region1"
 408                                         },
 409                                         "namespace":"testnamespace",
 410                                         "resources": [
 411                                                 {
 412                                                         "GVK": {
 413                                                                 "Group":"apps",
 414                                                                 "Version":"v1",
 415                                                                 "Kind":"Deployment"
 416                                                         },
 417                                                         "Name": "deployment-1"
 418                                                 },
 419                                                 {
 420                                                         "GVK": {
 421                                                                 "Group":"",
 422                                                                 "Version":"v1",
 423                                                                 "Kind":"Service"
 424                                                         },
 425                                                         "Name": "service-1"
 426                                                 }
 427                                         ]
 428                                 }`),
 429                 },
 430         }
 431
 432         t.Run("Successfully Find Instance By Name", func(t *testing.T) {
 433                 db.DBconn = &db.MockDB{
 434                         Items: items,
 435                 }
 436
 437                 expected := []InstanceMiniResponse{
 438                         {
 439                                 ID: "HaKpys8e",
 440                                 Request: InstanceRequest{
 441                                         RBName:      "test-rbdef",
 442                                         RBVersion:   "v1",
 443                                         ProfileName: "profile1",
 444                                         CloudRegion: "region1",
 445                                         Labels: map[string]string{
 446                                                 "vf_module_id": "test-vf-module-id",
 447                                         },
 448                                 },
 449                                 Namespace: "testnamespace",
 450                         },
 451                         {
 452                                 ID: "HaKpys8f",
 453                                 Request: InstanceRequest{
 454                                         RBName:      "test-rbdef",
 455                                         RBVersion:   "v1",
 456                                         ProfileName: "profile2",
 457                                         CloudRegion: "region1",
 458                                 },
 459                                 Namespace: "testnamespace",
 460                         },
 461                         {
 462                                 ID: "HaKpys8g",
 463                                 Request: InstanceRequest{
 464                                         RBName:      "test-rbdef",
 465                                         RBVersion:   "v2",
 466                                         ProfileName: "profile1",
 467                                         CloudRegion: "region1",
 468                                 },
 469                                 Namespace: "testnamespace",
 470                         },
 471                 }
 472                 ic := NewInstanceClient()
 473                 name := "test-rbdef"
 474                 data, err := ic.Find(name, "", "", nil)
 475                 if err != nil {
 476                         t.Fatalf("TestInstanceFind returned an error (%s)", err)
 477                 }
 478
 479                 // Since the order of returned slice is not guaranteed
 480                 // Check both and return error if both don't match
 481                 sort.Slice(data, func(i, j int) bool {
 482                         return data[i].ID < data[j].ID
 483                 })
 484                 // Sort both as it is not expected that testCase.expected
 485                 // is sorted
 486                 sort.Slice(expected, func(i, j int) bool {
 487                         return expected[i].ID < expected[j].ID
 488                 })
 489
 490                 if !reflect.DeepEqual(expected, data) {
 491                         t.Fatalf("TestInstanceFind returned:\n result=%v\n expected=%v",
 492                                 data, expected)
 493                 }
 494         })
 495
 496         t.Run("Successfully Find Instance By Name and Label", func(t *testing.T) {
 497                 db.DBconn = &db.MockDB{
 498                         Items: items,
 499                 }
 500
 501                 expected := []InstanceMiniResponse{
 502                         {
 503                                 ID: "HaKpys8e",
 504                                 Request: InstanceRequest{
 505                                         RBName:      "test-rbdef",
 506                                         RBVersion:   "v1",
 507                                         ProfileName: "profile1",
 508                                         CloudRegion: "region1",
 509                                         Labels: map[string]string{
 510                                                 "vf_module_id": "test-vf-module-id",
 511                                         },
 512                                 },
 513                                 Namespace: "testnamespace",
 514                         },
 515                 }
 516                 ic := NewInstanceClient()
 517                 name := "test-rbdef"
 518                 labels := map[string]string{
 519                         "vf_module_id": "test-vf-module-id",
 520                 }
 521                 data, err := ic.Find(name, "", "", labels)
 522                 if err != nil {
 523                         t.Fatalf("TestInstanceFind returned an error (%s)", err)
 524                 }
 525
 526                 // Since the order of returned slice is not guaranteed
 527                 // Check both and return error if both don't match
 528                 sort.Slice(data, func(i, j int) bool {
 529                         return data[i].ID < data[j].ID
 530                 })
 531                 // Sort both as it is not expected that testCase.expected
 532                 // is sorted
 533                 sort.Slice(expected, func(i, j int) bool {
 534                         return expected[i].ID < expected[j].ID
 535                 })
 536
 537                 if !reflect.DeepEqual(expected, data) {
 538                         t.Fatalf("TestInstanceFind returned:\n result=%v\n expected=%v",
 539                                 data, expected)
 540                 }
 541         })
 542
 543         t.Run("Successfully Find Instance By Name Version", func(t *testing.T) {
 544                 db.DBconn = &db.MockDB{
 545                         Items: items,
 546                 }
 547
 548                 expected := []InstanceMiniResponse{
 549                         {
 550                                 ID: "HaKpys8e",
 551                                 Request: InstanceRequest{
 552                                         RBName:      "test-rbdef",
 553                                         RBVersion:   "v1",
 554                                         ProfileName: "profile1",
 555                                         CloudRegion: "region1",
 556                                         Labels: map[string]string{
 557                                                 "vf_module_id": "test-vf-module-id",
 558                                         },
 559                                 },
 560                                 Namespace: "testnamespace",
 561                         },
 562                         {
 563                                 ID: "HaKpys8f",
 564                                 Request: InstanceRequest{
 565                                         RBName:      "test-rbdef",
 566                                         RBVersion:   "v1",
 567                                         ProfileName: "profile2",
 568                                         CloudRegion: "region1",
 569                                 },
 570                                 Namespace: "testnamespace",
 571                         },
 572                 }
 573                 ic := NewInstanceClient()
 574                 name := "test-rbdef"
 575                 data, err := ic.Find(name, "v1", "", nil)
 576                 if err != nil {
 577                         t.Fatalf("TestInstanceFind returned an error (%s)", err)
 578                 }
 579
 580                 // Since the order of returned slice is not guaranteed
 581                 // Check both and return error if both don't match
 582                 sort.Slice(data, func(i, j int) bool {
 583                         return data[i].ID < data[j].ID
 584                 })
 585                 // Sort both as it is not expected that testCase.expected
 586                 // is sorted
 587                 sort.Slice(expected, func(i, j int) bool {
 588                         return expected[i].ID < expected[j].ID
 589                 })
 590
 591                 if !reflect.DeepEqual(expected, data) {
 592                         t.Fatalf("TestInstanceFind returned:\n result=%v\n expected=%v",
 593                                 data, expected)
 594                 }
 595         })
 596
 597         t.Run("Successfully Find Instance By Name Version Profile", func(t *testing.T) {
 598                 db.DBconn = &db.MockDB{
 599                         Items: items,
 600                 }
 601
 602                 expected := []InstanceMiniResponse{
 603                         {
 604                                 ID: "HaKpys8e",
 605                                 Request: InstanceRequest{
 606                                         RBName:      "test-rbdef",
 607                                         RBVersion:   "v1",
 608                                         ProfileName: "profile1",
 609                                         CloudRegion: "region1",
 610                                         Labels: map[string]string{
 611                                                 "vf_module_id": "test-vf-module-id",
 612                                         },
 613                                 },
 614                                 Namespace: "testnamespace",
 615                         },
 616                 }
 617                 ic := NewInstanceClient()
 618                 name := "test-rbdef"
 619                 data, err := ic.Find(name, "v1", "profile1", nil)
 620                 if err != nil {
 621                         t.Fatalf("TestInstanceFind returned an error (%s)", err)
 622                 }
 623
 624                 // Since the order of returned slice is not guaranteed
 625                 // Check both and return error if both don't match
 626                 sort.Slice(data, func(i, j int) bool {
 627                         return data[i].ID < data[j].ID
 628                 })
 629                 // Sort both as it is not expected that testCase.expected
 630                 // is sorted
 631                 sort.Slice(expected, func(i, j int) bool {
 632                         return expected[i].ID < expected[j].ID
 633                 })
 634
 635                 if !reflect.DeepEqual(expected, data) {
 636                         t.Fatalf("TestInstanceFind returned:\n result=%v\n expected=%v",
 637                                 data, expected)
 638                 }
 639         })
 640
 641         t.Run("Find non-existing Instance", func(t *testing.T) {
 642                 db.DBconn = &db.MockDB{
 643                         Items: map[string]map[string][]byte{
 644                                 InstanceKey{ID: "HaKpys8e"}.String(): {
 645                                         "instance": []byte(
 646                                                 `{
 647                                                         "profile-name":"profile1",
 648                                                         "id":"HaKpys8e",
 649                                                         "namespace":"testnamespace",
 650                                                         "rb-name":"test-rbdef",
 651                                                         "rb-version":"v1",
 652                                                         "cloud-region":"region1",
 653                                                         "resources": [
 654                                                                 {
 655                                                                         "GVK": {
 656                                                                                 "Group":"apps",
 657                                                                                 "Version":"v1",
 658                                                                                 "Kind":"Deployment"
 659                                                                         },
 660                                                                         "Name": "deployment-1"
 661                                                                 },
 662                                                                 {
 663                                                                         "GVK": {
 664                                                                                 "Group":"",
 665                                                                                 "Version":"v1",
 666                                                                                 "Kind":"Service"
 667                                                                         },
 668                                                                         "Name": "service-1"
 669                                                                 }
 670                                                         ]
 671                                                 }`),
 672                                 },
 673                         },
 674                 }
 675
 676                 ic := NewInstanceClient()
 677                 name := "non-existing"
 678                 resp, _ := ic.Find(name, "", "", nil)
 679                 if len(resp) != 0 {
 680                         t.Fatalf("Expected 0 responses, but got %d", len(resp))
 681                 }
 682         })
 683 }
 684
 685 func TestInstanceDelete(t *testing.T) {
 686         oldkrdPluginData := utils.LoadedPlugins
 687
 688         defer func() {
 689                 utils.LoadedPlugins = oldkrdPluginData
 690         }()
 691
 692         err := LoadMockPlugins(utils.LoadedPlugins)
 693         if err != nil {
 694                 t.Fatalf("TestInstanceDelete returned an error (%s)", err)
 695         }
 696
 697         // Load the mock kube config file into memory
 698         fd, err := ioutil.ReadFile("../../mock_files/mock_configs/mock_kube_config")
 699         if err != nil {
 700                 t.Fatal("Unable to read mock_kube_config")
 701         }
 702
 703         t.Run("Successfully delete Instance", func(t *testing.T) {
 704                 db.DBconn = &db.MockDB{
 705                         Items: map[string]map[string][]byte{
 706                                 InstanceKey{ID: "HaKpys8e"}.String(): {
 707                                         "instance": []byte(
 708                                                 `{
 709                                                         "id":"HaKpys8e",
 710                                                         "request": {
 711                                                                 "profile-name":"profile1",
 712                                                                 "rb-name":"test-rbdef",
 713                                                                 "rb-version":"v1",
 714                                                                 "cloud-region":"mock_connection"
 715                                                         },
 716                                                         "namespace":"testnamespace",
 717                                                         "resources": [
 718                                                                 {
 719                                                                         "GVK": {
 720                                                                                 "Group":"apps",
 721                                                                                 "Version":"v1",
 722                                                                                 "Kind":"Deployment"
 723                                                                         },
 724                                                                         "Name": "deployment-1"
 725                                                                 },
 726                                                                 {
 727                                                                         "GVK": {
 728                                                                                 "Group":"",
 729                                                                                 "Version":"v1",
 730                                                                                 "Kind":"Service"
 731                                                                         },
 732                                                                         "Name": "service-1"
 733                                                                 }
 734                                                         ]
 735                                                 }`),
 736                                 },
 737                                 connection.ConnectionKey{CloudRegion: "mock_connection"}.String(): {
 738                                         "metadata": []byte(
 739                                                 "{\"cloud-region\":\"mock_connection\"," +
 740                                                         "\"cloud-owner\":\"mock_owner\"," +
 741                                                         "\"kubeconfig\": \"" + base64.StdEncoding.EncodeToString(fd) + "\"}"),
 742                                 },
 743                         },
 744                 }
 745
 746                 ic := NewInstanceClient()
 747                 id := "HaKpys8e"
 748                 err := ic.Delete(id)
 749                 if err != nil {
 750                         t.Fatalf("TestInstanceDelete returned an error (%s)", err)
 751                 }
 752         })
 753
 754         t.Run("Delete non-existing Instance", func(t *testing.T) {
 755                 db.DBconn = &db.MockDB{
 756                         Items: map[string]map[string][]byte{
 757                                 InstanceKey{ID: "HaKpys8e"}.String(): {
 758                                         "instance": []byte(
 759                                                 `{
 760                                                         "profile-name":"profile1",
 761                                                         "id":"HaKpys8e",
 762                                                         "namespace":"testnamespace",
 763                                                         "rb-name":"test-rbdef",
 764                                                         "rb-version":"v1",
 765                                                         "cloud-region":"mock_kube_config",
 766                                                         "resources": [
 767                                                                 {
 768                                                                         "GVK": {
 769                                                                                 "Group":"apps",
 770                                                                                 "Version":"v1",
 771                                                                                 "Kind":"Deployment"
 772                                                                         },
 773                                                                         "Name": "deployment-1"
 774                                                                 },
 775                                                                 {
 776                                                                         "GVK": {
 777                                                                                 "Group":"",
 778                                                                                 "Version":"v1",
 779                                                                                 "Kind":"Service"
 780                                                                         },
 781                                                                         "Name": "service-1"
 782                                                                 }
 783                                                         ]
 784                                                 }`),
 785                                 },
 786                         },
 787                 }
 788
 789                 ic := NewInstanceClient()
 790                 id := "non-existing"
 791                 err := ic.Delete(id)
 792                 if err == nil {
 793                         t.Fatal("Expected error, got pass", err)
 794                 }
 795         })
 796 }