pkg/SugarDB
1
0
Fork 0
mirror of https://github.com/EchoVault/SugarDB.git synced 2025-10-06 16:36:54 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
3e9f921cff750321a5f46b064a7c96a498403a9e
SugarDB/src/modules/sorted_set/commands_test.go
Kelvin Clement Mwinuka 3e9f921cff Made unit test for ZREMRANGEBYRANK command handler
2024-02-22 05:59:46 +08:00

3913 lines
137 KiB
Go
Raw Blame History

package sorted_set
import (
"bytes"
"context"
"errors"
"github.com/echovault/echovault/src/server"
"github.com/echovault/echovault/src/utils"
"github.com/tidwall/resp"
"math"
"slices"
"strconv"
"testing"
)
func Test_HandleZADD(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValue *SortedSet
key string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Create new sorted set and return the cardinality of the new sorted set.
preset: false,
presetValue: nil,
key: "key1",
command: []string{"ZADD", "key1", "5.5", "member1", "67.77", "member2", "10", "member3", "-inf", "member4", "+inf", "member5"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
{value: "member4", score: Score(math.Inf(-1))},
{value: "member5", score: Score(math.Inf(1))},
}),
expectedResponse: 5,
expectedError: nil,
},
{ // 2. Only add the elements that do not currently exist in the sorted set when NX flag is provided
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key2",
command: []string{"ZADD", "key2", "NX", "5.5", "member1", "67.77", "member4", "10", "member5"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
{value: "member4", score: Score(67.77)},
{value: "member5", score: Score(10)},
}),
expectedResponse: 2,
expectedError: nil,
},
{ // 3. Do not add any elements when providing existing members with NX flag
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key3",
command: []string{"ZADD", "key3", "NX", "5.5", "member1", "67.77", "member2", "10", "member3"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
expectedResponse: 0,
expectedError: nil,
},
{ // 4. Successfully add elements to an existing set when XX flag is provided with existing elements
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key4",
command: []string{"ZADD", "key4", "XX", "CH", "55", "member1", "1005", "member2", "15", "member3", "99.75", "member4"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(55)},
{value: "member2", score: Score(1005)},
{value: "member3", score: Score(15)},
}),
expectedResponse: 3,
expectedError: nil,
},
{ // 5. Fail to add element when providing XX flag with elements that do not exist in the sorted set.
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key5",
command: []string{"ZADD", "key5", "XX", "5.5", "member4", "100.5", "member5", "15", "member6"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
expectedResponse: 0,
expectedError: nil,
},
{ // 6. Only update the elements where provided score is greater than current score if GT flag
// Return only the new elements added by default
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key6",
command: []string{"ZADD", "key6", "XX", "CH", "GT", "7.5", "member1", "100.5", "member4", "15", "member5"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(7.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
expectedResponse: 1,
expectedError: nil,
},
{ // 7. Only update the elements where provided score is less than current score if LT flag is provided
// Return only the new elements added by default.
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key7",
command: []string{"ZADD", "key7", "XX", "LT", "3.5", "member1", "100.5", "member4", "15", "member5"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(3.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
expectedResponse: 0,
expectedError: nil,
},
{ // 8. Return all the elements that were updated AND added when CH flag is provided
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key8",
command: []string{"ZADD", "key8", "XX", "LT", "CH", "3.5", "member1", "100.5", "member4", "15", "member5"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(3.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
expectedResponse: 1,
expectedError: nil,
},
{ // 9. Increment the member by score
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key9",
command: []string{"ZADD", "key9", "INCR", "5.5", "member3"},
expectedValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(15.5)},
}),
expectedResponse: 0,
expectedError: nil,
},
{ // 10. Fail when GT/LT flag is provided alongside NX flag
preset: false,
presetValue: nil,
key: "key10",
command: []string{"ZADD", "key10", "NX", "LT", "CH", "3.5", "member1", "100.5", "member4", "15", "member5"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("GT/LT flags not allowed if NX flag is provided"),
},
{ // 11. Command is too short
preset: false,
presetValue: nil,
key: "key11",
command: []string{"ZADD", "key11"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 12. Throw error when score/member entries are do not match
preset: false,
presetValue: nil,
key: "key11",
command: []string{"ZADD", "key12", "10.5", "member1", "12.5"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("score/member pairs must be float/string"),
},
{ // 13. Throw error when INCR flag is passed with more than one score/member pair
preset: false,
presetValue: nil,
key: "key13",
command: []string{"ZADD", "key13", "INCR", "10.5", "member1", "12.5", "member2"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("cannot pass more than one score/member pair when INCR flag is provided"),
},
}
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 := handleZADD(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewReader(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d at key \"%s\", got %d", test.expectedResponse, test.key, rv.Integer())
}
// Fetch the sorted set from the server and check it against the expected result
if _, err = mockServer.KeyRLock(context.Background(), test.key); err != nil {
t.Error(err)
}
sortedSet, ok := mockServer.GetValue(test.key).(*SortedSet)
if !ok {
t.Errorf("expected the value at key \"%s\" to be a sorted set, got another type", test.key)
}
if test.expectedValue == nil {
continue
}
if !sortedSet.Equals(test.expectedValue) {
t.Errorf("expected sorted set %+v, got %+v", test.expectedValue, sortedSet)
}
mockServer.KeyRUnlock(test.key)
}
}
func Test_HandleZCARD(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValue interface{}
key string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Get cardinality of valid sorted set.
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
}),
key: "key1",
command: []string{"ZCARD", "key1"},
expectedValue: nil,
expectedResponse: 3,
expectedError: nil,
},
{ // 2. Return 0 when trying to get cardinality from non-existent key
preset: false,
presetValue: nil,
key: "key2",
command: []string{"ZCARD", "key2"},
expectedValue: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 3. Command is too short
preset: false,
presetValue: nil,
key: "key3",
command: []string{"ZCARD"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 4. Command too long
preset: false,
presetValue: nil,
key: "key4",
command: []string{"ZCARD", "key4", "key5"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 5. Return error when not a sorted set
preset: true,
presetValue: "Default value",
key: "key5",
command: []string{"ZCARD", "key5"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("value at key5 is not a sorted set"),
},
}
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 := handleZCARD(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewReader(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d at key \"%s\", got %d", test.expectedResponse, test.key, rv.Integer())
}
}
}
func Test_HandleZCOUNT(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValue interface{}
key string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Get entire count using infinity boundaries
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
{value: "member4", score: Score(1083.13)},
{value: "member5", score: Score(11)},
{value: "member6", score: Score(math.Inf(-1))},
{value: "member7", score: Score(math.Inf(1))},
}),
key: "key1",
command: []string{"ZCOUNT", "key1", "-inf", "+inf"},
expectedValue: nil,
expectedResponse: 7,
expectedError: nil,
},
{ // 2. Get count of sub-set from -inf to limit
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
{value: "member4", score: Score(1083.13)},
{value: "member5", score: Score(11)},
{value: "member6", score: Score(math.Inf(-1))},
{value: "member7", score: Score(math.Inf(1))},
}),
key: "key2",
command: []string{"ZCOUNT", "key2", "-inf", "90"},
expectedValue: nil,
expectedResponse: 5,
expectedError: nil,
},
{ // 3. Get count of sub-set from bottom boundary to +inf limit
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "member1", score: Score(5.5)},
{value: "member2", score: Score(67.77)},
{value: "member3", score: Score(10)},
{value: "member4", score: Score(1083.13)},
{value: "member5", score: Score(11)},
{value: "member6", score: Score(math.Inf(-1))},
{value: "member7", score: Score(math.Inf(1))},
}),
key: "key3",
command: []string{"ZCOUNT", "key3", "1000", "+inf"},
expectedValue: nil,
expectedResponse: 2,
expectedError: nil,
},
{ // 4. Return error when bottom boundary is not a valid double/float
preset: false,
presetValue: nil,
key: "key4",
command: []string{"ZCOUNT", "key4", "min", "10"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("min constraint must be a double"),
},
{ // 5. Return error when top boundary is not a valid double/float
preset: false,
presetValue: nil,
key: "key5",
command: []string{"ZCOUNT", "key5", "-10", "max"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("max constraint must be a double"),
},
{ // 6. Command is too short
preset: false,
presetValue: nil,
key: "key6",
command: []string{"ZCOUNT"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 7. Command too long
preset: false,
presetValue: nil,
key: "key7",
command: []string{"ZCOUNT", "key4", "min", "max", "count"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 8. Throw error when value at the key is not a sorted set
preset: true,
presetValue: "Default value",
key: "key8",
command: []string{"ZCOUNT", "key8", "1", "10"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("value at key8 is not a sorted set"),
},
}
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 := handleZCOUNT(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewReader(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d at key \"%s\", got %d", test.expectedResponse, test.key, rv.Integer())
}
}
}
func Test_HandleZLEXCOUNT(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValue interface{}
key string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Get entire count using infinity boundaries
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "e", score: Score(1)},
{value: "f", score: Score(1)},
{value: "g", score: Score(1)},
{value: "h", score: Score(1)},
{value: "i", score: Score(1)},
{value: "j", score: Score(1)},
{value: "k", score: Score(1)},
}),
key: "key1",
command: []string{"ZLEXCOUNT", "key1", "f", "j"},
expectedValue: nil,
expectedResponse: 5,
expectedError: nil,
},
{ // 2. Return 0 when the members do not have the same score
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "a", score: Score(5.5)},
{value: "b", score: Score(67.77)},
{value: "c", score: Score(10)},
{value: "d", score: Score(1083.13)},
{value: "e", score: Score(11)},
{value: "f", score: Score(math.Inf(-1))},
{value: "g", score: Score(math.Inf(1))},
}),
key: "key2",
command: []string{"ZLEXCOUNT", "key2", "a", "b"},
expectedValue: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 3. Return 0 when the key does not exist
preset: false,
presetValue: nil,
key: "key3",
command: []string{"ZLEXCOUNT", "key3", "a", "z"},
expectedValue: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 4. Return error when the value at the key is not a sorted set
preset: true,
presetValue: "Default value",
key: "key4",
command: []string{"ZLEXCOUNT", "key4", "a", "z"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("value at key4 is not a sorted set"),
},
{ // 5. Command is too short
preset: false,
presetValue: nil,
key: "key5",
command: []string{"ZLEXCOUNT"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 6. Command too long
preset: false,
presetValue: nil,
key: "key6",
command: []string{"ZLEXCOUNT", "key6", "min", "max", "count"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
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 := handleZLEXCOUNT(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewReader(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d at key \"%s\", got %d", test.expectedResponse, test.key, rv.Integer())
}
}
}
func Test_HandleZDIFF(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedResponse [][]string
expectedError error
}{
{ // 1. Get the difference between 2 sorted sets without scores.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1},
{value: "two", score: 2},
{value: "three", score: 3},
{value: "four", score: 4},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3},
{value: "four", score: 4},
{value: "five", score: 5},
{value: "six", score: 6},
{value: "seven", score: 7},
{value: "eight", score: 8},
}),
},
command: []string{"ZDIFF", "key1", "key2"},
expectedResponse: [][]string{{"one"}, {"two"}},
expectedError: nil,
},
{ // 2. Get the difference between 2 sorted sets with scores.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1},
{value: "two", score: 2},
{value: "three", score: 3},
{value: "four", score: 4},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3},
{value: "four", score: 4},
{value: "five", score: 5},
{value: "six", score: 6},
{value: "seven", score: 7},
{value: "eight", score: 8},
}),
},
command: []string{"ZDIFF", "key1", "key2", "WITHSCORES"},
expectedResponse: [][]string{{"one", "1"}, {"two", "2"}},
expectedError: nil,
},
{ // 3. Get the difference between 3 sets with scores.
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key5": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZDIFF", "key3", "key4", "key5", "WITHSCORES"},
expectedResponse: [][]string{{"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"}},
expectedError: nil,
},
{ // 3. Return sorted set if only one key exists and is a sorted set
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
command: []string{"ZDIFF", "key6", "key7", "key8", "WITHSCORES"},
expectedResponse: [][]string{
{"one", "1"}, {"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"},
{"six", "6"}, {"seven", "7"}, {"eight", "8"},
},
expectedError: nil,
},
{ // 4. Throw error when one of the keys is not a sorted set.
preset: true,
presetValues: map[string]interface{}{
"key9": "Default value",
"key10": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key11": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZDIFF", "key9", "key10", "key11"},
expectedResponse: nil,
expectedError: errors.New("value at key9 is not a sorted set"),
},
{ // 6. Command too short
preset: false,
command: []string{"ZDIFF"},
expectedResponse: [][]string{},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZDIFF(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
for _, element := range rv.Array() {
if !slices.ContainsFunc(test.expectedResponse, func(expected []string) bool {
// The current sub-slice is a different length, return false because they're not equal
if len(element.Array()) != len(expected) {
return false
}
for i := 0; i < len(expected); i++ {
if element.Array()[i].String() != expected[i] {
return false
}
}
return true
}) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
}
}
}
func Test_HandleZDIFFSTORE(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
destination string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Get the difference between 2 sorted sets.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
destination: "destination1",
command: []string{"ZDIFFSTORE", "destination1", "key1", "key2"},
expectedValue: NewSortedSet([]MemberParam{{value: "one", score: 1}, {value: "two", score: 2}}),
expectedResponse: 2,
expectedError: nil,
},
{ // 2. Get the difference between 3 sorted sets.
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key5": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination2",
command: []string{"ZDIFFSTORE", "destination2", "key3", "key4", "key5"},
expectedValue: NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
expectedResponse: 4,
expectedError: nil,
},
{ // 3. Return base sorted set element if base set is the only existing key provided and is a valid sorted set
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
destination: "destination3",
command: []string{"ZDIFFSTORE", "destination3", "key6", "key7", "key8"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
expectedResponse: 8,
expectedError: nil,
},
{ // 4. Throw error when base sorted set is not a set.
preset: true,
presetValues: map[string]interface{}{
"key9": "Default value",
"key10": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key11": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination4",
command: []string{"ZDIFFSTORE", "destination4", "key9", "key10", "key11"},
expectedValue: nil,
expectedResponse: 0,
expectedError: errors.New("value at key9 is not a sorted set"),
},
{ // 5. Throw error when base set is non-existent.
preset: true,
destination: "destination5",
presetValues: map[string]interface{}{
"key12": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key13": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZDIFFSTORE", "destination5", "non-existent", "key12", "key13"},
expectedValue: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 6. Command too short
preset: false,
command: []string{"ZDIFFSTORE", "destination6"},
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZDIFFSTORE(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response integer %d, got %d", test.expectedResponse, rv.Integer())
}
if test.expectedValue != nil {
if _, err = mockServer.KeyRLock(context.Background(), test.destination); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(test.destination).(*SortedSet)
if !ok {
t.Errorf("expected vaule at key %s to be set, got another type", test.destination)
}
for _, elem := range set.GetAll() {
if !test.expectedValue.Contains(elem.value) {
t.Errorf("could not find element %s in the expected values", elem.value)
}
}
mockServer.KeyRUnlock(test.destination)
}
}
}
func Test_HandleZINCRBY(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValue interface{}
key string
command []string
expectedValue *SortedSet
expectedResponse string
expectedError error
}{
{ // 1. Successfully increment by int. Return the new score
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
key: "key1",
command: []string{"ZINCRBY", "key1", "5", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 6}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
expectedResponse: "6",
expectedError: nil,
},
{ // 2. Successfully increment by float. Return new score
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
key: "key2",
command: []string{"ZINCRBY", "key2", "346.785", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 347.785}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
expectedResponse: "347.785",
expectedError: nil,
},
{ // 3. Increment on non-existent sorted set will create the set with the member and increment as its score
preset: false,
presetValue: nil,
key: "key3",
command: []string{"ZINCRBY", "key3", "346.785", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 346.785},
}),
expectedResponse: "346.785",
expectedError: nil,
},
{ // 4. Increment score to +inf
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
key: "key4",
command: []string{"ZINCRBY", "key4", "+inf", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: Score(math.Inf(1))}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
expectedResponse: "+Inf",
expectedError: nil,
},
{ // 5. Increment score to -inf
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
key: "key5",
command: []string{"ZINCRBY", "key5", "-inf", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: Score(math.Inf(-1))}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
expectedResponse: "-Inf",
expectedError: nil,
},
{ // 6. Incrementing score by negative increment should lower the score
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
key: "key6",
command: []string{"ZINCRBY", "key6", "-2.5", "five"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 2.5},
}),
expectedResponse: "2.5",
expectedError: nil,
},
{ // 7. Return error when attempting to increment on a value that is not a valid sorted set
preset: true,
presetValue: "Default value",
key: "key7",
command: []string{"ZINCRBY", "key7", "-2.5", "five"},
expectedValue: nil,
expectedResponse: "",
expectedError: errors.New("value at key7 is not a sorted set"),
},
{ // 8. Return error when trying to increment a member that already has score -inf
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: Score(math.Inf(-1))},
}),
key: "key8",
command: []string{"ZINCRBY", "key8", "2.5", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: Score(math.Inf(-1))},
}),
expectedResponse: "",
expectedError: errors.New("cannot increment -inf or +inf"),
},
{ // 9. Return error when trying to increment a member that already has score +inf
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: Score(math.Inf(1))},
}),
key: "key9",
command: []string{"ZINCRBY", "key9", "2.5", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: Score(math.Inf(-1))},
}),
expectedResponse: "",
expectedError: errors.New("cannot increment -inf or +inf"),
},
{ // 10. Return error when increment is not a valid number
preset: true,
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1},
}),
key: "key10",
command: []string{"ZINCRBY", "key10", "increment", "one"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1},
}),
expectedResponse: "",
expectedError: errors.New("increment must be a double"),
},
{ // 11. Command too short
key: "key11",
command: []string{"ZINCRBY", "key11", "one"},
expectedResponse: "",
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 12. Command too long
key: "key12",
command: []string{"ZINCRBY", "key12", "one", "1", "2"},
expectedResponse: "",
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
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 := handleZINCRBY(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
}
if err != nil {
t.Error(err)
}
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 integer %s, got %s", test.expectedResponse, rv.String())
}
if test.expectedValue != nil {
if _, err = mockServer.KeyRLock(context.Background(), test.key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(test.key).(*SortedSet)
if !ok {
t.Errorf("expected vaule at key %s to be set, got another type", test.key)
}
for _, elem := range set.GetAll() {
if !test.expectedValue.Contains(elem.value) {
t.Errorf("could not find element %s in the expected values", elem.value)
}
if test.expectedValue.Get(elem.value).score != elem.score {
t.Errorf("expected score of element \"%s\" from set at key \"%s\" to be %s, got %s",
elem.value, test.key,
strconv.FormatFloat(float64(test.expectedValue.Get(elem.value).score), 'f', -1, 64),
strconv.FormatFloat(float64(elem.score), 'f', -1, 64),
)
}
}
mockServer.KeyRUnlock(test.key)
}
}
}
func Test_HandleZMPOP(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedValues map[string]*SortedSet
expectedResponse [][]string
expectedError error
}{
{ // 1. Successfully pop one min element by default
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
command: []string{"ZMPOP", "key1"},
expectedValues: map[string]*SortedSet{
"key1": NewSortedSet([]MemberParam{
{value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
expectedResponse: [][]string{
{"one", "1"},
},
expectedError: nil,
},
{ // 2. Successfully pop one min element by specifying MIN
preset: true,
presetValues: map[string]interface{}{
"key2": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
command: []string{"ZMPOP", "key2", "MIN"},
expectedValues: map[string]*SortedSet{
"key2": NewSortedSet([]MemberParam{
{value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
expectedResponse: [][]string{
{"one", "1"},
},
expectedError: nil,
},
{ // 3. Successfully pop one max element by specifying MAX modifier
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
command: []string{"ZMPOP", "key3", "MAX"},
expectedValues: map[string]*SortedSet{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
}),
},
expectedResponse: [][]string{
{"five", "5"},
},
expectedError: nil,
},
{ // 4. Successfully pop multiple min elements
preset: true,
presetValues: map[string]interface{}{
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
},
command: []string{"ZMPOP", "key4", "MIN", "COUNT", "5"},
expectedValues: map[string]*SortedSet{
"key4": NewSortedSet([]MemberParam{
{value: "six", score: 6},
}),
},
expectedResponse: [][]string{
{"one", "1"}, {"two", "2"}, {"three", "3"},
{"four", "4"}, {"five", "5"},
},
expectedError: nil,
},
{ // 5. Successfully pop multiple max elements
preset: true,
presetValues: map[string]interface{}{
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
},
command: []string{"ZMPOP", "key5", "MAX", "COUNT", "5"},
expectedValues: map[string]*SortedSet{
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1},
}),
},
expectedResponse: [][]string{{"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"}},
expectedError: nil,
},
{ // 6. Successfully pop elements from the first set which is non-empty
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{}),
"key7": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
},
command: []string{"ZMPOP", "key6", "key7", "MAX", "COUNT", "5"},
expectedValues: map[string]*SortedSet{
"key6": NewSortedSet([]MemberParam{}),
"key7": NewSortedSet([]MemberParam{
{value: "one", score: 1},
}),
},
expectedResponse: [][]string{{"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"}},
expectedError: nil,
},
{ // 7. Skip the non-set items and pop elements from the first non-empty sorted set found
preset: true,
presetValues: map[string]interface{}{
"key8": "Default value",
"key9": 56,
"key10": NewSortedSet([]MemberParam{}),
"key11": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
},
command: []string{"ZMPOP", "key8", "key9", "key10", "key11", "MIN", "COUNT", "5"},
expectedValues: map[string]*SortedSet{
"key10": NewSortedSet([]MemberParam{}),
"key11": NewSortedSet([]MemberParam{
{value: "six", score: 6},
}),
},
expectedResponse: [][]string{{"one", "1"}, {"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}},
expectedError: nil,
},
{ // 9. Return error when count is a negative integer
preset: false,
command: []string{"ZMPOP", "key8", "MAX", "COUNT", "-20"},
expectedError: errors.New("count must be a positive integer"),
},
{ // 9. Command too short
preset: false,
command: []string{"ZMPOP"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZMPOP(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
for _, element := range rv.Array() {
if !slices.ContainsFunc(test.expectedResponse, func(expected []string) bool {
// The current sub-slice is a different length, return false because they're not equal
if len(element.Array()) != len(expected) {
return false
}
for i := 0; i < len(expected); i++ {
if element.Array()[i].String() != expected[i] {
return false
}
}
return true
}) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
}
for key, expectedSortedSet := range test.expectedValues {
if _, err = mockServer.KeyRLock(context.Background(), key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(key).(*SortedSet)
if !ok {
t.Errorf("expected key \"%s\" to be a sorted set, got another type", key)
}
if !set.Equals(expectedSortedSet) {
t.Errorf("expected sorted set at key \"%s\" %+v, got %+v", key, expectedSortedSet, set)
}
}
}
}
func Test_HandleZPOP(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedValues map[string]*SortedSet
expectedResponse [][]string
expectedError error
}{
{ // 1. Successfully pop one min element by default
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
command: []string{"ZPOPMIN", "key1"},
expectedValues: map[string]*SortedSet{
"key1": NewSortedSet([]MemberParam{
{value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
expectedResponse: [][]string{
{"one", "1"},
},
expectedError: nil,
},
{ // 2. Successfully pop one max element by default
preset: true,
presetValues: map[string]interface{}{
"key2": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
command: []string{"ZPOPMAX", "key2"},
expectedValues: map[string]*SortedSet{
"key2": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
}),
},
expectedResponse: [][]string{
{"five", "5"},
},
expectedError: nil,
},
{ // 3. Successfully pop multiple min elements
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
},
command: []string{"ZPOPMIN", "key3", "5"},
expectedValues: map[string]*SortedSet{
"key3": NewSortedSet([]MemberParam{
{value: "six", score: 6},
}),
},
expectedResponse: [][]string{
{"one", "1"}, {"two", "2"}, {"three", "3"},
{"four", "4"}, {"five", "5"},
},
expectedError: nil,
},
{ // 4. Successfully pop multiple max elements
preset: true,
presetValues: map[string]interface{}{
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
}),
},
command: []string{"ZPOPMAX", "key4", "5"},
expectedValues: map[string]*SortedSet{
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1},
}),
},
expectedResponse: [][]string{{"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"}},
expectedError: nil,
},
{ // 5. Throw an error when trying to pop from an element that's not a sorted set
preset: true,
presetValues: map[string]interface{}{
"key5": "Default value",
},
command: []string{"ZPOPMIN", "key5"},
expectedValues: nil,
expectedResponse: nil,
expectedError: errors.New("value at key key5 is not a sorted set"),
},
{ // 6. Command too short
preset: false,
command: []string{"ZPOPMAX"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 7. Command too long
preset: false,
command: []string{"ZPOPMAX", "key7", "6", "3"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZPOP(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
for _, element := range rv.Array() {
if !slices.ContainsFunc(test.expectedResponse, func(expected []string) bool {
// The current sub-slice is a different length, return false because they're not equal
if len(element.Array()) != len(expected) {
return false
}
for i := 0; i < len(expected); i++ {
if element.Array()[i].String() != expected[i] {
return false
}
}
return true
}) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
}
for key, expectedSortedSet := range test.expectedValues {
if _, err = mockServer.KeyRLock(context.Background(), key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(key).(*SortedSet)
if !ok {
t.Errorf("expected key \"%s\" to be a sorted set, got another type", key)
}
if !set.Equals(expectedSortedSet) {
t.Errorf("expected sorted set at key \"%s\" %+v, got %+v", key, expectedSortedSet, set)
}
}
}
}
func Test_HandleZMSCORE(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedResponse []interface{}
expectedError error
}{
{ // 1. Return multiple scores from the sorted set.
// Return nil for elements that do not exist in the sorted set.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1.1}, {value: "two", score: 245},
{value: "three", score: 3}, {value: "four", score: 4.055},
{value: "five", score: 5},
}),
},
command: []string{"ZMSCORE", "key1", "one", "none", "two", "one", "three", "four", "none", "five"},
expectedResponse: []interface{}{"1.1", nil, "245", "1.1", "3", "4.055", nil, "5"},
expectedError: nil,
},
{ // 2. If key does not exist, return empty array
preset: false,
presetValues: nil,
command: []string{"ZMSCORE", "key2", "one", "two", "three", "four"},
expectedResponse: []interface{}{},
expectedError: nil,
},
{ // 3. Throw error when trying to find scores from elements that are not sorted sets
preset: true,
presetValues: map[string]interface{}{"key3": "Default value"},
command: []string{"ZMSCORE", "key3", "one", "two", "three"},
expectedError: errors.New("value at key3 is not a sorted set"),
},
{ // 9. Command too short
preset: false,
command: []string{"ZMSCORE"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZMSCORE(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
for i := 0; i < len(rv.Array()); i++ {
if rv.Array()[i].IsNull() {
if test.expectedResponse[i] != nil {
t.Errorf("expected element at index %d to be %+v, got %+v", i, test.expectedResponse[i], rv.Array()[i])
}
continue
}
if rv.Array()[i].String() != test.expectedResponse[i] {
t.Errorf("expected \"%s\" at index %d, got %s", test.expectedResponse[i], i, rv.Array()[i].String())
}
}
}
}
func Test_HandleZSCORE(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedResponse interface{}
expectedError error
}{
{ // 1. Return score from a sorted set.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1.1}, {value: "two", score: 245},
{value: "three", score: 3}, {value: "four", score: 4.055},
{value: "five", score: 5},
}),
},
command: []string{"ZSCORE", "key1", "four"},
expectedResponse: "4.055",
expectedError: nil,
},
{ // 2. If key does not exist, return nil value
preset: false,
presetValues: nil,
command: []string{"ZSCORE", "key2", "one"},
expectedResponse: nil,
expectedError: nil,
},
{ // 3. If key exists and is a sorted set, but the member does not exist, return nil
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1.1}, {value: "two", score: 245},
{value: "three", score: 3}, {value: "four", score: 4.055},
{value: "five", score: 5},
}),
},
command: []string{"ZSCORE", "key3", "non-existent"},
expectedResponse: nil,
expectedError: nil,
},
{ // 4. Throw error when trying to find scores from elements that are not sorted sets
preset: true,
presetValues: map[string]interface{}{"key4": "Default value"},
command: []string{"ZSCORE", "key4", "one"},
expectedError: errors.New("value at key4 is not a sorted set"),
},
{ // 5. Command too short
preset: false,
command: []string{"ZSCORE"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 6. Command too long
preset: false,
command: []string{"ZSCORE", "key5", "one", "two"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZSCORE(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedResponse == nil {
if !rv.IsNull() {
t.Errorf("expected nil response, got %+v", rv)
}
continue
}
if rv.String() != test.expectedResponse {
t.Errorf("expected response \"%s\", got %s", test.expectedResponse, rv.String())
}
}
}
func Test_HandleZRANDMEMBER(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
key string
presetValue interface{}
command []string
expectedValue int // The final cardinality of the resulting set
allowRepeat bool
expectedResponse [][]string
expectedError error
}{
{ // 1. Return multiple random elements without removing them
// Count is positive, do not allow repeated elements
preset: true,
key: "key1",
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 8},
}),
command: []string{"ZRANDMEMBER", "key1", "3"},
expectedValue: 8,
allowRepeat: false,
expectedResponse: [][]string{
{"one"}, {"two"}, {"three"}, {"four"},
{"five"}, {"six"}, {"seven"}, {"eight"},
},
expectedError: nil,
},
{
// 2. Return multiple random elements and their scores without removing them.
// Count is negative, so allow repeated numbers.
preset: true,
key: "key2",
presetValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 8},
}),
command: []string{"ZRANDMEMBER", "key2", "-5", "WITHSCORES"},
expectedValue: 8,
allowRepeat: true,
expectedResponse: [][]string{
{"one", "1"}, {"two", "2"}, {"three", "3"}, {"four", "4"},
{"five", "5"}, {"six", "6"}, {"seven", "7"}, {"eight", "8"},
},
expectedError: nil,
},
{ // 2. Return error when the source key is not a sorted set.
preset: true,
key: "key3",
presetValue: "Default value",
command: []string{"ZRANDMEMBER", "key3"},
expectedValue: 0,
expectedError: errors.New("value at key3 is not a sorted set"),
},
{ // 5. Command too short
preset: false,
command: []string{"ZRANDMEMBER"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 6. Command too long
preset: false,
command: []string{"ZRANDMEMBER", "source5", "source6", "member1", "member2"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 7. Throw error when count is not an integer
preset: false,
command: []string{"SRANDMEMBER", "key1", "count"},
expectedError: errors.New("count must be an integer"),
},
{ // 8. Throw error when the fourth argument is not WITHSCORES
preset: false,
command: []string{"SRANDMEMBER", "key1", "8", "ANOTHER"},
expectedError: errors.New("last option must be WITHSCORES"),
},
}
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 := handleZRANDMEMBER(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
// 1. Check if the response array members are all included in test.expectedResponse.
for _, element := range rv.Array() {
if !slices.ContainsFunc(test.expectedResponse, func(expected []string) bool {
// The current sub-slice is a different length, return false because they're not equal
if len(element.Array()) != len(expected) {
return false
}
for i := 0; i < len(expected); i++ {
if element.Array()[i].String() != expected[i] {
return false
}
}
return true
}) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
}
// 2. Fetch the set and check if its cardinality is what we expect.
if _, err = mockServer.KeyRLock(context.Background(), test.key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(test.key).(*SortedSet)
if !ok {
t.Errorf("expected value at key \"%s\" to be a set, got another type", test.key)
}
if set.Cardinality() != test.expectedValue {
t.Errorf("expected cardinality of final set to be %d, got %d", test.expectedValue, set.Cardinality())
}
// 3. Check if all the returned elements we received are still in the set.
for _, element := range rv.Array() {
if !set.Contains(Value(element.Array()[0].String())) {
t.Errorf("expected element \"%s\" to be in set but it was not found", element.String())
}
}
// 4. If allowRepeat is false, check that all the elements make a valid set
if !test.allowRepeat {
var elems []MemberParam
for _, e := range rv.Array() {
if len(e.Array()) == 1 {
elems = append(elems, MemberParam{
value: Value(e.Array()[0].String()),
score: 1,
})
continue
}
elems = append(elems, MemberParam{
value: Value(e.Array()[0].String()),
score: Score(e.Array()[1].Float()),
})
}
s := NewSortedSet(elems)
if s.Cardinality() != len(elems) {
t.Errorf("expected non-repeating elements for random elements at key \"%s\"", test.key)
}
}
}
}
func Test_HandleZRANK(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedResponse []string
expectedError error
}{
{ // 1. Return element's rank from a sorted set.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
},
command: []string{"ZRANK", "key1", "four"},
expectedResponse: []string{"3"},
expectedError: nil,
},
{ // 2. Return element's rank from a sorted set with its score.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 100.1}, {value: "two", score: 245},
{value: "three", score: 305.43}, {value: "four", score: 411.055},
{value: "five", score: 500},
}),
},
command: []string{"ZRANK", "key1", "four", "WITHSCORES"},
expectedResponse: []string{"3", "411.055"},
expectedError: nil,
},
{ // 3. If key does not exist, return nil value
preset: false,
presetValues: nil,
command: []string{"ZRANK", "key3", "one"},
expectedResponse: nil,
expectedError: nil,
},
{ // 4. If key exists and is a sorted set, but the member does not exist, return nil
preset: true,
presetValues: map[string]interface{}{
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1.1}, {value: "two", score: 245},
{value: "three", score: 3}, {value: "four", score: 4.055},
{value: "five", score: 5},
}),
},
command: []string{"ZRANK", "key4", "non-existent"},
expectedResponse: nil,
expectedError: nil,
},
{ // 5. Throw error when trying to find scores from elements that are not sorted sets
preset: true,
presetValues: map[string]interface{}{"key5": "Default value"},
command: []string{"ZRANK", "key5", "one"},
expectedError: errors.New("value at key5 is not a sorted set"),
},
{ // 5. Command too short
preset: false,
command: []string{"ZRANK"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 6. Command too long
preset: false,
command: []string{"ZRANK", "key5", "one", "WITHSCORES", "two"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZRANK(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedResponse == nil {
if !rv.IsNull() {
t.Errorf("expected nil response, got %+v", rv)
}
continue
}
if len(rv.Array()) != len(test.expectedResponse) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
for i := 0; i < len(test.expectedResponse); i++ {
if rv.Array()[i].String() != test.expectedResponse[i] {
t.Errorf("expected element at index %d to be %s, got %s", i, test.expectedResponse[i], rv.Array()[i].String())
}
}
}
}
func Test_HandleZREM(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedValues map[string]*SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Successfully remove multiple elements from sorted set, skipping non-existent members.
// Return deleted count.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
command: []string{"ZREM", "key1", "three", "four", "five", "none", "six", "none", "seven"},
expectedValues: map[string]*SortedSet{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
expectedResponse: 5,
expectedError: nil,
},
{ // 2. If key does not exist, return 0
preset: false,
presetValues: nil,
command: []string{"ZREM", "key2", "member"},
expectedValues: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 3. Return error key is not a sorted set
preset: true,
presetValues: map[string]interface{}{
"key3": "Default value",
},
command: []string{"ZREM", "key3", "member"},
expectedError: errors.New("value at key3 is not a sorted set"),
},
{ // 9. Command too short
preset: false,
command: []string{"ZREM"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZREM(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, rv.Integer())
}
// Check if the expected sorted set is the same at the current one
if test.expectedValues != nil {
for key, expectedSet := range test.expectedValues {
if _, err = mockServer.KeyRLock(context.Background(), key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(key).(*SortedSet)
if !ok {
t.Errorf("expected value at key \"%s\" to be a sorted set, got another type", key)
}
if !set.Equals(expectedSet) {
t.Errorf("exptected sorted set %+v, got %+v", expectedSet, set)
}
}
}
}
}
func Test_HandleZREMRANGEBYSCORE(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedValues map[string]*SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Successfully remove multiple elements with scores inside the provided range
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
command: []string{"ZREMRANGEBYSCORE", "key1", "3", "7"},
expectedValues: map[string]*SortedSet{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
expectedResponse: 5,
expectedError: nil,
},
{ // 2. If key does not exist, return 0
preset: false,
presetValues: nil,
command: []string{"ZREMRANGEBYSCORE", "key2", "2", "4"},
expectedValues: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 3. Return error key is not a sorted set
preset: true,
presetValues: map[string]interface{}{
"key3": "Default value",
},
command: []string{"ZREMRANGEBYSCORE", "key3", "4", "4"},
expectedError: errors.New("value at key3 is not a sorted set"),
},
{ // 4. Command too short
preset: false,
command: []string{"ZREMRANGEBYSCORE", "key4", "3"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 5. Command too long
preset: false,
command: []string{"ZREMRANGEBYSCORE", "key5", "4", "5", "8"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZREMRANGEBYSCORE(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, rv.Integer())
}
// Check if the expected values are the same
if test.expectedValues != nil {
for key, expectedSet := range test.expectedValues {
if _, err = mockServer.KeyRLock(context.Background(), key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(key).(*SortedSet)
if !ok {
t.Errorf("expected value at key \"%s\" to be a sorted set, got another type", key)
}
if !set.Equals(expectedSet) {
t.Errorf("exptected sorted set %+v, got %+v", expectedSet, set)
}
}
}
}
}
func Test_HandleZREMRANGEBYRANK(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedValues map[string]*SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Successfully remove multiple elements within range
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
command: []string{"ZREMRANGEBYRANK", "key1", "0", "5"},
expectedValues: map[string]*SortedSet{
"key1": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
expectedResponse: 6,
expectedError: nil,
},
{ // 2. Establish boundaries from the end of the set when negative boundaries are provided
preset: true,
presetValues: map[string]interface{}{
"key2": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
command: []string{"ZREMRANGEBYRANK", "key2", "-6", "-3"},
expectedValues: map[string]*SortedSet{
"key2": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
expectedResponse: 4,
expectedError: nil,
},
{ // 2. If key does not exist, return 0
preset: false,
presetValues: nil,
command: []string{"ZREMRANGEBYRANK", "key3", "2", "4"},
expectedValues: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 3. Return error key is not a sorted set
preset: true,
presetValues: map[string]interface{}{
"key3": "Default value",
},
command: []string{"ZREMRANGEBYRANK", "key3", "4", "4"},
expectedError: errors.New("value at key3 is not a sorted set"),
},
{ // 4. Command too short
preset: false,
command: []string{"ZREMRANGEBYRANK", "key4", "3"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 5. Return error when start index is out of bounds
preset: true,
presetValues: map[string]interface{}{
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
command: []string{"ZREMRANGEBYRANK", "key5", "-12", "5"},
expectedValues: nil,
expectedResponse: 0,
expectedError: errors.New("indices out of bounds"),
},
{ // 6. Return error when end index is out of bounds
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
}),
},
command: []string{"ZREMRANGEBYRANK", "key6", "0", "11"},
expectedValues: nil,
expectedResponse: 0,
expectedError: errors.New("indices out of bounds"),
},
{ // 7. Command too long
preset: false,
command: []string{"ZREMRANGEBYRANK", "key7", "4", "5", "8"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZREMRANGEBYRANK(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, rv.Integer())
}
// Check if the expected values are the same
if test.expectedValues != nil {
for key, expectedSet := range test.expectedValues {
if _, err = mockServer.KeyRLock(context.Background(), key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(key).(*SortedSet)
if !ok {
t.Errorf("expected value at key \"%s\" to be a sorted set, got another type", key)
}
if !set.Equals(expectedSet) {
t.Errorf("exptected sorted set %+v, got %+v", expectedSet, set)
}
}
}
}
}
func Test_HandleZREMRANGEBYLEX(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedValues map[string]*SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Successfully remove multiple elements with scores inside the provided range
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "a", score: 1}, {value: "b", score: 1},
{value: "c", score: 1}, {value: "d", score: 1},
{value: "e", score: 1}, {value: "f", score: 1},
{value: "g", score: 1}, {value: "h", score: 1},
{value: "i", score: 1}, {value: "j", score: 1},
}),
},
command: []string{"ZREMRANGEBYLEX", "key1", "a", "d"},
expectedValues: map[string]*SortedSet{
"key1": NewSortedSet([]MemberParam{
{value: "e", score: 1}, {value: "f", score: 1},
{value: "g", score: 1}, {value: "h", score: 1},
{value: "i", score: 1}, {value: "j", score: 1},
}),
},
expectedResponse: 4,
expectedError: nil,
},
{ // 2. Return 0 if the members do not have the same score
preset: true,
presetValues: map[string]interface{}{
"key2": NewSortedSet([]MemberParam{
{value: "a", score: 1}, {value: "b", score: 2},
{value: "c", score: 3}, {value: "d", score: 4},
{value: "e", score: 5}, {value: "f", score: 6},
{value: "g", score: 7}, {value: "h", score: 8},
{value: "i", score: 9}, {value: "j", score: 10},
}),
},
command: []string{"ZREMRANGEBYLEX", "key2", "d", "g"},
expectedValues: map[string]*SortedSet{
"key2": NewSortedSet([]MemberParam{
{value: "a", score: 1}, {value: "b", score: 2},
{value: "c", score: 3}, {value: "d", score: 4},
{value: "e", score: 5}, {value: "f", score: 6},
{value: "g", score: 7}, {value: "h", score: 8},
{value: "i", score: 9}, {value: "j", score: 10},
}),
},
expectedResponse: 0,
expectedError: nil,
},
{ // 3. If key does not exist, return 0
preset: false,
presetValues: nil,
command: []string{"ZREMRANGEBYLEX", "key3", "2", "4"},
expectedValues: nil,
expectedResponse: 0,
expectedError: nil,
},
{ // 3. Return error key is not a sorted set
preset: true,
presetValues: map[string]interface{}{
"key3": "Default value",
},
command: []string{"ZREMRANGEBYLEX", "key3", "a", "d"},
expectedError: errors.New("value at key3 is not a sorted set"),
},
{ // 4. Command too short
preset: false,
command: []string{"ZREMRANGEBYLEX", "key4", "a"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 5. Command too long
preset: false,
command: []string{"ZREMRANGEBYLEX", "key5", "a", "b", "c"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZREMRANGEBYLEX(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, rv.Integer())
}
// Check if the expected values are the same
if test.expectedValues != nil {
for key, expectedSet := range test.expectedValues {
if _, err = mockServer.KeyRLock(context.Background(), key); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(key).(*SortedSet)
if !ok {
t.Errorf("expected value at key \"%s\" to be a sorted set, got another type", key)
}
if !set.Equals(expectedSet) {
t.Errorf("exptected sorted set %+v, got %+v", expectedSet, set)
}
}
}
}
}
func Test_HandleZRANGE(t *testing.T) {}
func Test_HandleZRANGESTORE(t *testing.T) {}
func Test_HandleZINTER(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedResponse [][]string
expectedError error
}{
{ // 1. Get the intersection between 2 sorted sets.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
command: []string{"ZINTER", "key1", "key2"},
expectedResponse: [][]string{{"three"}, {"four"}, {"five"}},
expectedError: nil,
},
{
// 2. Get the intersection between 3 sorted sets with scores.
// By default, the SUM aggregate will be used.
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 8},
}),
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "key3", "key4", "key5", "WITHSCORES"},
expectedResponse: [][]string{{"one", "3"}, {"eight", "24"}},
expectedError: nil,
},
{
// 3. Get the intersection between 3 sorted sets with scores.
// Use MIN aggregate.
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key7": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key8": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "key6", "key7", "key8", "WITHSCORES", "AGGREGATE", "MIN"},
expectedResponse: [][]string{{"one", "1"}, {"eight", "8"}},
expectedError: nil,
},
{
// 4. Get the intersection between 3 sorted sets with scores.
// Use MAX aggregate.
preset: true,
presetValues: map[string]interface{}{
"key9": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key10": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key11": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "key9", "key10", "key11", "WITHSCORES", "AGGREGATE", "MAX"},
expectedResponse: [][]string{{"one", "1000"}, {"eight", "800"}},
expectedError: nil,
},
{
// 5. Get the intersection between 3 sorted sets with scores.
// Use SUM aggregate with weights modifier.
preset: true,
presetValues: map[string]interface{}{
"key12": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key13": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key14": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "key12", "key13", "key14", "WITHSCORES", "AGGREGATE", "SUM", "WEIGHTS", "1", "5", "3"},
expectedResponse: [][]string{{"one", "3105"}, {"eight", "2808"}},
expectedError: nil,
},
{
// 6. Get the intersection between 3 sorted sets with scores.
// Use MAX aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key15": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key16": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key17": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "key15", "key16", "key17", "WITHSCORES", "AGGREGATE", "MAX", "WEIGHTS", "1", "5", "3"},
expectedResponse: [][]string{{"one", "3000"}, {"eight", "2400"}},
expectedError: nil,
},
{
// 7. Get the intersection between 3 sorted sets with scores.
// Use MIN aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key18": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key19": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key20": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "key18", "key19", "key20", "WITHSCORES", "AGGREGATE", "MIN", "WEIGHTS", "1", "5", "3"},
expectedResponse: [][]string{{"one", "5"}, {"eight", "8"}},
expectedError: nil,
},
{ // 8. Throw an error if there are more weights than keys
preset: true,
presetValues: map[string]interface{}{
"key21": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key22": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTER", "key21", "key22", "WEIGHTS", "1", "2", "3"},
expectedResponse: nil,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 9. Throw an error if there are fewer weights than keys
preset: true,
presetValues: map[string]interface{}{
"key23": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key24": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
}),
"key25": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTER", "key23", "key24", "key25", "WEIGHTS", "5", "4"},
expectedResponse: nil,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 10. Throw an error if there are no keys provided
preset: true,
presetValues: map[string]interface{}{
"key26": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key27": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key28": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTER", "WEIGHTS", "5", "4"},
expectedResponse: nil,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 11. Throw an error if any of the provided keys are not sorted sets
preset: true,
presetValues: map[string]interface{}{
"key29": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key30": "Default value",
"key31": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTER", "key29", "key30", "key31"},
expectedResponse: nil,
expectedError: errors.New("value at key30 is not a sorted set"),
},
{ // 12. If any of the keys does not exist, return an empty array.
preset: true,
presetValues: map[string]interface{}{
"key32": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key33": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTER", "non-existent", "key32", "key33"},
expectedResponse: [][]string{},
expectedError: nil,
},
{ // 13. Command too short
preset: false,
command: []string{"ZINTER"},
expectedResponse: [][]string{},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZINTER(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
for _, element := range rv.Array() {
if !slices.ContainsFunc(test.expectedResponse, func(expected []string) bool {
// The current sub-slice is a different length, return false because they're not equal
if len(element.Array()) != len(expected) {
return false
}
for i := 0; i < len(expected); i++ {
if element.Array()[i].String() != expected[i] {
return false
}
}
return true
}) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
}
}
}
func Test_HandleZINTERSTORE(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
destination string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Get the intersection between 2 sorted sets.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
destination: "destination1",
command: []string{"ZINTERSTORE", "destination1", "key1", "key2"},
expectedValue: NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
expectedResponse: 3,
expectedError: nil,
},
{
// 2. Get the intersection between 3 sorted sets with scores.
// By default, the SUM aggregate will be used.
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 8},
}),
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination2",
command: []string{"ZINTERSTORE", "destination2", "key3", "key4", "key5", "WITHSCORES"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 24},
}),
expectedResponse: 2,
expectedError: nil,
},
{
// 3. Get the intersection between 3 sorted sets with scores.
// Use MIN aggregate.
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key7": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key8": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination3",
command: []string{"ZINTERSTORE", "destination3", "key6", "key7", "key8", "WITHSCORES", "AGGREGATE", "MIN"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 8},
}),
expectedResponse: 2,
expectedError: nil,
},
{
// 4. Get the intersection between 3 sorted sets with scores.
// Use MAX aggregate.
preset: true,
presetValues: map[string]interface{}{
"key9": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key10": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key11": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination4",
command: []string{"ZINTERSTORE", "destination4", "key9", "key10", "key11", "WITHSCORES", "AGGREGATE", "MAX"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
}),
expectedResponse: 2,
expectedError: nil,
},
{
// 5. Get the intersection between 3 sorted sets with scores.
// Use SUM aggregate with weights modifier.
preset: true,
presetValues: map[string]interface{}{
"key12": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key13": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key14": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination5",
command: []string{"ZINTERSTORE", "destination5", "key12", "key13", "key14", "WITHSCORES", "AGGREGATE", "SUM", "WEIGHTS", "1", "5", "3"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 2808},
}),
expectedResponse: 2,
expectedError: nil,
},
{
// 6. Get the intersection between 3 sorted sets with scores.
// Use MAX aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key15": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key16": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key17": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination6",
command: []string{"ZINTERSTORE", "destination6", "key15", "key16", "key17", "WITHSCORES", "AGGREGATE", "MAX", "WEIGHTS", "1", "5", "3"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 3000}, {value: "eight", score: 2400},
}),
expectedResponse: 2,
expectedError: nil,
},
{
// 7. Get the intersection between 3 sorted sets with scores.
// Use MIN aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key18": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key19": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key20": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination7",
command: []string{"ZINTERSTORE", "destination7", "key18", "key19", "key20", "WITHSCORES", "AGGREGATE", "MIN", "WEIGHTS", "1", "5", "3"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 5}, {value: "eight", score: 8},
}),
expectedResponse: 2,
expectedError: nil,
},
{ // 8. Throw an error if there are more weights than keys
preset: true,
presetValues: map[string]interface{}{
"key21": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key22": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTERSTORE", "destination8", "key21", "key22", "WEIGHTS", "1", "2", "3"},
expectedResponse: 0,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 9. Throw an error if there are fewer weights than keys
preset: true,
presetValues: map[string]interface{}{
"key23": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key24": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
}),
"key25": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTERSTORE", "destination9", "key23", "key24", "key25", "WEIGHTS", "5", "4"},
expectedResponse: 0,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 10. Throw an error if there are no keys provided
preset: true,
presetValues: map[string]interface{}{
"key26": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key27": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key28": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTERSTORE", "WEIGHTS", "5", "4"},
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 11. Throw an error if any of the provided keys are not sorted sets
preset: true,
presetValues: map[string]interface{}{
"key29": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key30": "Default value",
"key31": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZINTERSTORE", "key29", "key30", "key31"},
expectedResponse: 0,
expectedError: errors.New("value at key30 is not a sorted set"),
},
{ // 12. If any of the keys does not exist, return an empty array.
preset: true,
presetValues: map[string]interface{}{
"key32": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key33": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZINTERSTORE", "destination12", "non-existent", "key32", "key33"},
expectedResponse: 0,
expectedError: nil,
},
{ // 13. Command too short
preset: false,
command: []string{"ZINTERSTORE"},
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZINTERSTORE(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response integer %d, got %d", test.expectedResponse, rv.Integer())
}
if test.expectedValue != nil {
if _, err = mockServer.KeyRLock(context.Background(), test.destination); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(test.destination).(*SortedSet)
if !ok {
t.Errorf("expected vaule at key %s to be set, got another type", test.destination)
}
for _, elem := range set.GetAll() {
if !test.expectedValue.Contains(elem.value) {
t.Errorf("could not find element %s in the expected values", elem.value)
}
}
mockServer.KeyRUnlock(test.destination)
}
}
}
func Test_HandleZUNION(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
command []string
expectedResponse [][]string
expectedError error
}{
{ // 1. Get the union between 2 sorted sets.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
command: []string{"ZUNION", "key1", "key2"},
expectedResponse: [][]string{{"one"}, {"two"}, {"three"}, {"four"}, {"five"}, {"six"}, {"seven"}, {"eight"}},
expectedError: nil,
},
{
// 2. Get the union between 3 sorted sets with scores.
// By default, the SUM aggregate will be used.
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 8},
}),
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12}, {value: "thirty-six", score: 36},
}),
},
command: []string{"ZUNION", "key3", "key4", "key5", "WITHSCORES"},
expectedResponse: [][]string{
{"one", "3"}, {"two", "4"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"},
{"seven", "7"}, {"eight", "24"}, {"nine", "9"}, {"ten", "10"}, {"eleven", "11"},
{"twelve", "24"}, {"thirty-six", "72"},
},
expectedError: nil,
},
{
// 3. Get the union between 3 sorted sets with scores.
// Use MIN aggregate.
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key7": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key8": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12}, {value: "thirty-six", score: 72},
}),
},
command: []string{"ZUNION", "key6", "key7", "key8", "WITHSCORES", "AGGREGATE", "MIN"},
expectedResponse: [][]string{
{"one", "1"}, {"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"},
{"seven", "7"}, {"eight", "8"}, {"nine", "9"}, {"ten", "10"}, {"eleven", "11"},
{"twelve", "12"}, {"thirty-six", "36"},
},
expectedError: nil,
},
{
// 4. Get the union between 3 sorted sets with scores.
// Use MAX aggregate.
preset: true,
presetValues: map[string]interface{}{
"key9": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key10": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key11": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12}, {value: "thirty-six", score: 72},
}),
},
command: []string{"ZUNION", "key9", "key10", "key11", "WITHSCORES", "AGGREGATE", "MAX"},
expectedResponse: [][]string{
{"one", "1000"}, {"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"},
{"seven", "7"}, {"eight", "800"}, {"nine", "9"}, {"ten", "10"}, {"eleven", "11"},
{"twelve", "12"}, {"thirty-six", "72"},
},
expectedError: nil,
},
{
// 5. Get the union between 3 sorted sets with scores.
// Use SUM aggregate with weights modifier.
preset: true,
presetValues: map[string]interface{}{
"key12": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key13": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key14": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZUNION", "key12", "key13", "key14", "WITHSCORES", "AGGREGATE", "SUM", "WEIGHTS", "1", "2", "3"},
expectedResponse: [][]string{
{"one", "3102"}, {"two", "6"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"},
{"seven", "7"}, {"eight", "2568"}, {"nine", "27"}, {"ten", "30"}, {"eleven", "22"},
{"twelve", "60"}, {"thirty-six", "72"},
},
expectedError: nil,
},
{
// 6. Get the union between 3 sorted sets with scores.
// Use MAX aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key15": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key16": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key17": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZUNION", "key15", "key16", "key17", "WITHSCORES", "AGGREGATE", "MAX", "WEIGHTS", "1", "2", "3"},
expectedResponse: [][]string{
{"one", "3000"}, {"two", "4"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"},
{"seven", "7"}, {"eight", "2400"}, {"nine", "27"}, {"ten", "30"}, {"eleven", "22"},
{"twelve", "36"}, {"thirty-six", "72"},
},
expectedError: nil,
},
{
// 7. Get the union between 3 sorted sets with scores.
// Use MIN aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key18": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key19": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key20": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZUNION", "key18", "key19", "key20", "WITHSCORES", "AGGREGATE", "MIN", "WEIGHTS", "1", "2", "3"},
expectedResponse: [][]string{
{"one", "2"}, {"two", "2"}, {"three", "3"}, {"four", "4"}, {"five", "5"}, {"six", "6"}, {"seven", "7"},
{"eight", "8"}, {"nine", "27"}, {"ten", "30"}, {"eleven", "22"}, {"twelve", "24"}, {"thirty-six", "72"},
},
expectedError: nil,
},
{ // 8. Throw an error if there are more weights than keys
preset: true,
presetValues: map[string]interface{}{
"key21": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key22": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZUNION", "key21", "key22", "WEIGHTS", "1", "2", "3"},
expectedResponse: nil,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 9. Throw an error if there are fewer weights than keys
preset: true,
presetValues: map[string]interface{}{
"key23": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key24": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
}),
"key25": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZUNION", "key23", "key24", "key25", "WEIGHTS", "5", "4"},
expectedResponse: nil,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 10. Throw an error if there are no keys provided
preset: true,
presetValues: map[string]interface{}{
"key26": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key27": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key28": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZUNION", "WEIGHTS", "5", "4"},
expectedResponse: nil,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 11. Throw an error if any of the provided keys are not sorted sets
preset: true,
presetValues: map[string]interface{}{
"key29": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key30": "Default value",
"key31": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZUNION", "key29", "key30", "key31"},
expectedResponse: nil,
expectedError: errors.New("value at key30 is not a sorted set"),
},
{ // 12. If any of the keys does not exist, skip it.
preset: true,
presetValues: map[string]interface{}{
"key32": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key33": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
command: []string{"ZUNION", "non-existent", "key32", "key33"},
expectedResponse: [][]string{
{"one"}, {"two"}, {"thirty-six"}, {"twelve"}, {"eleven"},
{"seven"}, {"eight"}, {"nine"}, {"ten"},
},
expectedError: nil,
},
{ // 13. Command too short
preset: false,
command: []string{"ZUNION"},
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZUNION(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
for _, element := range rv.Array() {
if !slices.ContainsFunc(test.expectedResponse, func(expected []string) bool {
// The current sub-slice is a different length, return false because they're not equal
if len(element.Array()) != len(expected) {
return false
}
for i := 0; i < len(expected); i++ {
if element.Array()[i].String() != expected[i] {
return false
}
}
return true
}) {
t.Errorf("expected response %+v, got %+v", test.expectedResponse, rv.Array())
}
}
}
}
func Test_HandleZUNIONSTORE(t *testing.T) {
mockServer := server.NewServer(server.Opts{})
tests := []struct {
preset bool
presetValues map[string]interface{}
destination string
command []string
expectedValue *SortedSet
expectedResponse int
expectedError error
}{
{ // 1. Get the union between 2 sorted sets.
preset: true,
presetValues: map[string]interface{}{
"key1": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5},
}),
"key2": NewSortedSet([]MemberParam{
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
},
destination: "destination1",
command: []string{"ZUNIONSTORE", "destination1", "key1", "key2"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
expectedResponse: 8,
expectedError: nil,
},
{
// 2. Get the union between 3 sorted sets with scores.
// By default, the SUM aggregate will be used.
preset: true,
presetValues: map[string]interface{}{
"key3": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key4": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 8},
}),
"key5": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12}, {value: "thirty-six", score: 36},
}),
},
destination: "destination2",
command: []string{"ZUNIONSTORE", "destination2", "key3", "key4", "key5", "WITHSCORES"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 3}, {value: "two", score: 4}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 24},
{value: "nine", score: 9}, {value: "ten", score: 10}, {value: "eleven", score: 11},
{value: "twelve", score: 24}, {value: "thirty-six", score: 72},
}),
expectedResponse: 13,
expectedError: nil,
},
{
// 3. Get the union between 3 sorted sets with scores.
// Use MIN aggregate.
preset: true,
presetValues: map[string]interface{}{
"key6": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key7": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key8": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12}, {value: "thirty-six", score: 72},
}),
},
destination: "destination3",
command: []string{"ZUNIONSTORE", "destination3", "key6", "key7", "key8", "WITHSCORES", "AGGREGATE", "MIN"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10}, {value: "eleven", score: 11},
{value: "twelve", score: 12}, {value: "thirty-six", score: 36},
}),
expectedResponse: 13,
expectedError: nil,
},
{
// 4. Get the union between 3 sorted sets with scores.
// Use MAX aggregate.
preset: true,
presetValues: map[string]interface{}{
"key9": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key10": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key11": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12}, {value: "thirty-six", score: 72},
}),
},
destination: "destination4",
command: []string{
"ZUNIONSTORE", "destination4", "key9", "key10", "key11", "WITHSCORES", "AGGREGATE", "MAX",
},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "two", score: 2}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10}, {value: "eleven", score: 11},
{value: "twelve", score: 12}, {value: "thirty-six", score: 72},
}),
expectedResponse: 13,
expectedError: nil,
},
{
// 5. Get the union between 3 sorted sets with scores.
// Use SUM aggregate with weights modifier.
preset: true,
presetValues: map[string]interface{}{
"key12": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key13": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key14": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination5",
command: []string{
"ZUNIONSTORE", "destination5", "key12", "key13", "key14",
"WITHSCORES", "AGGREGATE", "SUM", "WEIGHTS", "1", "2", "3",
},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 3102}, {value: "two", score: 6}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 2568},
{value: "nine", score: 27}, {value: "ten", score: 30}, {value: "eleven", score: 22},
{value: "twelve", score: 60}, {value: "thirty-six", score: 72},
}),
expectedResponse: 13,
expectedError: nil,
},
{
// 6. Get the union between 3 sorted sets with scores.
// Use MAX aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key15": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key16": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key17": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination6",
command: []string{
"ZUNIONSTORE", "destination6", "key15", "key16", "key17",
"WITHSCORES", "AGGREGATE", "MAX", "WEIGHTS", "1", "2", "3"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 3000}, {value: "two", score: 4}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 2400},
{value: "nine", score: 27}, {value: "ten", score: 30}, {value: "eleven", score: 22},
{value: "twelve", score: 36}, {value: "thirty-six", score: 72},
}),
expectedResponse: 13,
expectedError: nil,
},
{
// 7. Get the union between 3 sorted sets with scores.
// Use MIN aggregate with added weights.
preset: true,
presetValues: map[string]interface{}{
"key18": NewSortedSet([]MemberParam{
{value: "one", score: 100}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key19": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11}, {value: "eight", score: 80},
}),
"key20": NewSortedSet([]MemberParam{
{value: "one", score: 1000}, {value: "eight", score: 800},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination7",
command: []string{
"ZUNIONSTORE", "destination7", "key18", "key19", "key20",
"WITHSCORES", "AGGREGATE", "MIN", "WEIGHTS", "1", "2", "3",
},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 2}, {value: "two", score: 2}, {value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6}, {value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 27}, {value: "ten", score: 30}, {value: "eleven", score: 22},
{value: "twelve", score: 24}, {value: "thirty-six", score: 72},
}),
expectedResponse: 13,
expectedError: nil,
},
{ // 8. Throw an error if there are more weights than keys
preset: true,
presetValues: map[string]interface{}{
"key21": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key22": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
destination: "destination8",
command: []string{"ZUNIONSTORE", "destination8", "key21", "key22", "WEIGHTS", "1", "2", "3"},
expectedResponse: 0,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 9. Throw an error if there are fewer weights than keys
preset: true,
presetValues: map[string]interface{}{
"key23": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key24": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
}),
"key25": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
destination: "destination9",
command: []string{"ZUNIONSTORE", "destination9", "key23", "key24", "key25", "WEIGHTS", "5", "4"},
expectedResponse: 0,
expectedError: errors.New("number of weights should match number of keys"),
},
{ // 10. Throw an error if there are no keys provided
preset: true,
presetValues: map[string]interface{}{
"key26": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key27": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
"key28": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
command: []string{"ZUNIONSTORE", "WEIGHTS", "5", "4"},
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
{ // 11. Throw an error if any of the provided keys are not sorted sets
preset: true,
presetValues: map[string]interface{}{
"key29": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "three", score: 3}, {value: "four", score: 4},
{value: "five", score: 5}, {value: "six", score: 6},
{value: "seven", score: 7}, {value: "eight", score: 8},
}),
"key30": "Default value",
"key31": NewSortedSet([]MemberParam{{value: "one", score: 1}}),
},
destination: "destination11",
command: []string{"ZUNIONSTORE", "destination11", "key29", "key30", "key31"},
expectedResponse: 0,
expectedError: errors.New("value at key30 is not a sorted set"),
},
{ // 12. If any of the keys does not exist, skip it.
preset: true,
presetValues: map[string]interface{}{
"key32": NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2},
{value: "thirty-six", score: 36}, {value: "twelve", score: 12},
{value: "eleven", score: 11},
}),
"key33": NewSortedSet([]MemberParam{
{value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10},
{value: "twelve", score: 12},
}),
},
destination: "destination12",
command: []string{"ZUNIONSTORE", "destination12", "non-existent", "key32", "key33"},
expectedValue: NewSortedSet([]MemberParam{
{value: "one", score: 1}, {value: "two", score: 2}, {value: "seven", score: 7}, {value: "eight", score: 8},
{value: "nine", score: 9}, {value: "ten", score: 10}, {value: "eleven", score: 11}, {value: "twelve", score: 12},
{value: "thirty-six", score: 36},
}),
expectedResponse: 9,
expectedError: nil,
},
{ // 13. Command too short
preset: false,
command: []string{"ZUNIONSTORE"},
expectedResponse: 0,
expectedError: errors.New(utils.WRONG_ARGS_RESPONSE),
},
}
for _, test := range tests {
if test.preset {
for key, value := range test.presetValues {
if _, err := mockServer.CreateKeyAndLock(context.Background(), key); err != nil {
t.Error(err)
}
mockServer.SetValue(context.Background(), key, value)
mockServer.KeyUnlock(key)
}
}
res, err := handleZUNIONSTORE(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
}
if err != nil {
t.Error(err)
}
rd := resp.NewReader(bytes.NewBuffer(res))
rv, _, err := rd.ReadValue()
if err != nil {
t.Error(err)
}
if rv.Integer() != test.expectedResponse {
t.Errorf("expected response integer %d, got %d", test.expectedResponse, rv.Integer())
}
if test.expectedValue != nil {
if _, err = mockServer.KeyRLock(context.Background(), test.destination); err != nil {
t.Error(err)
}
set, ok := mockServer.GetValue(test.destination).(*SortedSet)
if !ok {
t.Errorf("expected vaule at key %s to be set, got another type", test.destination)
}
for _, elem := range set.GetAll() {
if !test.expectedValue.Contains(elem.value) {
t.Errorf("could not find element %s in the expected values", elem.value)
}
}
mockServer.KeyRUnlock(test.destination)
}
}
}
Reference in New Issue View Git Blame Copy Permalink