gerrit.akraino Code Review - icn/sdwan.git/blob

   1 // SPDX-License-Identifier: Apache-2.0
   2 // Copyright (c) 2020 Intel Corporation
   3
   4 package controller
   5
   6 import (
   7         "reflect"
   8         "strings"
   9         "testing"
  10
  11         "github.com/open-ness/EMCO/src/orchestrator/pkg/infra/db"
  12         "github.com/open-ness/EMCO/src/orchestrator/pkg/module/types"
  13
  14         pkgerrors "github.com/pkg/errors"
  15 )
  16
  17 func TestCreateController(t *testing.T) {
  18         testCases := []struct {
  19                 label         string
  20                 inp           Controller
  21                 expectedError string
  22                 mockdb        *db.MockDB
  23                 expected      Controller
  24         }{
  25                 {
  26                         label: "Create Controller",
  27                         inp: Controller{
  28                                 Metadata: types.Metadata{
  29                                         Name: "testController",
  30                                 },
  31                                 Spec: ControllerSpec{
  32                                         Host: "132.156.0.10",
  33                                         Port: 8080,
  34                                 },
  35                         },
  36                         expected: Controller{
  37                                 Metadata: types.Metadata{
  38                                         Name: "testController",
  39                                 },
  40                                 Spec: ControllerSpec{
  41                                         Host: "132.156.0.10",
  42                                         Port: 8080,
  43                                 },
  44                         },
  45                         expectedError: "",
  46                         mockdb:        &db.MockDB{},
  47                 },
  48                 {
  49                         label:         "Failed Create Controller",
  50                         expectedError: "Error Creating Controller",
  51                         mockdb: &db.MockDB{
  52                                 Err: pkgerrors.New("Error Creating Controller"),
  53                         },
  54                 },
  55         }
  56
  57         for _, testCase := range testCases {
  58                 t.Run(testCase.label, func(t *testing.T) {
  59                         db.DBconn = testCase.mockdb
  60                         impl := NewControllerClient()
  61                         got, err := impl.CreateController(testCase.inp, false)
  62                         if err != nil {
  63                                 if testCase.expectedError == "" {
  64                                         t.Fatalf("Create returned an unexpected error %s", err)
  65                                 }
  66                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
  67                                         t.Fatalf("Create returned an unexpected error %s", err)
  68                                 }
  69                         } else {
  70                                 if reflect.DeepEqual(testCase.expected, got) == false {
  71                                         t.Errorf("Create returned unexpected body: got %v;"+
  72                                                 " expected %v", got, testCase.expected)
  73                                 }
  74                         }
  75                 })
  76         }
  77 }
  78
  79 func TestGetController(t *testing.T) {
  80
  81         testCases := []struct {
  82                 label         string
  83                 name          string
  84                 expectedError string
  85                 mockdb        *db.MockDB
  86                 inp           string
  87                 expected      Controller
  88         }{
  89                 {
  90                         label: "Get Controller",
  91                         name:  "testController",
  92                         expected: Controller{
  93                                 Metadata: types.Metadata{
  94                                         Name: "testController",
  95                                 },
  96                                 Spec: ControllerSpec{
  97                                         Host: "132.156.0.10",
  98                                         Port: 8080,
  99                                 },
 100                         },
 101                         expectedError: "",
 102                         mockdb: &db.MockDB{
 103                                 Items: []map[string]map[string][]byte{
 104                                         {
 105                                                 ControllerKey{ControllerName: "testController"}.String(): {
 106                                                         "controllermetadata": []byte(
 107                                                                 "{\"metadata\":{" +
 108                                                                         "\"name\":\"testController\"" +
 109                                                                         "}," +
 110                                                                         "\"spec\":{" +
 111                                                                         "\"host\":\"132.156.0.10\"," +
 112                                                                         "\"port\": 8080 }}"),
 113                                                 },
 114                                         },
 115                                 },
 116                         },
 117                 },
 118                 {
 119                         label:         "Get Error",
 120                         expectedError: "DB Error",
 121                         mockdb: &db.MockDB{
 122                                 Err: pkgerrors.New("DB Error"),
 123                         },
 124                 },
 125         }
 126
 127         for _, testCase := range testCases {
 128                 t.Run(testCase.label, func(t *testing.T) {
 129                         db.DBconn = testCase.mockdb
 130                         impl := NewControllerClient()
 131                         got, err := impl.GetController(testCase.name)
 132                         if err != nil {
 133                                 if testCase.expectedError == "" {
 134                                         t.Fatalf("Get returned an unexpected error: %s", err)
 135                                 }
 136                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
 137                                         t.Fatalf("Get returned an unexpected error: %s", err)
 138                                 }
 139                         } else {
 140                                 if reflect.DeepEqual(testCase.expected, got) == false {
 141                                         t.Errorf("Get returned unexpected body: got %v;"+
 142                                                 " expected %v", got, testCase.expected)
 143                                 }
 144                         }
 145                 })
 146         }
 147 }
 148
 149 func TestDeleteController(t *testing.T) {
 150
 151         testCases := []struct {
 152                 label         string
 153                 name          string
 154                 expectedError string
 155                 mockdb        *db.MockDB
 156         }{
 157                 {
 158                         label:  "Delete Controller",
 159                         name:   "testController",
 160                         mockdb: &db.MockDB{},
 161                 },
 162                 {
 163                         label:         "Delete Error",
 164                         expectedError: "DB Error",
 165                         mockdb: &db.MockDB{
 166                                 Err: pkgerrors.New("DB Error"),
 167                         },
 168                 },
 169         }
 170
 171         for _, testCase := range testCases {
 172                 t.Run(testCase.label, func(t *testing.T) {
 173                         db.DBconn = testCase.mockdb
 174                         impl := NewControllerClient()
 175                         err := impl.DeleteController(testCase.name)
 176                         if err != nil {
 177                                 if testCase.expectedError == "" {
 178                                         t.Fatalf("Delete returned an unexpected error %s", err)
 179                                 }
 180                                 if strings.Contains(err.Error(), testCase.expectedError) == false {
 181                                         t.Fatalf("Delete returned an unexpected error %s", err)
 182                                 }
 183                         }
 184                 })
 185         }
 186 }