mirror of
https://github.com/EchoVault/SugarDB.git
synced 2025-10-08 17:30:47 +08:00
815 lines
28 KiB
Go
815 lines
28 KiB
Go
package list
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"github.com/echovault/echovault/src/server"
|
|
"github.com/echovault/echovault/src/utils"
|
|
"github.com/tidwall/resp"
|
|
"testing"
|
|
)
|
|
|
|
func Test_HandleLLEN(t *testing.T) {
|
|
mockServer := server.NewServer(server.Opts{})
|
|
|
|
tests := []struct {
|
|
preset bool
|
|
key string
|
|
presetValue interface{}
|
|
command []string
|
|
expectedResponse interface{}
|
|
expectedValue []interface{}
|
|
expectedError error
|
|
}{
|
|
{ // If key exists and is a list, return the lists length
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LLEN", "key1"},
|
|
expectedResponse: 4,
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // If key does not exist, return 0
|
|
preset: false,
|
|
key: "key2",
|
|
presetValue: nil,
|
|
command: []string{"LLEN", "key2"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // Command too short
|
|
preset: false,
|
|
key: "key3",
|
|
presetValue: nil,
|
|
command: []string{"LLEN"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Command too long
|
|
preset: false,
|
|
key: "key4",
|
|
presetValue: nil,
|
|
command: []string{"LLEN", "key4", "key4"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Trying to get lengths on a non-list returns error
|
|
preset: true,
|
|
key: "key5",
|
|
presetValue: "Default value",
|
|
command: []string{"LLEN", "key5"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LLEN command on non-list item"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.preset {
|
|
if _, err := mockServer.CreateKeyAndLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
mockServer.SetValue(context.Background(), test.key, test.presetValue)
|
|
mockServer.KeyUnlock(test.key)
|
|
}
|
|
res, err := handleLLen(context.Background(), test.command, mockServer, nil)
|
|
if test.expectedError != nil {
|
|
if err.Error() != test.expectedError.Error() {
|
|
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
|
|
}
|
|
continue
|
|
}
|
|
rd := resp.NewReader(bytes.NewBuffer(res))
|
|
rv, _, err := rd.ReadValue()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rv.Integer() != test.expectedResponse {
|
|
t.Errorf("expected integer response \"%d\", got \"%d\"", test.expectedResponse, rv.Integer())
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_HandleLINDEX(t *testing.T) {
|
|
mockServer := server.NewServer(server.Opts{})
|
|
|
|
tests := []struct {
|
|
preset bool
|
|
key string
|
|
presetValue interface{}
|
|
command []string
|
|
expectedResponse interface{}
|
|
expectedValue []interface{}
|
|
expectedError error
|
|
}{
|
|
{ // Return last element within range
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LINDEX", "key1", "3"},
|
|
expectedResponse: "value4",
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // Return first element within range
|
|
preset: true,
|
|
key: "key2",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LINDEX", "key1", "0"},
|
|
expectedResponse: "value1",
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // Return middle element within range
|
|
preset: true,
|
|
key: "key3",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LINDEX", "key1", "1"},
|
|
expectedResponse: "value2",
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // If key does not exist, return error
|
|
preset: false,
|
|
key: "key4",
|
|
presetValue: nil,
|
|
command: []string{"LINDEX", "key4", "0"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LINDEX command on non-list item"),
|
|
},
|
|
{ // Command too short
|
|
preset: false,
|
|
key: "key3",
|
|
presetValue: nil,
|
|
command: []string{"LINDEX", "key3"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Command too long
|
|
preset: false,
|
|
key: "key4",
|
|
presetValue: nil,
|
|
command: []string{"LINDEX", "key4", "0", "20"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Trying to get element by index on a non-list returns error
|
|
preset: true,
|
|
key: "key5",
|
|
presetValue: "Default value",
|
|
command: []string{"LINDEX", "key5", "0"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LINDEX command on non-list item"),
|
|
},
|
|
{ // Trying to get index out of range index beyond last index
|
|
preset: true,
|
|
key: "key6",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LINDEX", "key6", "3"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("index must be within list range"),
|
|
},
|
|
{ // Trying to get index out of range with negative index
|
|
preset: true,
|
|
key: "key7",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LINDEX", "key7", "-1"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("index must be within list range"),
|
|
},
|
|
{ // Return error when index is not an integer
|
|
preset: false,
|
|
key: "key8",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LINDEX", "key8", "index"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("index must be an integer"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.preset {
|
|
if _, err := mockServer.CreateKeyAndLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
mockServer.SetValue(context.Background(), test.key, test.presetValue)
|
|
mockServer.KeyUnlock(test.key)
|
|
}
|
|
res, err := handleLIndex(context.Background(), test.command, mockServer, nil)
|
|
if test.expectedError != nil {
|
|
if err.Error() != test.expectedError.Error() {
|
|
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
|
|
}
|
|
continue
|
|
}
|
|
rd := resp.NewReader(bytes.NewBuffer(res))
|
|
rv, _, err := rd.ReadValue()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rv.String() != test.expectedResponse {
|
|
t.Errorf("expected response \"%s\", got \"%s\"", test.expectedResponse, rv.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_HandleLRANGE(t *testing.T) {
|
|
mockServer := server.NewServer(server.Opts{})
|
|
|
|
tests := []struct {
|
|
preset bool
|
|
key string
|
|
presetValue interface{}
|
|
command []string
|
|
expectedResponse []interface{}
|
|
expectedValue []interface{}
|
|
expectedError error
|
|
}{
|
|
{
|
|
// Return sub-list within range.
|
|
// Both start and end indices are positive.
|
|
// End index is greater than start index.
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8"},
|
|
command: []string{"LRANGE", "key1", "3", "6"},
|
|
expectedResponse: []interface{}{"value4", "value5", "value6", "value7"},
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // Return sub-list from start index to the end of the list when end index is -1
|
|
preset: true,
|
|
key: "key2",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8"},
|
|
command: []string{"LRANGE", "key2", "3", "-1"},
|
|
expectedResponse: []interface{}{"value4", "value5", "value6", "value7", "value8"},
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // Return the reversed sub-list when the end index is greater than -1 but less than start index
|
|
preset: true,
|
|
key: "key3",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8"},
|
|
command: []string{"LRANGE", "key3", "3", "0"},
|
|
expectedResponse: []interface{}{"value4", "value3", "value2", "value1"},
|
|
expectedValue: nil,
|
|
expectedError: nil,
|
|
},
|
|
{ // If key does not exist, return error
|
|
preset: false,
|
|
key: "key4",
|
|
presetValue: nil,
|
|
command: []string{"LRANGE", "key4", "0", "2"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LRANGE command on non-list item"),
|
|
},
|
|
{ // Command too short
|
|
preset: false,
|
|
key: "key5",
|
|
presetValue: nil,
|
|
command: []string{"LRANGE", "key5"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Command too long
|
|
preset: false,
|
|
key: "key6",
|
|
presetValue: nil,
|
|
command: []string{"LRANGE", "key6", "0", "element", "element"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Error when executing command on non-list command
|
|
preset: true,
|
|
key: "key5",
|
|
presetValue: "Default value",
|
|
command: []string{"LRANGE", "key5", "0", "3"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LRANGE command on non-list item"),
|
|
},
|
|
{ // Error when start index is less than 0
|
|
preset: true,
|
|
key: "key7",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LRANGE", "key7", "-1", "3"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start index must be within list boundary"),
|
|
},
|
|
{ // Error when start index is higher than the length of the list
|
|
preset: true,
|
|
key: "key8",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LRANGE", "key8", "10", "11"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start index must be within list boundary"),
|
|
},
|
|
{ // Return error when start index is not an integer
|
|
preset: false,
|
|
key: "key9",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LRANGE", "key9", "start", "7"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start and end indices must be integers"),
|
|
},
|
|
{ // Return error when end index is not an integer
|
|
preset: false,
|
|
key: "key10",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LRANGE", "key10", "0", "end"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start and end indices must be integers"),
|
|
},
|
|
{ // Error when start and end indices are equal
|
|
preset: true,
|
|
key: "key11",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LRANGE", "key11", "1", "1"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start and end indices cannot be equal"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.preset {
|
|
if _, err := mockServer.CreateKeyAndLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
mockServer.SetValue(context.Background(), test.key, test.presetValue)
|
|
mockServer.KeyUnlock(test.key)
|
|
}
|
|
res, err := handleLRange(context.Background(), test.command, mockServer, nil)
|
|
if test.expectedError != nil {
|
|
if err.Error() != test.expectedError.Error() {
|
|
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
|
|
}
|
|
continue
|
|
}
|
|
rd := resp.NewReader(bytes.NewBuffer(res))
|
|
rv, _, err := rd.ReadValue()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
responseArray := rv.Array()
|
|
if len(responseArray) != len(test.expectedResponse) {
|
|
t.Errorf("expected response of length \"%d\", got \"%d\"", len(test.expectedResponse), len(responseArray))
|
|
}
|
|
for i := 0; i < len(responseArray); i++ {
|
|
if responseArray[i].String() != test.expectedResponse[i] {
|
|
t.Errorf("expected value \"%s\" at index %d, got \"%s\"", test.expectedResponse[i], i, responseArray[i].String())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_HandleLSET(t *testing.T) {
|
|
mockServer := server.NewServer(server.Opts{})
|
|
|
|
tests := []struct {
|
|
preset bool
|
|
key string
|
|
presetValue interface{}
|
|
command []string
|
|
expectedResponse interface{}
|
|
expectedValue []interface{}
|
|
expectedError error
|
|
}{
|
|
{ // Return last element within range
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LSET", "key1", "3", "new-value"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"value1", "value2", "value3", "new-value"},
|
|
expectedError: nil,
|
|
},
|
|
{ // Return first element within range
|
|
preset: true,
|
|
key: "key2",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LSET", "key2", "0", "new-value"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"new-value", "value2", "value3", "value4"},
|
|
expectedError: nil,
|
|
},
|
|
{ // Return middle element within range
|
|
preset: true,
|
|
key: "key3",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LSET", "key3", "1", "new-value"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"value1", "new-value", "value3", "value4"},
|
|
expectedError: nil,
|
|
},
|
|
{ // If key does not exist, return error
|
|
preset: false,
|
|
key: "key4",
|
|
presetValue: nil,
|
|
command: []string{"LSET", "key4", "0", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LSET command on non-list item"),
|
|
},
|
|
{ // Command too short
|
|
preset: false,
|
|
key: "key5",
|
|
presetValue: nil,
|
|
command: []string{"LSET", "key5"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Command too long
|
|
preset: false,
|
|
key: "key6",
|
|
presetValue: nil,
|
|
command: []string{"LSET", "key6", "0", "element", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Trying to get element by index on a non-list returns error
|
|
preset: true,
|
|
key: "key5",
|
|
presetValue: "Default value",
|
|
command: []string{"LSET", "key5", "0", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LSET command on non-list item"),
|
|
},
|
|
{ // Trying to get index out of range index beyond last index
|
|
preset: true,
|
|
key: "key6",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LSET", "key6", "3", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("index must be within list range"),
|
|
},
|
|
{ // Trying to get index out of range with negative index
|
|
preset: true,
|
|
key: "key7",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LSET", "key7", "-1", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("index must be within list range"),
|
|
},
|
|
{ // Return error when index is not an integer
|
|
preset: false,
|
|
key: "key8",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LSET", "key8", "index", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("index must be an integer"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.preset {
|
|
if _, err := mockServer.CreateKeyAndLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
mockServer.SetValue(context.Background(), test.key, test.presetValue)
|
|
mockServer.KeyUnlock(test.key)
|
|
}
|
|
res, err := handleLSet(context.Background(), test.command, mockServer, nil)
|
|
if test.expectedError != nil {
|
|
if err.Error() != test.expectedError.Error() {
|
|
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
|
|
}
|
|
continue
|
|
}
|
|
rd := resp.NewReader(bytes.NewBuffer(res))
|
|
rv, _, err := rd.ReadValue()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rv.String() != test.expectedResponse {
|
|
t.Errorf("expected \"%s\" response, got \"%s\"", test.expectedResponse, rv.String())
|
|
}
|
|
if _, err = mockServer.KeyRLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
list, ok := mockServer.GetValue(test.key).([]interface{})
|
|
if !ok {
|
|
t.Error("expected value to be list, got another type")
|
|
}
|
|
if len(list) != len(test.expectedValue) {
|
|
t.Errorf("expected list length to be %d, got %d", len(test.expectedValue), len(list))
|
|
}
|
|
for i := 0; i < len(list); i++ {
|
|
if list[i] != test.expectedValue[i] {
|
|
t.Errorf("expected element at index %d to be %+v, got %+v", i, test.expectedValue[i], list[i])
|
|
}
|
|
}
|
|
mockServer.KeyRUnlock(test.key)
|
|
}
|
|
}
|
|
|
|
func Test_HandleLTRIM(t *testing.T) {
|
|
mockServer := server.NewServer(server.Opts{})
|
|
|
|
tests := []struct {
|
|
preset bool
|
|
key string
|
|
presetValue interface{}
|
|
command []string
|
|
expectedResponse interface{}
|
|
expectedValue []interface{}
|
|
expectedError error
|
|
}{
|
|
{
|
|
// Return trim within range.
|
|
// Both start and end indices are positive.
|
|
// End index is greater than start index.
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8"},
|
|
command: []string{"LTRIM", "key1", "3", "6"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"value4", "value5", "value6"},
|
|
expectedError: nil,
|
|
},
|
|
{ // Return element from start index to end index when end index is greater than length of the list
|
|
preset: true,
|
|
key: "key2",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8"},
|
|
command: []string{"LTRIM", "key2", "5", "-1"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"value6", "value7", "value8"},
|
|
expectedError: nil,
|
|
},
|
|
{ // Return error when end index is smaller than start index but greater than -1
|
|
preset: true,
|
|
key: "key3",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LTRIM", "key3", "3", "1"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("end index must be greater than start index or -1"),
|
|
},
|
|
{ // If key does not exist, return error
|
|
preset: false,
|
|
key: "key4",
|
|
presetValue: nil,
|
|
command: []string{"LTRIM", "key4", "0", "2"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LTRIM command on non-list item"),
|
|
},
|
|
{ // Command too short
|
|
preset: false,
|
|
key: "key5",
|
|
presetValue: nil,
|
|
command: []string{"LTRIM", "key5"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Command too long
|
|
preset: false,
|
|
key: "key6",
|
|
presetValue: nil,
|
|
command: []string{"LTRIM", "key6", "0", "element", "element"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Trying to get element by index on a non-list returns error
|
|
preset: true,
|
|
key: "key5",
|
|
presetValue: "Default value",
|
|
command: []string{"LTRIM", "key5", "0", "3"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LTRIM command on non-list item"),
|
|
},
|
|
{ // Error when start index is less than 0
|
|
preset: true,
|
|
key: "key7",
|
|
presetValue: []interface{}{"value1", "value2", "value3", "value4"},
|
|
command: []string{"LTRIM", "key7", "-1", "3"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start index must be within list boundary"),
|
|
},
|
|
{ // Error when start index is higher than the length of the list
|
|
preset: true,
|
|
key: "key8",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LTRIM", "key8", "10", "11"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start index must be within list boundary"),
|
|
},
|
|
{ // Return error when start index is not an integer
|
|
preset: false,
|
|
key: "key9",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LTRIM", "key9", "start", "7"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start and end indices must be integers"),
|
|
},
|
|
{ // Return error when end index is not an integer
|
|
preset: false,
|
|
key: "key10",
|
|
presetValue: []interface{}{"value1", "value2", "value3"},
|
|
command: []string{"LTRIM", "key10", "0", "end"},
|
|
expectedResponse: 0,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("start and end indices must be integers"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.preset {
|
|
if _, err := mockServer.CreateKeyAndLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
mockServer.SetValue(context.Background(), test.key, test.presetValue)
|
|
mockServer.KeyUnlock(test.key)
|
|
}
|
|
res, err := handleLTrim(context.Background(), test.command, mockServer, nil)
|
|
if test.expectedError != nil {
|
|
if err.Error() != test.expectedError.Error() {
|
|
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
|
|
}
|
|
continue
|
|
}
|
|
rd := resp.NewReader(bytes.NewBuffer(res))
|
|
rv, _, err := rd.ReadValue()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rv.String() != test.expectedResponse {
|
|
t.Errorf("expected \"%s\" response, got \"%s\"", test.expectedResponse, rv.String())
|
|
}
|
|
if _, err = mockServer.KeyRLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
list, ok := mockServer.GetValue(test.key).([]interface{})
|
|
if !ok {
|
|
t.Error("expected value to be list, got another type")
|
|
}
|
|
if len(list) != len(test.expectedValue) {
|
|
t.Errorf("expected list length to be %d, got %d", len(test.expectedValue), len(list))
|
|
}
|
|
for i := 0; i < len(list); i++ {
|
|
if list[i] != test.expectedValue[i] {
|
|
t.Errorf("expected element at index %d to be %+v, got %+v", i, test.expectedValue[i], list[i])
|
|
}
|
|
}
|
|
mockServer.KeyRUnlock(test.key)
|
|
}
|
|
}
|
|
|
|
func Test_HandleLREM(t *testing.T) {
|
|
mockServer := server.NewServer(server.Opts{})
|
|
|
|
tests := []struct {
|
|
preset bool
|
|
key string
|
|
presetValue interface{}
|
|
command []string
|
|
expectedResponse interface{}
|
|
expectedValue []interface{}
|
|
expectedError error
|
|
}{
|
|
{ // Remove the first 3 elements that appear in the list
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"1", "2", "4", "4", "5", "6", "7", "4", "8", "4", "9", "10", "5", "4"},
|
|
command: []string{"LREM", "key1", "3", "4"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"1", "2", "5", "6", "7", "8", "4", "9", "10", "5", "4"},
|
|
expectedError: nil,
|
|
},
|
|
{ // Remove the last 3 elements that appear in the list
|
|
preset: true,
|
|
key: "key1",
|
|
presetValue: []interface{}{"1", "2", "4", "4", "5", "6", "7", "4", "8", "4", "9", "10", "5", "4"},
|
|
command: []string{"LREM", "key1", "-3", "4"},
|
|
expectedResponse: "OK",
|
|
expectedValue: []interface{}{"1", "2", "4", "4", "5", "6", "7", "8", "9", "10", "5"},
|
|
expectedError: nil,
|
|
},
|
|
{ // Command too short
|
|
preset: false,
|
|
key: "key5",
|
|
presetValue: nil,
|
|
command: []string{"LREM", "key5"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Command too long
|
|
preset: false,
|
|
key: "key6",
|
|
presetValue: nil,
|
|
command: []string{"LREM", "key6", "0", "element", "element"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
|
|
},
|
|
{ // Throw error when count is not an integer
|
|
preset: false,
|
|
key: "key7",
|
|
presetValue: nil,
|
|
command: []string{"LREM", "key7", "count", "value1"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("count must be an integer"),
|
|
},
|
|
{ // Throw error on non-list item
|
|
preset: true,
|
|
key: "key8",
|
|
presetValue: "Default value",
|
|
command: []string{"LREM", "key8", "0", "value1"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LREM command on non-list item"),
|
|
},
|
|
{ // Throw error on non-existent item
|
|
preset: false,
|
|
key: "key9",
|
|
presetValue: "Default value",
|
|
command: []string{"LREM", "key9", "0", "value1"},
|
|
expectedResponse: nil,
|
|
expectedValue: nil,
|
|
expectedError: errors.New("LREM command on non-list item"),
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.preset {
|
|
if _, err := mockServer.CreateKeyAndLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
mockServer.SetValue(context.Background(), test.key, test.presetValue)
|
|
mockServer.KeyUnlock(test.key)
|
|
}
|
|
res, err := handleLRem(context.Background(), test.command, mockServer, nil)
|
|
if test.expectedError != nil {
|
|
if err.Error() != test.expectedError.Error() {
|
|
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
|
|
}
|
|
continue
|
|
}
|
|
rd := resp.NewReader(bytes.NewBuffer(res))
|
|
rv, _, err := rd.ReadValue()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rv.String() != test.expectedResponse {
|
|
t.Errorf("expected \"%s\" response, got \"%s\"", test.expectedResponse, rv.String())
|
|
}
|
|
if _, err = mockServer.KeyRLock(context.Background(), test.key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
list, ok := mockServer.GetValue(test.key).([]interface{})
|
|
if !ok {
|
|
t.Error("expected value to be list, got another type")
|
|
}
|
|
if len(list) != len(test.expectedValue) {
|
|
t.Errorf("expected list length to be %d, got %d", len(test.expectedValue), len(list))
|
|
}
|
|
for i := 0; i < len(list); i++ {
|
|
if list[i] != test.expectedValue[i] {
|
|
t.Errorf("expected element at index %d to be %+v, got %+v", i, test.expectedValue[i], list[i])
|
|
}
|
|
}
|
|
mockServer.KeyRUnlock(test.key)
|
|
}
|
|
}
|
|
|
|
func Test_HandleLMOVE(t *testing.T) {}
|
|
|
|
func Test_HandleLPUSH(t *testing.T) {}
|
|
|
|
func Test_HandleRPUSH(t *testing.T) {}
|
|
|
|
func Test_HandlePop(t *testing.T) {}
|