Version history
---------------
+[0.5.5] - 2021-03-09
+
+* Take DBAAS multi-channel publishing Redis modules into use.
+* Fix potential type conversion crash in RemoveIf() and
+ RemoveIfAndPublish() APIs.
+
[0.5.4] - 2020-10-07
* Fix Go routine race condition when new DB notifications are subscribed.
if err != nil {
return false, err
}
- if result.(int) == int(1) {
- return true, nil
+ if n, ok := result.(int64); ok {
+ if n == 1 {
+ return true, nil
+ }
+ } else if n, ok := result.(int); ok {
+ if n == 1 {
+ return true, nil
+ }
}
return false, nil
}
return checkResultAndError(db.client.Do("SETIE", key, newData, oldData).Result())
}
-func (db *DB) SetIEPub(channel, message, key string, oldData, newData interface{}) (bool, error) {
+func (db *DB) SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
if !db.redisModules {
- return false, errors.New("Redis deployment not supporting command SETIEPUB")
+ return false, errors.New("Redis deployment not supporting command SETIEMPUB")
+ }
+ capacity := 4 + len(channelsAndEvents)
+ command := make([]interface{}, 0, capacity)
+ command = append(command, "SETIEMPUB")
+ command = append(command, key)
+ command = append(command, newData)
+ command = append(command, oldData)
+ for _, ce := range channelsAndEvents {
+ command = append(command, ce)
}
- return checkResultAndError(db.client.Do("SETIEPUB", key, newData, oldData, channel, message).Result())
+ return checkResultAndError(db.client.Do(command...).Result())
}
-func (db *DB) SetNXPub(channel, message, key string, data interface{}) (bool, error) {
+func (db *DB) SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
if !db.redisModules {
- return false, errors.New("Redis deployment not supporting command SETNXPUB")
+ return false, errors.New("Redis deployment not supporting command SETNXMPUB")
}
- return checkResultAndError(db.client.Do("SETNXPUB", key, data, channel, message).Result())
+ capacity := 3 + len(channelsAndEvents)
+ command := make([]interface{}, 0, capacity)
+ command = append(command, "SETNXMPUB")
+ command = append(command, key)
+ command = append(command, data)
+ for _, ce := range channelsAndEvents {
+ command = append(command, ce)
+ }
+ return checkResultAndError(db.client.Do(command...).Result())
}
func (db *DB) SetNX(key string, data interface{}, expiration time.Duration) (bool, error) {
return db.client.SetNX(key, data, expiration).Result()
}
-func (db *DB) DelIEPub(channel, message, key string, data interface{}) (bool, error) {
+func (db *DB) DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
if !db.redisModules {
- return false, errors.New("Redis deployment not supporting command")
+ return false, errors.New("Redis deployment not supporting command DELIEMPUB")
+ }
+ capacity := 3 + len(channelsAndEvents)
+ command := make([]interface{}, 0, capacity)
+ command = append(command, "DELIEMPUB")
+ command = append(command, key)
+ command = append(command, data)
+ for _, ce := range channelsAndEvents {
+ command = append(command, ce)
}
- return checkIntResultAndError(db.client.Do("DELIEPUB", key, data, channel, message).Result())
+ return checkIntResultAndError(db.client.Do(command...).Result())
}
func (db *DB) DelIE(key string, data interface{}) (bool, error) {
func TestSetIEPubKeyExists(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+ expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
- result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+ result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
assert.True(t, result)
assert.Nil(t, err)
r.AssertExpectations(t)
func TestSetIEPubKeyDoesntExists(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+ expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
- result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+ result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
assert.False(t, result)
assert.Nil(t, err)
r.AssertExpectations(t)
func TestSetIEPubFailure(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+ expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
- result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+ result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
assert.False(t, result)
assert.NotNil(t, err)
r.AssertExpectations(t)
func TestSetIEPubCommandMissing(t *testing.T) {
_, r, db := setup(false)
- expectedMessage := []interface{}{"SETIEPUB", "key", "newdata", "olddata", "channel", "message"}
+ expectedMessage := []interface{}{"SETIEMPUB", "key", "newdata", "olddata", "channel", "message"}
r.AssertNotCalled(t, "Do", expectedMessage)
- result, err := db.SetIEPub("channel", "message", "key", "olddata", "newdata")
+ result, err := db.SetIEPub([]string{"channel", "message"}, "key", "olddata", "newdata")
assert.False(t, result)
assert.NotNil(t, err)
r.AssertExpectations(t)
func TestSetNXPubKeyDoesntExist(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+ expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult("OK", nil))
- result, err := db.SetNXPub("channel", "message", "key", "data")
+ result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
assert.True(t, result)
assert.Nil(t, err)
r.AssertExpectations(t)
func TestSetNXPubKeyExists(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+ expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, nil))
- result, err := db.SetNXPub("channel", "message", "key", "data")
+ result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
assert.False(t, result)
assert.Nil(t, err)
r.AssertExpectations(t)
func TestSetNXPubFailure(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+ expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult(nil, errors.New("Some error")))
- result, err := db.SetNXPub("channel", "message", "key", "data")
+ result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
assert.False(t, result)
assert.NotNil(t, err)
r.AssertExpectations(t)
func TestSetNXPubCommandMissing(t *testing.T) {
_, r, db := setup(false)
- expectedMessage := []interface{}{"SETNXPUB", "key", "data", "channel", "message"}
+ expectedMessage := []interface{}{"SETNXMPUB", "key", "data", "channel", "message"}
r.AssertNotCalled(t, "Do", expectedMessage)
- result, err := db.SetNXPub("channel", "message", "key", "data")
+ result, err := db.SetNXPub([]string{"channel", "message"}, "key", "data")
assert.False(t, result)
assert.NotNil(t, err)
r.AssertExpectations(t)
func TestDelIEPubKeyDoesntExist(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
- r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
- result, err := db.DelIEPub("channel", "message", "key", "data")
+ expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
+ r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
+ result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
assert.False(t, result)
assert.Nil(t, err)
r.AssertExpectations(t)
func TestDelIEPubKeyExists(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
+ expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
+ r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
+ result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
+ assert.True(t, result)
+ assert.Nil(t, err)
+ r.AssertExpectations(t)
+}
+
+func TestDelIEPubKeyExistsIntTypeRedisValue(t *testing.T) {
+ _, r, db := setup(true)
+ expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
- result, err := db.DelIEPub("channel", "message", "key", "data")
+ result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
assert.True(t, result)
assert.Nil(t, err)
r.AssertExpectations(t)
func TestDelIEPubFailure(t *testing.T) {
_, r, db := setup(true)
- expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
- r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
- result, err := db.DelIEPub("channel", "message", "key", "data")
+ expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
+ r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
+ result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
assert.False(t, result)
assert.NotNil(t, err)
r.AssertExpectations(t)
func TestDelIEPubCommandMissing(t *testing.T) {
_, r, db := setup(false)
- expectedMessage := []interface{}{"DELIEPUB", "key", "data", "channel", "message"}
+ expectedMessage := []interface{}{"DELIEMPUB", "key", "data", "channel", "message"}
r.AssertNotCalled(t, "Do", expectedMessage)
- result, err := db.DelIEPub("channel", "message", "key", "data")
+ result, err := db.DelIEPub([]string{"channel", "message"}, "key", "data")
assert.False(t, result)
assert.NotNil(t, err)
r.AssertExpectations(t)
func TestDelIEKeyDoesntExist(t *testing.T) {
_, r, db := setup(true)
expectedMessage := []interface{}{"DELIE", "key", "data"}
- r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, nil))
+ r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), nil))
result, err := db.DelIE("key", "data")
assert.False(t, result)
assert.Nil(t, err)
}
func TestDelIEKeyExists(t *testing.T) {
+ _, r, db := setup(true)
+ expectedMessage := []interface{}{"DELIE", "key", "data"}
+ r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(1), nil))
+ result, err := db.DelIE("key", "data")
+ assert.True(t, result)
+ assert.Nil(t, err)
+ r.AssertExpectations(t)
+}
+
+func TestDelIEKeyExistsIntTypeRedisValue(t *testing.T) {
_, r, db := setup(true)
expectedMessage := []interface{}{"DELIE", "key", "data"}
r.On("Do", expectedMessage).Return(redis.NewCmdResult(1, nil))
func TestDelIEFailure(t *testing.T) {
_, r, db := setup(true)
expectedMessage := []interface{}{"DELIE", "key", "data"}
- r.On("Do", expectedMessage).Return(redis.NewCmdResult(0, errors.New("Some error")))
+ r.On("Do", expectedMessage).Return(redis.NewCmdResult(int64(0), errors.New("Some error")))
result, err := db.DelIE("key", "data")
assert.False(t, result)
assert.NotNil(t, err)
return false, err
}
channelsAndEventsPrepared := s.prepareChannelsAndEvents(channelsAndEvents)
- return s.SetIEPub(channelsAndEventsPrepared[0], channelsAndEventsPrepared[1], s.nsPrefix+key, oldData, newData)
+ return s.SetIEPub(channelsAndEventsPrepared, s.nsPrefix+key, oldData, newData)
}
//SetIf atomically replaces existing data with newData in SDL if data matches the oldData.
return false, err
}
channelsAndEventsPrepared := s.prepareChannelsAndEvents(channelsAndEvents)
- return s.SetNXPub(channelsAndEventsPrepared[0], channelsAndEventsPrepared[1], s.nsPrefix+key, data)
+ return s.SetNXPub(channelsAndEventsPrepared, s.nsPrefix+key, data)
}
//SetIfNotExists conditionally sets the value of a key. If key already exists in SDL,
return false, err
}
channelsAndEventsPrepared := s.prepareChannelsAndEvents(channelsAndEvents)
- return s.DelIEPub(channelsAndEventsPrepared[0], channelsAndEventsPrepared[1], s.nsPrefix+key, data)
+ return s.DelIEPub(channelsAndEventsPrepared, s.nsPrefix+key, data)
}
//RemoveIf removes data from SDL conditionally. If existing data matches given data,
DelMPub(channelsAndEvents []string, keys []string) error
Keys(key string) ([]string, error)
SetIE(key string, oldData, newData interface{}) (bool, error)
- SetIEPub(channel, message, key string, oldData, newData interface{}) (bool, error)
+ SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error)
SetNX(key string, data interface{}, expiration time.Duration) (bool, error)
- SetNXPub(channel, message, key string, data interface{}) (bool, error)
+ SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error)
DelIE(key string, data interface{}) (bool, error)
- DelIEPub(channel, message, key string, data interface{}) (bool, error)
+ DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error)
SAdd(key string, data ...interface{}) error
SRem(key string, data ...interface{}) error
SMembers(key string) ([]string, error)
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) SetIEPub(channel, message, key string, oldData, newData interface{}) (bool, error) {
- a := m.Called(channel, message, key, oldData, newData)
+func (m *mockDB) SetIEPub(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, oldData, newData)
return a.Bool(0), a.Error(1)
}
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) SetNXPub(channel, message, key string, data interface{}) (bool, error) {
- a := m.Called(channel, message, key, data)
+func (m *mockDB) SetNXPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, data)
return a.Bool(0), a.Error(1)
}
return a.Bool(0), a.Error(1)
}
-func (m *mockDB) DelIEPub(channel, message, key string, data interface{}) (bool, error) {
- a := m.Called(channel, message, key, data)
+func (m *mockDB) DelIEPub(channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, data)
return a.Bool(0), a.Error(1)
}
func TestSetIfAndPublishSuccessfully(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedOldData := interface{}("olddata")
expectedNewData := interface{}("newdata")
- m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
+ m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(true, nil)
status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
assert.Nil(t, err)
assert.True(t, status)
func TestSetIfAndPublishIncorrectChannelAndEvent(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedOldData := interface{}("olddata")
expectedNewData := interface{}("newdata")
- m.AssertNotCalled(t, "SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData)
+ m.AssertNotCalled(t, "SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData)
m.AssertNotCalled(t, "SetIE", expectedKey, expectedOldData, expectedNewData)
status, err := i.SetIfAndPublish([]string{"channel", "event1", "channel"}, "key", "olddata", "newdata")
assert.NotNil(t, err)
func TestSetIfAndPublishNOKStatus(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedOldData := interface{}("olddata")
expectedNewData := interface{}("newdata")
- m.On("SetIEPub", expectedChannel, expectedEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
+ m.On("SetIEPub", expectedChannelAndEvent, expectedKey, expectedOldData, expectedNewData).Return(false, nil)
status, err := i.SetIfAndPublish([]string{"channel", "event"}, "key", "olddata", "newdata")
assert.Nil(t, err)
assert.False(t, status)
func TestSetIfNotExistsAndPublishSuccessfully(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
func TestSetIfNotExistsAndPublishSeveralEvents(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(true, nil)
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(true, nil)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
func TestSetIfNotExistsAndPublishFail(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, nil)
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, nil)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
assert.Nil(t, err)
assert.False(t, status)
func TestSetIfNotExistsAndPublishIncorrectChannels(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.AssertNotCalled(t, "SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData)
+ m.AssertNotCalled(t, "SetNXPub", expectedChannelAndEvent, expectedKey, expectedData)
m.AssertNotCalled(t, "SetNX", expectedKey, expectedData, 0)
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event", "channel2"}, "key", "data")
assert.NotNil(t, err)
func TestSetIfNotExistsAndPublishError(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedData := interface{}("data")
- m.On("SetNXPub", expectedChannel, expectedEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
+ m.On("SetNXPub", expectedChannelAndEvent, expectedKey, expectedData).Return(false, errors.New("Some error"))
status, err := i.SetIfNotExistsAndPublish([]string{"channel", "event"}, "key", "data")
assert.NotNil(t, err)
assert.False(t, status)
func TestRemoveIfAndPublishSuccessfully(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(true, nil)
+ m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(true, nil)
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.Nil(t, err)
assert.True(t, status)
func TestRemoveIfAndPublishNok(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, nil)
+ m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, nil)
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.Nil(t, err)
assert.False(t, status)
func TestRemoveIfAndPublishError(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event1___event2"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event1___event2"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.On("DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
+ m.On("DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue).Return(false, errors.New("Some error"))
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel", "event2"}, "key", "data")
assert.NotNil(t, err)
assert.False(t, status)
func TestRemoveIfAndPublishIncorrectChannel(t *testing.T) {
m, i := setup()
- expectedChannel := "{namespace},channel"
- expectedEvent := "event"
+ expectedChannelAndEvent := []string{"{namespace},channel", "event"}
expectedKey := "{namespace},key"
expectedValue := interface{}("data")
- m.AssertNotCalled(t, "DelIEPub", expectedChannel, expectedEvent, expectedKey, expectedValue)
+ m.AssertNotCalled(t, "DelIEPub", expectedChannelAndEvent, expectedKey, expectedValue)
m.AssertNotCalled(t, "DelIE", expectedKey, expectedValue)
status, err := i.RemoveIfAndPublish([]string{"channel", "event1", "channel"}, "key", "data")
assert.NotNil(t, err)