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

   1 // SPDX-License-Identifier: Apache-2.0
   2 // Copyright (c) 2020 Intel Corporation
   3
   4 package contextdb
   5
   6 import (
   7         "context"
   8         pkgerrors "github.com/pkg/errors"
   9         "go.etcd.io/etcd/clientv3"
  10         mvccpb "go.etcd.io/etcd/mvcc/mvccpb"
  11         "strings"
  12         "testing"
  13 )
  14
  15 type kv struct {
  16         Key   []byte
  17         Value []byte
  18 }
  19
  20 // MockEtcdClient for mocking etcd
  21 type MockEtcdClient struct {
  22         Kvs   []*mvccpb.KeyValue
  23         Count int64
  24         Err   error
  25 }
  26
  27 // Mocking only Single Value
  28 // Put function
  29 func (e *MockEtcdClient) Put(ctx context.Context, key, val string, opts ...clientv3.OpOption) (*clientv3.PutResponse, error) {
  30         var m mvccpb.KeyValue
  31         m.Key = []byte(key)
  32         m.Value = []byte(val)
  33         e.Count = e.Count + 1
  34         e.Kvs = append(e.Kvs, &m)
  35         return &clientv3.PutResponse{}, e.Err
  36 }
  37
  38 // Get function
  39 func (e *MockEtcdClient) Get(ctx context.Context, key string, opts ...clientv3.OpOption) (*clientv3.GetResponse, error) {
  40         var g clientv3.GetResponse
  41         g.Kvs = e.Kvs
  42         g.Count = e.Count
  43         return &g, e.Err
  44 }
  45
  46 // Delete function
  47 func (e *MockEtcdClient) Delete(ctx context.Context, key string, opts ...clientv3.OpOption) (*clientv3.DeleteResponse, error) {
  48         return &clientv3.DeleteResponse{}, e.Err
  49 }
  50
  51 type testStruct struct {
  52         Name string `json:"name"`
  53         Num  int    `json:"num"`
  54 }
  55
  56 // TestPut test Put
  57 func TestPut(t *testing.T) {
  58         testCases := []struct {
  59                 label         string
  60                 mockEtcd      *MockEtcdClient
  61                 expectedError string
  62                 key           string
  63                 value         *testStruct
  64         }{
  65                 {
  66                         label:    "Success Case",
  67                         mockEtcd: &MockEtcdClient{},
  68                         key:      "test1",
  69                         value:    &testStruct{Name: "test", Num: 5},
  70                 },
  71                 {
  72                         label:         "Key is null",
  73                         mockEtcd:      &MockEtcdClient{},
  74                         key:           "",
  75                         expectedError: "Key is null",
  76                 },
  77                 {
  78                         label:         "Value is nil",
  79                         mockEtcd:      &MockEtcdClient{},
  80                         key:           "test1",
  81                         value:         nil,
  82                         expectedError: "Value is nil",
  83                 },
  84                 {
  85                         label:         "Error creating etcd entry",
  86                         mockEtcd:      &MockEtcdClient{Err: pkgerrors.New("DB Error")},
  87                         key:           "test1",
  88                         value:         &testStruct{Name: "test", Num: 5},
  89                         expectedError: "Error creating etcd entry: DB Error",
  90                 },
  91         }
  92         for _, testCase := range testCases {
  93                 t.Run(testCase.label, func(t *testing.T) {
  94                         cli, _ := NewEtcdClient(&clientv3.Client{}, EtcdConfig{})
  95                         getEtcd = func(e *EtcdClient) Etcd {
  96                                 return testCase.mockEtcd
  97                         }
  98                         err := cli.Put(testCase.key, testCase.value)
  99                         if err != nil {
 100                                 if testCase.expectedError == "" {
 101                                         t.Fatalf("Method returned an un-expected (%s)", err)
 102                                 }
 103                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {
 104                                         t.Fatalf("Method returned an error (%s)", err)
 105                                 }
 106                         }
 107
 108                 })
 109         }
 110 }
 111
 112 func TestGet(t *testing.T) {
 113         testCases := []struct {
 114                 label         string
 115                 mockEtcd      *MockEtcdClient
 116                 expectedError string
 117                 key           string
 118                 value         *testStruct
 119         }{
 120                 {
 121                         label:         "Key is null",
 122                         mockEtcd:      &MockEtcdClient{},
 123                         key:           "",
 124                         value:         nil,
 125                         expectedError: "Key is null",
 126                 },
 127                 {
 128                         label:         "Key doesn't exist",
 129                         mockEtcd:      &MockEtcdClient{},
 130                         key:           "test1",
 131                         value:         &testStruct{},
 132                         expectedError: "Key doesn't exist",
 133                 },
 134                 {
 135                         label:         "Error getting etcd entry",
 136                         mockEtcd:      &MockEtcdClient{Err: pkgerrors.New("DB Error")},
 137                         key:           "test1",
 138                         value:         &testStruct{},
 139                         expectedError: "Error getting etcd entry: DB Error",
 140                 },
 141         }
 142         for _, testCase := range testCases {
 143                 t.Run(testCase.label, func(t *testing.T) {
 144                         cli, _ := NewEtcdClient(&clientv3.Client{}, EtcdConfig{})
 145                         getEtcd = func(e *EtcdClient) Etcd {
 146                                 return testCase.mockEtcd
 147                         }
 148                         err := cli.Get(testCase.key, testCase.value)
 149                         if err != nil {
 150                                 if testCase.expectedError == "" {
 151                                         t.Fatalf("Method returned an un-expected (%s)", err)
 152                                 }
 153                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {
 154                                         t.Fatalf("Method returned an error (%s)", err)
 155                                 }
 156                         }
 157
 158                 })
 159         }
 160 }
 161
 162 func TestGetString(t *testing.T) {
 163         testCases := []struct {
 164                 label         string
 165                 mockEtcd      *MockEtcdClient
 166                 expectedError string
 167                 value         string
 168         }{
 169                 {
 170                         label:    "Success Case",
 171                         mockEtcd: &MockEtcdClient{},
 172                 },
 173         }
 174         for _, testCase := range testCases {
 175                 t.Run(testCase.label, func(t *testing.T) {
 176                         cli, _ := NewEtcdClient(&clientv3.Client{}, EtcdConfig{})
 177                         getEtcd = func(e *EtcdClient) Etcd {
 178                                 return testCase.mockEtcd
 179                         }
 180                         err := cli.Put("test", "test1")
 181                         if err != nil {
 182                                 t.Error("Test failed", err)
 183                         }
 184                         var s string
 185                         err = cli.Get("test", &s)
 186                         if err != nil {
 187                                 t.Error("Test failed", err)
 188                         }
 189                         if "test1" != s {
 190                                 t.Error("Get Failed")
 191                         }
 192                 })
 193         }
 194 }
 195
 196 func TestDelete(t *testing.T) {
 197         testCases := []struct {
 198                 label         string
 199                 mockEtcd      *MockEtcdClient
 200                 expectedError string
 201         }{
 202                 {
 203                         label:    "Success Case",
 204                         mockEtcd: &MockEtcdClient{},
 205                 },
 206                 {
 207                         label:         "Delete failed etcd entry",
 208                         mockEtcd:      &MockEtcdClient{Err: pkgerrors.New("DB Error")},
 209                         expectedError: "Delete failed etcd entry: DB Error",
 210                 },
 211         }
 212         for _, testCase := range testCases {
 213                 t.Run(testCase.label, func(t *testing.T) {
 214                         cli, _ := NewEtcdClient(&clientv3.Client{}, EtcdConfig{})
 215                         getEtcd = func(e *EtcdClient) Etcd {
 216                                 return testCase.mockEtcd
 217                         }
 218                         err := cli.Delete("test")
 219                         if err != nil {
 220                                 if testCase.expectedError == "" {
 221                                         t.Fatalf("Method returned an un-expected (%s)", err)
 222                                 }
 223                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {
 224                                         t.Fatalf("Method returned an error (%s)", err)
 225                                 }
 226                         }
 227
 228                 })
 229         }
 230 }
 231
 232 func TestGetAll(t *testing.T) {
 233         testCases := []struct {
 234                 label         string
 235                 mockEtcd      *MockEtcdClient
 236                 expectedError string
 237         }{
 238                 {
 239                         label:         "Key doesn't exist",
 240                         mockEtcd:      &MockEtcdClient{},
 241                         expectedError: "Key doesn't exist",
 242                 },
 243                 {
 244                         label:         "Error getting etcd entry",
 245                         mockEtcd:      &MockEtcdClient{Err: pkgerrors.New("DB Error")},
 246                         expectedError: "Error getting etcd entry: DB Error",
 247                 },
 248         }
 249         for _, testCase := range testCases {
 250                 t.Run(testCase.label, func(t *testing.T) {
 251                         cli, _ := NewEtcdClient(&clientv3.Client{}, EtcdConfig{})
 252                         getEtcd = func(e *EtcdClient) Etcd {
 253                                 return testCase.mockEtcd
 254                         }
 255                         _, err := cli.GetAllKeys("test")
 256                         if err != nil {
 257                                 if testCase.expectedError == "" {
 258                                         t.Fatalf("Method returned an un-expected (%s)", err)
 259                                 }
 260                                 if !strings.Contains(string(err.Error()), testCase.expectedError) {
 261                                         t.Fatalf("Method returned an error (%s)", err)
 262                                 }
 263                         }
 264                 })
 265         }
 266 }