internal/sdlgo/sdl_test.go

   1 package sdlgo_test
   2
   3 import (
   4         "errors"
   5         "testing"
   6
   7         "github.com/stretchr/testify/assert"
   8         "github.com/stretchr/testify/mock"
   9         "gerrit.oran-osc.org/r/ric-plt/sdlgo"
  10 )
  11
  12 type mockDB struct {
  13         mock.Mock
  14 }
  15
  16 func (m *mockDB) MSet(pairs ...interface{}) error {
  17         a := m.Called(pairs)
  18         return a.Error(0)
  19 }
  20
  21 func (m *mockDB) MGet(keys []string) ([]interface{}, error) {
  22         a := m.Called(keys)
  23         return a.Get(0).([]interface{}), a.Error(1)
  24 }
  25
  26 func (m *mockDB) Close() error {
  27         a := m.Called()
  28         return a.Error(0)
  29 }
  30
  31 func (m *mockDB) Del(keys []string) error {
  32         a := m.Called(keys)
  33         return a.Error(0)
  34 }
  35
  36 func (m *mockDB) Keys(pattern string) ([]string, error) {
  37         a := m.Called(pattern)
  38         return a.Get(0).([]string), a.Error(1)
  39 }
  40
  41 func setup() (*mockDB, *sdlgo.SdlInstance) {
  42         m := new(mockDB)
  43         i := &sdlgo.SdlInstance{
  44                 NameSpace: "namespace",
  45                 NsPrefix:  "{namespace},",
  46                 Idatabase: m,
  47         }
  48         return m, i
  49 }
  50
  51 func TestGetOneKey(t *testing.T) {
  52         m, i := setup()
  53
  54         mgetExpected := []string{"{namespace},key"}
  55         mReturn := []interface{}{"somevalue"}
  56         mReturnExpected := make(map[string]interface{})
  57         mReturnExpected["key"] = "somevalue"
  58
  59         m.On("MGet", mgetExpected).Return(mReturn, nil)
  60         retVal, err := i.Get([]string{"key"})
  61         assert.Nil(t, err)
  62         assert.Equal(t, mReturnExpected, retVal)
  63         m.AssertExpectations(t)
  64 }
  65
  66 func TestGetSeveralKeys(t *testing.T) {
  67         m, i := setup()
  68
  69         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
  70         mReturn := []interface{}{"somevalue1", 2, "someothervalue"}
  71         mReturnExpected := make(map[string]interface{})
  72         mReturnExpected["key1"] = "somevalue1"
  73         mReturnExpected["key2"] = 2
  74         mReturnExpected["key3"] = "someothervalue"
  75
  76         m.On("MGet", mgetExpected).Return(mReturn, nil)
  77         retVal, err := i.Get([]string{"key1", "key2", "key3"})
  78         assert.Nil(t, err)
  79         assert.Equal(t, mReturnExpected, retVal)
  80         m.AssertExpectations(t)
  81 }
  82
  83 func TestGetSeveralKeysSomeFail(t *testing.T) {
  84         m, i := setup()
  85
  86         mgetExpected := []string{"{namespace},key1", "{namespace},key2", "{namespace},key3"}
  87         mReturn := []interface{}{"somevalue1", nil, "someothervalue"}
  88         mReturnExpected := make(map[string]interface{})
  89         mReturnExpected["key1"] = "somevalue1"
  90         mReturnExpected["key2"] = nil
  91         mReturnExpected["key3"] = "someothervalue"
  92
  93         m.On("MGet", mgetExpected).Return(mReturn, nil)
  94         retVal, err := i.Get([]string{"key1", "key2", "key3"})
  95         assert.Nil(t, err)
  96         assert.Equal(t, mReturnExpected, retVal)
  97         m.AssertExpectations(t)
  98 }
  99
 100 func TestGetKeyReturnError(t *testing.T) {
 101         m, i := setup()
 102
 103         mgetExpected := []string{"{namespace},key"}
 104         mReturn := []interface{}{nil}
 105         mReturnExpected := make(map[string]interface{})
 106
 107         m.On("MGet", mgetExpected).Return(mReturn, errors.New("Some error"))
 108         retVal, err := i.Get([]string{"key"})
 109         assert.NotNil(t, err)
 110         assert.Equal(t, mReturnExpected, retVal)
 111         m.AssertExpectations(t)
 112 }
 113
 114 func TestGetEmptyList(t *testing.T) {
 115         m, i := setup()
 116
 117         mgetExpected := []string{}
 118
 119         retval, err := i.Get([]string{})
 120         assert.Nil(t, err)
 121         assert.Len(t, retval, 0)
 122         m.AssertNotCalled(t, "MGet", mgetExpected)
 123 }
 124
 125 func TestWriteOneKey(t *testing.T) {
 126         m, i := setup()
 127
 128         msetExpected := []interface{}{"{namespace},key1", "data1"}
 129
 130         m.On("MSet", msetExpected).Return(nil)
 131         err := i.Set("key1", "data1")
 132         assert.Nil(t, err)
 133         m.AssertExpectations(t)
 134 }
 135
 136 func TestWriteSeveralKeysSlice(t *testing.T) {
 137         m, i := setup()
 138
 139         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", 22}
 140
 141         m.On("MSet", msetExpected).Return(nil)
 142         err := i.Set([]interface{}{"key1", "data1", "key2", 22})
 143         assert.Nil(t, err)
 144         m.AssertExpectations(t)
 145
 146 }
 147
 148 func TestWriteSeveralKeysArray(t *testing.T) {
 149         m, i := setup()
 150
 151         msetExpected := []interface{}{"{namespace},key1", "data1", "{namespace},key2", "data2"}
 152
 153         m.On("MSet", msetExpected).Return(nil)
 154         err := i.Set([4]string{"key1", "data1", "key2", "data2"})
 155         assert.Nil(t, err)
 156         m.AssertExpectations(t)
 157 }
 158
 159 func TestWriteFail(t *testing.T) {
 160         m, i := setup()
 161
 162         msetExpected := []interface{}{"{namespace},key1", "data1"}
 163
 164         m.On("MSet", msetExpected).Return(errors.New("Some error"))
 165         err := i.Set("key1", "data1")
 166         assert.NotNil(t, err)
 167         m.AssertExpectations(t)
 168 }
 169
 170 func TestWriteEmptyList(t *testing.T) {
 171         m, i := setup()
 172
 173         msetExpected := []interface{}{}
 174         err := i.Set()
 175         assert.Nil(t, err)
 176         m.AssertNotCalled(t, "MSet", msetExpected)
 177 }
 178
 179 func TestRemoveSuccessfully(t *testing.T) {
 180         m, i := setup()
 181
 182         msetExpected := []string{"{namespace},key1", "{namespace},key2"}
 183         m.On("Del", msetExpected).Return(nil)
 184
 185         err := i.Remove([]string{"key1", "key2"})
 186         assert.Nil(t, err)
 187         m.AssertExpectations(t)
 188 }
 189
 190 func TestRemoveFail(t *testing.T) {
 191         m, i := setup()
 192
 193         msetExpected := []string{"{namespace},key"}
 194         m.On("Del", msetExpected).Return(errors.New("Some error"))
 195
 196         err := i.Remove([]string{"key"})
 197         assert.NotNil(t, err)
 198         m.AssertExpectations(t)
 199 }
 200
 201 func TestRemoveEmptyList(t *testing.T) {
 202         m, i := setup()
 203
 204         err := i.Remove([]string{})
 205         assert.Nil(t, err)
 206         m.AssertNotCalled(t, "Del", []string{})
 207 }
 208
 209 func TestGetAllSuccessfully(t *testing.T) {
 210         m, i := setup()
 211
 212         mKeysExpected := string("{namespace},*")
 213         mReturnExpected := []string{"{namespace},key1", "{namespace},key2"}
 214         expectedReturn := []string{"key1", "key2"}
 215         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 216         retVal, err := i.GetAll()
 217         assert.Nil(t, err)
 218         assert.Equal(t, expectedReturn, retVal)
 219         m.AssertExpectations(t)
 220 }
 221
 222 func TestGetAllFail(t *testing.T) {
 223         m, i := setup()
 224
 225         mKeysExpected := string("{namespace},*")
 226         mReturnExpected := []string{}
 227         m.On("Keys", mKeysExpected).Return(mReturnExpected, errors.New("some error"))
 228         retVal, err := i.GetAll()
 229         assert.NotNil(t, err)
 230         assert.Nil(t, retVal)
 231         assert.Equal(t, len(retVal), 0)
 232         m.AssertExpectations(t)
 233 }
 234
 235 func TestGetAllReturnEmpty(t *testing.T) {
 236         m, i := setup()
 237
 238         mKeysExpected := string("{namespace},*")
 239         var mReturnExpected []string = nil
 240         m.On("Keys", mKeysExpected).Return(mReturnExpected, nil)
 241         retVal, err := i.GetAll()
 242         assert.Nil(t, err)
 243         assert.Nil(t, retVal)
 244         assert.Equal(t, len(retVal), 0)
 245         m.AssertExpectations(t)
 246
 247 }
 248
 249 func TestRemoveAllSuccessfully(t *testing.T) {
 250         m, i := setup()
 251
 252         mKeysExpected := string("{namespace},*")
 253         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 254         mDelExpected := mKeysReturn
 255         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 256         m.On("Del", mDelExpected).Return(nil)
 257         err := i.RemoveAll()
 258         assert.Nil(t, err)
 259         m.AssertExpectations(t)
 260 }
 261
 262 func TestRemoveAllNoKeysFound(t *testing.T) {
 263         m, i := setup()
 264
 265         mKeysExpected := string("{namespace},*")
 266         var mKeysReturn []string = nil
 267         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 268         m.AssertNumberOfCalls(t, "Del", 0)
 269         err := i.RemoveAll()
 270         assert.Nil(t, err)
 271         m.AssertExpectations(t)
 272 }
 273
 274 func TestRemoveAllKeysReturnError(t *testing.T) {
 275         m, i := setup()
 276
 277         mKeysExpected := string("{namespace},*")
 278         var mKeysReturn []string = nil
 279         m.On("Keys", mKeysExpected).Return(mKeysReturn, errors.New("Some error"))
 280         m.AssertNumberOfCalls(t, "Del", 0)
 281         err := i.RemoveAll()
 282         assert.NotNil(t, err)
 283         m.AssertExpectations(t)
 284 }
 285
 286 func TestRemoveAllDelReturnError(t *testing.T) {
 287         m, i := setup()
 288
 289         mKeysExpected := string("{namespace},*")
 290         mKeysReturn := []string{"{namespace},key1", "{namespace},key2"}
 291         mDelExpected := mKeysReturn
 292         m.On("Keys", mKeysExpected).Return(mKeysReturn, nil)
 293         m.On("Del", mDelExpected).Return(errors.New("Some Error"))
 294         err := i.RemoveAll()
 295         assert.NotNil(t, err)
 296         m.AssertExpectations(t)
 297 }