src/k8splugin/vnfd/vnfd_test.go

   1 /*
   2  * Copyright 2018 Intel Corporation, Inc
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package vnfd
  18
  19 import (
  20         "k8splugin/db"
  21         "reflect"
  22         "strings"
  23         "testing"
  24
  25         "github.com/hashicorp/consul/api"
  26         pkgerrors "github.com/pkg/errors"
  27 )
  28
  29 //Creating an embedded interface via anonymous variable
  30 //This allows us to make mockDB satisfy the DatabaseConnection
  31 //interface even if we are not implementing all the methods in it
  32 type mockDB struct {
  33         db.DatabaseConnection
  34         Items api.KVPairs
  35         Err   error
  36 }
  37
  38 func (m *mockDB) CreateEntry(key string, value string) error {
  39         return m.Err
  40 }
  41
  42 func (m *mockDB) ReadEntry(key string) (string, bool, error) {
  43         if m.Err != nil {
  44                 return "", false, m.Err
  45         }
  46
  47         for _, kvpair := range m.Items {
  48                 if kvpair.Key == key {
  49                         return string(kvpair.Value), true, nil
  50                 }
  51         }
  52
  53         return "", false, nil
  54 }
  55
  56 func (m *mockDB) DeleteEntry(key string) error {
  57         return m.Err
  58 }
  59
  60 func (m *mockDB) ReadAll(prefix string) ([]string, error) {
  61         if m.Err != nil {
  62                 return []string{}, m.Err
  63         }
  64
  65         var res []string
  66
  67         for _, keypair := range m.Items {
  68                 res = append(res, keypair.Key)
  69         }
  70
  71         return res, nil
  72 }
  73
  74 func TestCreate(t *testing.T) {
  75         testCases := []struct {
  76                 label         string
  77                 inp           VNFDefinition
  78                 expectedError string
  79                 mockdb        *mockDB
  80                 expected      VNFDefinition
  81         }{
  82                 {
  83                         label: "Create VNF Definition",
  84                         inp: VNFDefinition{
  85                                 UUID:        "123e4567-e89b-12d3-a456-426655440000",
  86                                 Name:        "testvnf",
  87                                 Description: "testvnf",
  88                                 ServiceType: "firewall",
  89                         },
  90                         expected: VNFDefinition{
  91                                 UUID:        "123e4567-e89b-12d3-a456-426655440000",
  92                                 Name:        "testvnf",
  93                                 Description: "testvnf",
  94                                 ServiceType: "firewall",
  95                         },
  96                         expectedError: "",
  97                         mockdb:        &mockDB{},
  98                 },
  99                 {
 100                         label:         "Failed Create VNF Definition",
 101                         expectedError: "Error Creating Definition",
 102                         mockdb: &mockDB{
 103                                 Err: pkgerrors.New("Error Creating Definition"),
 104                         },
 105                 },
 106         }
 107
 108         for _, testCase := range testCases {
 109                 t.Run(testCase.label, func(t *testing.T) {
 110                         db.DBconn = testCase.mockdb
 111                         vimpl := GetVNFDClient()
 112                         got, err := vimpl.Create(testCase.inp)
 113                         if err != nil {
 114                                 if testCase.expectedError == "" {
 115                                         t.Fatalf("Create returned an unexpected error %s", err)
 116                                 }
 117                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
 118                                         t.Fatalf("Create returned an unexpected error %s", err)
 119                                 }
 120                         } else {
 121                                 if reflect.DeepEqual(testCase.expected, got) == false {
 122                                         t.Errorf("Create VNF returned unexpected body: got %v;"+
 123                                                 " expected %v", got, testCase.expected)
 124                                 }
 125                         }
 126                 })
 127         }
 128 }
 129
 130 func TestList(t *testing.T) {
 131
 132         testCases := []struct {
 133                 label         string
 134                 expectedError string
 135                 mockdb        *mockDB
 136                 expected      []VNFDefinition
 137         }{
 138                 {
 139                         label: "List VNF Definition",
 140                         expected: []VNFDefinition{
 141                                 {
 142                                         UUID:        "123e4567-e89b-12d3-a456-426655440000",
 143                                         Name:        "testvnf",
 144                                         Description: "testvnf",
 145                                         ServiceType: "firewall",
 146                                 },
 147                                 {
 148                                         UUID:        "123e4567-e89b-12d3-a456-426655441111",
 149                                         Name:        "testvnf2",
 150                                         Description: "testvnf2",
 151                                         ServiceType: "dns",
 152                                 },
 153                         },
 154                         expectedError: "",
 155                         mockdb: &mockDB{
 156                                 Items: api.KVPairs{
 157                                         &api.KVPair{
 158                                                 Key: "vnfd/123e4567-e89b-12d3-a456-426655440000",
 159                                                 Value: []byte("{\"name\":\"testvnf\"," +
 160                                                         "\"description\":\"testvnf\"," +
 161                                                         "\"uuid\":\"123e4567-e89b-12d3-a456-426655440000\"," +
 162                                                         "\"service-type\":\"firewall\"}"),
 163                                         },
 164                                         &api.KVPair{
 165                                                 Key: "vnfd/123e4567-e89b-12d3-a456-426655441111",
 166                                                 Value: []byte("{\"name\":\"testvnf2\"," +
 167                                                         "\"description\":\"testvnf2\"," +
 168                                                         "\"uuid\":\"123e4567-e89b-12d3-a456-426655441111\"," +
 169                                                         "\"service-type\":\"dns\"}"),
 170                                         },
 171                                 },
 172                         },
 173                 },
 174                 {
 175                         label:         "List Error",
 176                         expectedError: "DB Error",
 177                         mockdb: &mockDB{
 178                                 Err: pkgerrors.New("DB Error"),
 179                         },
 180                 },
 181         }
 182
 183         for _, testCase := range testCases {
 184                 t.Run(testCase.label, func(t *testing.T) {
 185                         db.DBconn = testCase.mockdb
 186                         vimpl := GetVNFDClient()
 187                         got, err := vimpl.List()
 188                         if err != nil {
 189                                 if testCase.expectedError == "" {
 190                                         t.Fatalf("List returned an unexpected error %s", err)
 191                                 }
 192                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
 193                                         t.Fatalf("List returned an unexpected error %s", err)
 194                                 }
 195                         } else {
 196                                 if reflect.DeepEqual(testCase.expected, got) == false {
 197                                         t.Errorf("List VNF returned unexpected body: got %v;"+
 198                                                 " expected %v", got, testCase.expected)
 199                                 }
 200                         }
 201                 })
 202         }
 203 }
 204
 205 func TestGet(t *testing.T) {
 206
 207         testCases := []struct {
 208                 label         string
 209                 expectedError string
 210                 mockdb        *mockDB
 211                 inp           string
 212                 expected      VNFDefinition
 213         }{
 214                 {
 215                         label: "Get VNF Definition",
 216                         inp:   "123e4567-e89b-12d3-a456-426655440000",
 217                         expected: VNFDefinition{
 218                                 UUID:        "123e4567-e89b-12d3-a456-426655440000",
 219                                 Name:        "testvnf",
 220                                 Description: "testvnf",
 221                                 ServiceType: "firewall",
 222                         },
 223                         expectedError: "",
 224                         mockdb: &mockDB{
 225                                 Items: api.KVPairs{
 226                                         &api.KVPair{
 227                                                 Key: "vnfd/123e4567-e89b-12d3-a456-426655440000",
 228                                                 Value: []byte("{\"name\":\"testvnf\"," +
 229                                                         "\"description\":\"testvnf\"," +
 230                                                         "\"uuid\":\"123e4567-e89b-12d3-a456-426655440000\"," +
 231                                                         "\"service-type\":\"firewall\"}"),
 232                                         },
 233                                 },
 234                         },
 235                 },
 236                 {
 237                         label:         "Get Error",
 238                         expectedError: "DB Error",
 239                         mockdb: &mockDB{
 240                                 Err: pkgerrors.New("DB Error"),
 241                         },
 242                 },
 243         }
 244
 245         for _, testCase := range testCases {
 246                 t.Run(testCase.label, func(t *testing.T) {
 247                         db.DBconn = testCase.mockdb
 248                         vimpl := GetVNFDClient()
 249                         got, err := vimpl.Get(testCase.inp)
 250                         if err != nil {
 251                                 if testCase.expectedError == "" {
 252                                         t.Fatalf("Get returned an unexpected error %s", err)
 253                                 }
 254                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
 255                                         t.Fatalf("Get returned an unexpected error %s", err)
 256                                 }
 257                         } else {
 258                                 if reflect.DeepEqual(testCase.expected, got) == false {
 259                                         t.Errorf("Get VNF returned unexpected body: got %v;"+
 260                                                 " expected %v", got, testCase.expected)
 261                                 }
 262                         }
 263                 })
 264         }
 265 }
 266
 267 func TestDelete(t *testing.T) {
 268
 269         testCases := []struct {
 270                 label         string
 271                 inp           string
 272                 expectedError string
 273                 mockdb        *mockDB
 274                 expected      []VNFDefinition
 275         }{
 276                 {
 277                         label:  "Delete VNF Definition",
 278                         inp:    "123e4567-e89b-12d3-a456-426655440000",
 279                         mockdb: &mockDB{},
 280                 },
 281                 {
 282                         label:         "Delete Error",
 283                         expectedError: "DB Error",
 284                         mockdb: &mockDB{
 285                                 Err: pkgerrors.New("DB Error"),
 286                         },
 287                 },
 288         }
 289
 290         for _, testCase := range testCases {
 291                 t.Run(testCase.label, func(t *testing.T) {
 292                         db.DBconn = testCase.mockdb
 293                         vimpl := GetVNFDClient()
 294                         err := vimpl.Delete(testCase.inp)
 295                         if err != nil {
 296                                 if testCase.expectedError == "" {
 297                                         t.Fatalf("Delete returned an unexpected error %s", err)
 298                                 }
 299                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
 300                                         t.Fatalf("Delete returned an unexpected error %s", err)
 301                                 }
 302                         }
 303                 })
 304         }
 305 }