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)
receivedChannel2 = channel
}, "{prefix}", "---", "{prefix}channel2")
+ time.Sleep(1 * time.Second)
db.UnsubscribeChannelDB("{prefix}channel1")
ch <- &msg2
db.UnsubscribeChannelDB("{prefix}channel2")
ps.AssertExpectations(t)
}
+func TestSubscribeChannelReDBSubscribeAfterUnsubscribe(t *testing.T) {
+ ps, r, db := setup(true)
+ ch := make(chan *redis.Message)
+ msg := redis.Message{
+ Channel: "{prefix}channel",
+ Pattern: "pattern",
+ Payload: "event",
+ }
+ ps.On("Channel").Return(ch)
+ ps.On("Unsubscribe").Return(nil)
+ ps.On("Close").Return(nil)
+ count := 0
+ receivedChannel := ""
+
+ db.SubscribeChannelDB(func(channel string, payload ...string) {
+ count++
+ receivedChannel = channel
+ }, "{prefix}", "---", "{prefix}channel")
+ ch <- &msg
+ db.UnsubscribeChannelDB("{prefix}channel")
+ time.Sleep(1 * time.Second)
+
+ db.SubscribeChannelDB(func(channel string, payload ...string) {
+ count++
+ receivedChannel = channel
+ }, "{prefix}", "---", "{prefix}channel")
+ ch <- &msg
+ db.UnsubscribeChannelDB("{prefix}channel")
+
+ time.Sleep(1 * time.Second)
+ assert.Equal(t, 2, count)
+ assert.Equal(t, "channel", receivedChannel)
+ r.AssertExpectations(t)
+ ps.AssertExpectations(t)
+}
+
func TestPTTLSuccessfully(t *testing.T) {
_, r, db := setup(true)
expectedKey := "key"