sdl_test.go

   1 /*
   2    Copyright (c) 2019 AT&T Intellectual Property.
   3    Copyright (c) 2018-2019 Nokia.
   4
   5    Licensed under the Apache License, Version 2.0 (the "License");
   6    you may not use this file except in compliance with the License.
   7    You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 */
  17
  18 package sdlgo_test
  19
  20 import (
  21         "errors"
  22         "testing"
  23
  24         "gerrit.oran-osc.org/r/ric-plt/sdlgo"
  25         "github.com/stretchr/testify/assert"
  26         "github.com/stretchr/testify/mock"
  27 )
  28
  29 type mockDB struct {
  30         mock.Mock
  31 }
  32
  33 func (m *mockDB) MSet(pairs ...interface{}) error {
  34         a := m.Called(pairs)
  35         return a.Error(0)
  36 }
  37
  38 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
  39         a := m.Called(keys)
  40         return a.Get(0).([]interface{}), a.Error(1)
  41 }
  42
  43 func (m *mockDB) Close() error {
  44         a := m.Called()
  45         return a.Error(0)
  46 }
  47
  48 func (m *mockDB) Del(keys []string) error {
  49         a := m.Called(keys)
  50         return a.Error(0)
  51 }
  52
  53 func (m *mockDB) Keys(pattern string) ([]string, error) {
  54         a := m.Called(pattern)
  55         return a.Get(0).([]string), a.Error(1)
  56 }
  57
  58 func (m *mockDB) SetIE(key string, oldData, newData interface{}) (bool, error) {
  59         a := m.Called(key, oldData, newData)
  60         return a.Bool(0), a.Error(1)
  61 }
  62
  63 func (m *mockDB) SetNX(key string, data interface{}) (bool, error) {
  64         a := m.Called(key, data)
  65         return a.Bool(0), a.Error(1)
  66 }
  67
  68 func (m *mockDB) DelIE(key string, data interface{}) (bool, error) {
  69         a := m.Called(key, data)
  70         return a.Bool(0), a.Error(1)
  71 }
  72
  73 func setup() (*mockDB, *sdlgo.SdlInstance) {
  74         m := new(mockDB)
  75         i := sdlgo.NewSdlInstance("namespace", m)
  76         return m, i
  77 }
  78
  79 func TestGetOneKey(t *testing.T) {
  80         m, i := setup()
  81
  82         mgetExpected := []string{"{namespace},key"}
  83         mReturn := []interface{}{"somevalue"}
  84         mReturnExpected := make(map[string]interface{})
  85         mReturnExpected["key"] = "somevalue"
  86
  87         m.On("MGet", mgetExpected).Return(mReturn, nil)
  88         retVal, err := i.Get([]string{"key"})
  89         assert.Nil(t, err)
  90         assert.Equal(t, mReturnExpected, retVal)
  91         m.AssertExpectations(t)
  92 }
  93
  94 func TestGetSeveralKeys(t *testing.T) {
  95         m, i := setup()
  96
  97         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
  98         mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
  99         mReturnExpected := make(map[string]interface{})
 100         mReturnExpected["key1"] = "somevalue1"
 101         mReturnExpected["key2"] = 2
 102         mReturnExpected["key3"] = "someothervalue"
 103
 104         m.On("MGet", mgetExpected).Return(mReturn, nil)
 105         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 106         assert.Nil(t, err)
 107         assert.Equal(t, mReturnExpected, retVal)
 108         m.AssertExpectations(t)
 109 }
 110
 111 func TestGetSeveralKeysSomeFail(t *testing.T) {
 112         m, i := setup()
 113
 114         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
 115         mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
 116         mReturnExpected := make(map[string]interface{})
 117         mReturnExpected["key1"] = "somevalue1"
 118         mReturnExpected["key2"] = nil
 119         mReturnExpected["key3"] = "someothervalue"
 120
 121         m.On("MGet", mgetExpected).Return(mReturn, nil)
 122         retVal, err := i.Get([]string{"key1", "key2", "key3"})
 123         assert.Nil(t, err)
 124         assert.Equal(t, mReturnExpected, retVal)
 125         m.AssertExpectations(t)
 126 }
 127
 128 func TestGetKeyReturnError(t *testing.T) {
 129         m, i := setup()
 130
 131         mgetExpected := []string{"{namespace},key"}
 132         mReturn := []interface{}{nil}
 133         mReturnExpected := make(map[string]interface{})
 134
 135         m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
 136         retVal, err := i.Get([]string{"key"})
 137         assert.NotNil(t, err)
 138         assert.Equal(t, mReturnExpected, retVal)
 139         m.AssertExpectations(t)
 140 }
 141
 142 func TestGetEmptyList(t *testing.T) {
 143         m, i := setup()
 144
 145         mgetExpected := []string{}
 146
 147         retval, err := i.Get([]string{})
 148         assert.Nil(t, err)
 149         assert.Len(t, retval, 0)
 150         m.AssertNotCalled(t, "MGet", mgetExpected)
 151 }
 152
 153 func TestWriteOneKey(t *testing.T) {
 154         m, i := setup()
 155
 156         msetExpected := []interface{}{"{namespace},key1", "data1"}
 157
 158         m.On("MSet", msetExpected).Return(nil)
 159         err := i.Set("key1", "data1")
 160         assert.Nil(t, err)
 161         m.AssertExpectations(t)
 162 }
 163
 164 func TestWriteSeveralKeysSlice(t *testing.T) {
 165         m, i := setup()
 166
 167         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 168
 169         m.On("MSet", msetExpected).Return(nil)
 170         err := i.Set([]interface{}{"key1", "data1", "key2", 22})
 171         assert.Nil(t, err)
 172         m.AssertExpectations(t)
 173
 174 }
 175
 176 func TestWriteSeveralKeysArray(t *testing.T) {
 177         m, i := setup()
 178
 179         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
 180
 181         m.On("MSet", msetExpected).Return(nil)
 182         err := i.Set([4]string{"key1", "data1", "key2", "data2"})
 183         assert.Nil(t, err)
 184         m.AssertExpectations(t)
 185 }
 186
 187 func TestWriteFail(t *testing.T) {
 188         m, i := setup()
 189
 190         msetExpected := []interface{}{"{namespace},key1", "data1"}
 191
 192         m.On("MSet", msetExpected).Return(errors.New("Some error"))
 193         err := i.Set("key1", "data1")
 194         assert.NotNil(t, err)
 195         m.AssertExpectations(t)
 196 }
 197
 198 func TestWriteEmptyList(t *testing.T) {
 199         m, i := setup()
 200
 201         msetExpected := []interface{}{}
 202         err := i.Set()
 203         assert.Nil(t, err)
 204         m.AssertNotCalled(t, "MSet", msetExpected)
 205 }
 206
 207 func TestRemoveSuccessfully(t *testing.T) {
 208         m, i := setup()
 209
 210         msetExpected := []string{"{namespace},key1", "{namespace},key2"}
 211         m.On("Del", msetExpected).Return(nil)
 212
 213         err := i.Remove([]string{"key1", "key2"})
 214         assert.Nil(t, err)
 215         m.AssertExpectations(t)
 216 }
 217
 218 func TestRemoveFail(t *testing.T) {
 219         m, i := setup()
 220
 221         msetExpected := []string{"{namespace},key"}
 222         m.On("Del", msetExpected).Return(errors.New("Some error"))
 223
 224         err := i.Remove([]string{"key"})
 225         assert.NotNil(t, err)
 226         m.AssertExpectations(t)
 227 }
 228
 229 func TestRemoveEmptyList(t *testing.T) {
 230         m, i := setup()
 231
 232         err := i.Remove([]string{})
 233         assert.Nil(t, err)
 234         m.AssertNotCalled(t, "Del", []string{})
 235 }
 236
 237 func TestGetAllSuccessfully(t *testing.T) {
 238         m, i := setup()
 239
 240         mKeysExpected := string("{namespace},*")
 241         mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
 242         expectedReturn := []string{"key1", "key2"}
 243         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 244         retVal, err := i.GetAll()
 245         assert.Nil(t, err)
 246         assert.Equal(t, expectedReturn, retVal)
 247         m.AssertExpectations(t)
 248 }
 249
 250 func TestGetAllFail(t *testing.T) {
 251         m, i := setup()
 252
 253         mKeysExpected := string("{namespace},*")
 254         mReturnExpected := []string{}
 255         m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
 256         retVal, err := i.GetAll()
 257         assert.NotNil(t, err)
 258         assert.Nil(t, retVal)
 259         assert.Equal(t, len(retVal), 0)
 260         m.AssertExpectations(t)
 261 }
 262
 263 func TestGetAllReturnEmpty(t *testing.T) {
 264         m, i := setup()
 265
 266         mKeysExpected := string("{namespace},*")
 267         var mReturnExpected []string = nil
 268         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 269         retVal, err := i.GetAll()
 270         assert.Nil(t, err)
 271         assert.Nil(t, retVal)
 272         assert.Equal(t, len(retVal), 0)
 273         m.AssertExpectations(t)
 274
 275 }
 276
 277 func TestRemoveAllSuccessfully(t *testing.T) {
 278         m, i := setup()
 279
 280         mKeysExpected := string("{namespace},*")
 281         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 282         mDelExpected := mKeysReturn
 283         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 284         m.On("Del", mDelExpected).Return(nil)
 285         err := i.RemoveAll()
 286         assert.Nil(t, err)
 287         m.AssertExpectations(t)
 288 }
 289
 290 func TestRemoveAllNoKeysFound(t *testing.T) {
 291         m, i := setup()
 292
 293         mKeysExpected := string("{namespace},*")
 294         var mKeysReturn []string = nil
 295         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 296         m.AssertNumberOfCalls(t, "Del", 0)
 297         err := i.RemoveAll()
 298         assert.Nil(t, err)
 299         m.AssertExpectations(t)
 300 }
 301
 302 func TestRemoveAllKeysReturnError(t *testing.T) {
 303         m, i := setup()
 304
 305         mKeysExpected := string("{namespace},*")
 306         var mKeysReturn []string = nil
 307         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
 308         m.AssertNumberOfCalls(t, "Del", 0)
 309         err := i.RemoveAll()
 310         assert.NotNil(t, err)
 311         m.AssertExpectations(t)
 312 }
 313
 314 func TestRemoveAllDelReturnError(t *testing.T) {
 315         m, i := setup()
 316
 317         mKeysExpected := string("{namespace},*")
 318         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 319         mDelExpected := mKeysReturn
 320         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 321         m.On("Del", mDelExpected).Return(errors.New("Some Error"))
 322         err := i.RemoveAll()
 323         assert.NotNil(t, err)
 324         m.AssertExpectations(t)
 325 }
 326
 327 func TestSetIfSuccessfullyOkStatus(t *testing.T) {
 328         m, i := setup()
 329
 330         mSetIEExpectedKey := string("{namespace},key1")
 331         mSetIEExpectedOldData := interface{}("olddata")
 332         mSetIEExpectedNewData := interface{}("newdata")
 333         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, nil)
 334         status, err := i.SetIf("key1", "olddata", "newdata")
 335         assert.Nil(t, err)
 336         assert.True(t, status)
 337         m.AssertExpectations(t)
 338 }
 339
 340 func TestSetIfSuccessfullyNOKStatus(t *testing.T) {
 341         m, i := setup()
 342
 343         mSetIEExpectedKey := string("{namespace},key1")
 344         mSetIEExpectedOldData := interface{}("olddata")
 345         mSetIEExpectedNewData := interface{}("newdata")
 346         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(false, nil)
 347         status, err := i.SetIf("key1", "olddata", "newdata")
 348         assert.Nil(t, err)
 349         assert.False(t, status)
 350         m.AssertExpectations(t)
 351 }
 352
 353 func TestSetIfFailure(t *testing.T) {
 354         m, i := setup()
 355
 356         mSetIEExpectedKey := string("{namespace},key1")
 357         mSetIEExpectedOldData := interface{}("olddata")
 358         mSetIEExpectedNewData := interface{}("newdata")
 359         m.On("SetIE", mSetIEExpectedKey, mSetIEExpectedOldData, mSetIEExpectedNewData).Return(true, errors.New("Some error"))
 360         status, err := i.SetIf("key1", "olddata", "newdata")
 361         assert.NotNil(t, err)
 362         assert.False(t, status)
 363         m.AssertExpectations(t)
 364 }
 365
 366 func TestSetIfNotExistsSuccessfullyOkStatus(t *testing.T) {
 367         m, i := setup()
 368
 369         mSetNXExpectedKey := string("{namespace},key1")
 370         mSetNXExpectedData := interface{}("data")
 371         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, nil)
 372         status, err := i.SetIfNotExists("key1", "data")
 373         assert.Nil(t, err)
 374         assert.True(t, status)
 375         m.AssertExpectations(t)
 376 }
 377
 378 func TestSetIfNotExistsSuccessfullyNOKStatus(t *testing.T) {
 379         m, i := setup()
 380
 381         mSetNXExpectedKey := string("{namespace},key1")
 382         mSetNXExpectedData := interface{}("data")
 383         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(false, nil)
 384         status, err := i.SetIfNotExists("key1", "data")
 385         assert.Nil(t, err)
 386         assert.False(t, status)
 387         m.AssertExpectations(t)
 388 }
 389
 390 func TestSetIfNotExistsFailure(t *testing.T) {
 391         m, i := setup()
 392
 393         mSetNXExpectedKey := string("{namespace},key1")
 394         mSetNXExpectedData := interface{}("data")
 395         m.On("SetNX", mSetNXExpectedKey, mSetNXExpectedData).Return(true, errors.New("Some error"))
 396         status, err := i.SetIfNotExists("key1", "data")
 397         assert.NotNil(t, err)
 398         assert.False(t, status)
 399         m.AssertExpectations(t)
 400 }
 401 func TestRemoveIfSuccessfullyOkStatus(t *testing.T) {
 402         m, i := setup()
 403
 404         mDelIEExpectedKey := string("{namespace},key1")
 405         mDelIEExpectedData := interface{}("data")
 406         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, nil)
 407         status, err := i.RemoveIf("key1", "data")
 408         assert.Nil(t, err)
 409         assert.True(t, status)
 410         m.AssertExpectations(t)
 411 }
 412
 413 func TestRemoveIfSuccessfullyNOKStatus(t *testing.T) {
 414         m, i := setup()
 415
 416         mDelIEExpectedKey := string("{namespace},key1")
 417         mDelIEExpectedData := interface{}("data")
 418         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(false, nil)
 419         status, err := i.RemoveIf("key1", "data")
 420         assert.Nil(t, err)
 421         assert.False(t, status)
 422         m.AssertExpectations(t)
 423 }
 424
 425 func TestRemoveIfFailure(t *testing.T) {
 426         m, i := setup()
 427
 428         mDelIEExpectedKey := string("{namespace},key1")
 429         mDelIEExpectedData := interface{}("data")
 430         m.On("DelIE", mDelIEExpectedKey, mDelIEExpectedData).Return(true, errors.New("Some error"))
 431         status, err := i.RemoveIf("key1", "data")
 432         assert.NotNil(t, err)
 433         assert.False(t, status)
 434         m.AssertExpectations(t)
 435 }