pkg/SugarDB
1
0
Fork 0
mirror of https://github.com/EchoVault/SugarDB.git synced 2025-10-03 23:26:29 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
dfb5a0ff4bdf2fae96a607ed192ca456e8d4c14d
SugarDB/internal/modules/generic/commands_test.go
Sahil dfb5a0ff4b feat: added DECR command support
2024-06-23 19:07:20 +05:30

2141 lines
65 KiB
Go
Raw Blame History

// Copyright 2024 Kelvin Clement Mwinuka
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package generic_test
import (
"errors"
"fmt"
"strconv"
"strings"
"testing"
"time"
"github.com/echovault/echovault/echovault"
"github.com/echovault/echovault/internal"
"github.com/echovault/echovault/internal/clock"
"github.com/echovault/echovault/internal/config"
"github.com/echovault/echovault/internal/constants"
"github.com/tidwall/resp"
)
type KeyData struct {
Value interface{}
ExpireAt time.Time
}
func Test_Generic(t *testing.T) {
mockClock := clock.NewClock()
port, err := internal.GetFreePort()
if err != nil {
t.Error(err)
return
}
mockServer, err := echovault.NewEchoVault(
echovault.WithConfig(config.Config{
BindAddr: "localhost",
Port: uint16(port),
DataDir: "",
EvictionPolicy: constants.NoEviction,
}),
)
if err != nil {
t.Error(err)
return
}
go func() {
mockServer.Start()
}()
t.Cleanup(func() {
mockServer.ShutDown()
})
t.Run("Test_HandleSET", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]KeyData
expectedResponse interface{}
expectedValue interface{}
expectedExpiry time.Time
expectedErr error
}{
{
name: "1. Set normal string value",
command: []string{"SET", "SetKey1", "value1"},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "value1",
expectedExpiry: time.Time{},
expectedErr: nil,
},
{
name: "2. Set normal integer value",
command: []string{"SET", "SetKey2", "1245678910"},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "1245678910",
expectedExpiry: time.Time{},
expectedErr: nil,
},
{
name: "3. Set normal float value",
command: []string{"SET", "SetKey3", "45782.11341"},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "45782.11341",
expectedExpiry: time.Time{},
expectedErr: nil,
},
{
name: "4. Only set the value if the key does not exist",
command: []string{"SET", "SetKey4", "value4", "NX"},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "value4",
expectedExpiry: time.Time{},
expectedErr: nil,
},
{
name: "5. Throw error when value already exists with NX flag passed",
command: []string{"SET", "SetKey5", "value5", "NX"},
presetValues: map[string]KeyData{
"SetKey5": {
Value: "preset-value5",
ExpireAt: time.Time{},
},
},
expectedResponse: nil,
expectedValue: "preset-value5",
expectedExpiry: time.Time{},
expectedErr: errors.New("key SetKey5 already exists"),
},
{
name: "6. Set new key value when key exists with XX flag passed",
command: []string{"SET", "SetKey6", "value6", "XX"},
presetValues: map[string]KeyData{
"SetKey6": {
Value: "preset-value6",
ExpireAt: time.Time{},
},
},
expectedResponse: "OK",
expectedValue: "value6",
expectedExpiry: time.Time{},
expectedErr: nil,
},
{
name: "7. Return error when setting non-existent key with XX flag",
command: []string{"SET", "SetKey7", "value7", "XX"},
presetValues: nil,
expectedResponse: nil,
expectedValue: nil,
expectedExpiry: time.Time{},
expectedErr: errors.New("key SetKey7 does not exist"),
},
{
name: "8. Return error when NX flag is provided after XX flag",
command: []string{"SET", "SetKey8", "value8", "XX", "NX"},
presetValues: nil,
expectedResponse: nil,
expectedValue: nil,
expectedExpiry: time.Time{},
expectedErr: errors.New("cannot specify NX when XX is already specified"),
},
{
name: "9. Return error when XX flag is provided after NX flag",
command: []string{"SET", "SetKey9", "value9", "NX", "XX"},
presetValues: nil,
expectedResponse: nil,
expectedValue: nil,
expectedExpiry: time.Time{},
expectedErr: errors.New("cannot specify XX when NX is already specified"),
},
{
name: "10. Set expiry time on the key to 100 seconds from now",
command: []string{"SET", "SetKey10", "value10", "EX", "100"},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "value10",
expectedExpiry: mockClock.Now().Add(100 * time.Second),
expectedErr: nil,
},
{
name: "11. Return error when EX flag is passed without seconds value",
command: []string{"SET", "SetKey11", "value11", "EX"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("seconds value required after EX"),
},
{
name: "12. Return error when EX flag is passed with invalid (non-integer) value",
command: []string{"SET", "SetKey12", "value12", "EX", "seconds"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("seconds value should be an integer"),
},
{
name: "13. Return error when trying to set expiry seconds when expiry is already set",
command: []string{"SET", "SetKey13", "value13", "PX", "100000", "EX", "100"},
presetValues: nil,
expectedResponse: nil,
expectedValue: nil,
expectedExpiry: time.Time{},
expectedErr: errors.New("cannot specify EX when expiry time is already set"),
},
{
name: "14. Set expiry time on the key in unix milliseconds",
command: []string{"SET", "SetKey14", "value14", "PX", "4096"},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "value14",
expectedExpiry: mockClock.Now().Add(4096 * time.Millisecond),
expectedErr: nil,
},
{
name: "15. Return error when PX flag is passed without milliseconds value",
command: []string{"SET", "SetKey15", "value15", "PX"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("milliseconds value required after PX"),
},
{
name: "16. Return error when PX flag is passed with invalid (non-integer) value",
command: []string{"SET", "SetKey16", "value16", "PX", "milliseconds"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("milliseconds value should be an integer"),
},
{
name: "17. Return error when trying to set expiry milliseconds when expiry is already provided",
command: []string{"SET", "SetKey17", "value17", "EX", "10", "PX", "1000000"},
presetValues: nil,
expectedResponse: nil,
expectedValue: nil,
expectedExpiry: time.Time{},
expectedErr: errors.New("cannot specify PX when expiry time is already set"),
},
{
name: "18. Set exact expiry time in seconds from unix epoch",
command: []string{
"SET", "SetKey18", "value18",
"EXAT", fmt.Sprintf("%d", mockClock.Now().Add(200*time.Second).Unix()),
},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "value18",
expectedExpiry: mockClock.Now().Add(200 * time.Second),
expectedErr: nil,
},
{
name: "19. Return error when trying to set exact seconds expiry time when expiry time is already provided",
command: []string{
"SET", "SetKey19", "value19",
"EX", "10",
"EXAT", fmt.Sprintf("%d", mockClock.Now().Add(200*time.Second).Unix()),
},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("cannot specify EXAT when expiry time is already set"),
},
{
name: "20. Return error when no seconds value is provided after EXAT flag",
command: []string{"SET", "SetKey20", "value20", "EXAT"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("seconds value required after EXAT"),
},
{
name: "21. Return error when invalid (non-integer) value is passed after EXAT flag",
command: []string{"SET", "SekKey21", "value21", "EXAT", "seconds"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("seconds value should be an integer"),
},
{
name: "22. Set exact expiry time in milliseconds from unix epoch",
command: []string{
"SET", "SetKey22", "value22",
"PXAT", fmt.Sprintf("%d", mockClock.Now().Add(4096*time.Millisecond).UnixMilli()),
},
presetValues: nil,
expectedResponse: "OK",
expectedValue: "value22",
expectedExpiry: mockClock.Now().Add(4096 * time.Millisecond),
expectedErr: nil,
},
{
name: "23. Return error when trying to set exact milliseconds expiry time when expiry time is already provided",
command: []string{
"SET", "SetKey23", "value23",
"PX", "1000",
"PXAT", fmt.Sprintf("%d", mockClock.Now().Add(4096*time.Millisecond).UnixMilli()),
},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("cannot specify PXAT when expiry time is already set"),
},
{
name: "24. Return error when no milliseconds value is provided after PXAT flag",
command: []string{"SET", "SetKey24", "value24", "PXAT"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("milliseconds value required after PXAT"),
},
{
name: "25. Return error when invalid (non-integer) value is passed after EXAT flag",
command: []string{"SET", "SetKey25", "value25", "PXAT", "unix-milliseconds"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "",
expectedExpiry: time.Time{},
expectedErr: errors.New("milliseconds value should be an integer"),
},
{
name: "26. Get the previous value when GET flag is passed",
command: []string{"SET", "SetKey26", "value26", "GET", "EX", "1000"},
presetValues: map[string]KeyData{
"SetKey26": {
Value: "previous-value",
ExpireAt: time.Time{},
},
},
expectedResponse: "previous-value",
expectedValue: "value26",
expectedExpiry: mockClock.Now().Add(1000 * time.Second),
expectedErr: nil,
},
{
name: "27. Return nil when GET value is passed and no previous value exists",
command: []string{"SET", "SetKey27", "value27", "GET", "EX", "1000"},
presetValues: nil,
expectedResponse: nil,
expectedValue: "value27",
expectedExpiry: mockClock.Now().Add(1000 * time.Second),
expectedErr: nil,
},
{
name: "28. Throw error when unknown optional flag is passed to SET command.",
command: []string{"SET", "SetKey28", "value28", "UNKNOWN-OPTION"},
presetValues: nil,
expectedResponse: nil,
expectedValue: nil,
expectedExpiry: time.Time{},
expectedErr: errors.New("unknown option UNKNOWN-OPTION for set command"),
},
{
name: "29. Command too short",
command: []string{"SET"},
expectedResponse: nil,
expectedValue: nil,
expectedErr: errors.New(constants.WrongArgsResponse),
},
{
name: "30. Command too long",
command: []string{"SET", "SetKey30", "value1", "value2", "value3", "value4", "value5", "value6"},
expectedResponse: nil,
expectedValue: nil,
expectedErr: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
cmd := []resp.Value{
resp.StringValue("SET"),
resp.StringValue(k),
resp.StringValue(v.Value.(string))}
err := client.WriteArray(cmd)
if err != nil {
t.Error(err)
}
rd, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(rd.String(), "ok") {
t.Errorf("expected preset response to be \"OK\", got %s", rd.String())
}
}
}
command := make([]resp.Value, len(test.command))
for j, c := range test.command {
command[j] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if test.expectedErr != nil {
if !strings.Contains(res.Error().Error(), test.expectedErr.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedErr.Error(), err.Error())
}
return
}
if err != nil {
t.Error(err)
}
switch test.expectedResponse.(type) {
case string:
if test.expectedResponse != res.String() {
t.Errorf("expected response \"%s\", got \"%s\"", test.expectedResponse, res.String())
}
case nil:
if !res.IsNull() {
t.Errorf("expcted nil response, got %+v", res)
}
default:
t.Error("test expected result should be nil or string")
}
key := test.command[1]
// Compare expected value to response value
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if res.String() != test.expectedValue.(string) {
t.Errorf("expected value %s, got %s", test.expectedValue.(string), res.String())
}
// Compare expected expiry to response expiry
if !test.expectedExpiry.Equal(time.Time{}) {
if err = client.WriteArray([]resp.Value{resp.StringValue("EXPIRETIME"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if res.Integer() != int(test.expectedExpiry.Unix()) {
t.Errorf("expected expiry time %d, got %d", test.expectedExpiry.Unix(), res.Integer())
}
}
})
}
})
t.Run("Test_HandleMSET", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
expectedResponse string
expectedValues map[string]interface{}
expectedErr error
}{
{
name: "1. Set multiple key value pairs",
command: []string{"MSET", "MsetKey1", "value1", "MsetKey2", "10", "MsetKey3", "3.142"},
expectedResponse: "OK",
expectedValues: map[string]interface{}{"MsetKey1": "value1", "MsetKey2": 10, "MsetKey3": 3.142},
expectedErr: nil,
},
{
name: "2. Return error when keys and values are not even",
command: []string{"MSET", "MsetKey1", "value1", "MsetKey2", "10", "MsetKey3"},
expectedResponse: "",
expectedValues: make(map[string]interface{}),
expectedErr: errors.New("each key must be paired with a value"),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
command := make([]resp.Value, len(test.command))
for j, c := range test.command {
command[j] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedErr != nil {
if !strings.Contains(res.Error().Error(), test.expectedErr.Error()) {
t.Errorf("expected error %s, got %s", test.expectedErr.Error(), err.Error())
}
return
}
if res.String() != test.expectedResponse {
t.Errorf("expected response %s, got %s", test.expectedResponse, res.String())
}
for key, expectedValue := range test.expectedValues {
// Get value from server
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
switch expectedValue.(type) {
default:
t.Error("unexpected type for expectedValue")
case int:
ev, _ := expectedValue.(int)
if res.Integer() != ev {
t.Errorf("expected value %d for key %s, got %d", ev, key, res.Integer())
}
case float64:
ev, _ := expectedValue.(float64)
if res.Float() != ev {
t.Errorf("expected value %f for key %s, got %f", ev, key, res.Float())
}
case string:
ev, _ := expectedValue.(string)
if res.String() != ev {
t.Errorf("expected value %s for key %s, got %s", ev, key, res.String())
}
}
}
})
}
})
t.Run("Test_HandleGET", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
key string
value string
}{
{
name: "1. String",
key: "GetKey1",
value: "value1",
},
{
name: "2. Integer",
key: "GetKey2",
value: "10",
},
{
name: "3. Float",
key: "GetKey3",
value: "3.142",
},
}
// Test successful Get command
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
func(key, value string) {
// Preset the values
err = client.WriteArray([]resp.Value{resp.StringValue("SET"), resp.StringValue(key), resp.StringValue(value)})
if err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be \"OK\", got %s", res.String())
}
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if res.String() != test.value {
t.Errorf("expected value %s, got %s", test.value, res.String())
}
}(test.key, test.value)
})
}
// Test get non-existent key
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue("test4")}); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !res.IsNull() {
t.Errorf("expected nil, got: %+v", res)
}
errorTests := []struct {
name string
command []string
expected string
}{
{
name: "1. Return error when no GET key is passed",
command: []string{"GET"},
expected: constants.WrongArgsResponse,
},
{
name: "2. Return error when too many GET keys are passed",
command: []string{"GET", "GetKey1", "test"},
expected: constants.WrongArgsResponse,
},
}
for _, test := range errorTests {
t.Run(test.name, func(t *testing.T) {
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.Contains(res.Error().Error(), test.expected) {
t.Errorf("expected error '%s', got: %s", test.expected, err.Error())
}
})
}
})
t.Run("Test_HandleMGET", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
presetKeys []string
presetValues []string
command []string
expected []interface{}
expectedError error
}{
{
name: "1. MGET multiple existing values",
presetKeys: []string{"MgetKey1", "MgetKey2", "MgetKey3", "MgetKey4"},
presetValues: []string{"value1", "value2", "value3", "value4"},
command: []string{"MGET", "MgetKey1", "MgetKey4", "MgetKey2", "MgetKey3", "MgetKey1"},
expected: []interface{}{"value1", "value4", "value2", "value3", "value1"},
expectedError: nil,
},
{
name: "2. MGET multiple values with nil values spliced in",
presetKeys: []string{"MgetKey5", "MgetKey6", "MgetKey7"},
presetValues: []string{"value5", "value6", "value7"},
command: []string{"MGET", "MgetKey5", "MgetKey6", "non-existent", "non-existent", "MgetKey7", "non-existent"},
expected: []interface{}{"value5", "value6", nil, nil, "value7", nil},
expectedError: nil,
},
{
name: "3. Return error when MGET is invoked with no keys",
presetKeys: []string{"MgetKey5"},
presetValues: []string{"value5"},
command: []string{"MGET"},
expected: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
// Set up the values
for i, key := range test.presetKeys {
if err = client.WriteArray([]resp.Value{
resp.StringValue("SET"),
resp.StringValue(key),
resp.StringValue(test.presetValues[i]),
}); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be \"OK\", got \"%s\"", res.String())
}
}
// Test the command and its results
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
// If we expect and error, branch out and check error
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error %+v, got: %+v", test.expectedError, err)
}
return
}
if res.Type().String() != "Array" {
t.Errorf("expected type Array, got: %s", res.Type().String())
}
for i, value := range res.Array() {
if test.expected[i] == nil {
if !value.IsNull() {
t.Errorf("expected nil value, got %+v", value)
}
continue
}
if value.String() != test.expected[i] {
t.Errorf("expected value %s, got: %s", test.expected[i], value.String())
}
}
})
}
})
t.Run("Test_HandleDEL", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]string
expectedResponse int
expectToExist map[string]bool
expectedErr error
}{
{
name: "1. Delete multiple keys",
command: []string{"DEL", "DelKey1", "DelKey2", "DelKey3", "DelKey4", "DelKey5"},
presetValues: map[string]string{
"DelKey1": "value1",
"DelKey2": "value2",
"DelKey3": "value3",
"DelKey4": "value4",
},
expectedResponse: 4,
expectToExist: map[string]bool{
"DelKey1": false,
"DelKey2": false,
"DelKey3": false,
"DelKey4": false,
"DelKey5": false,
},
expectedErr: nil,
},
{
name: "2. Return error when DEL is called with no keys",
command: []string{"DEL"},
presetValues: nil,
expectedResponse: 0,
expectToExist: nil,
expectedErr: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
if err = client.WriteArray([]resp.Value{
resp.StringValue("SET"),
resp.StringValue(k),
resp.StringValue(v),
}); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be \"OK\", got %s", res.String())
}
}
}
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedErr != nil {
if !strings.Contains(res.Error().Error(), test.expectedErr.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedErr.Error(), res.Error().Error())
}
return
}
if res.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, res.Integer())
}
for key, expected := range test.expectToExist {
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
exists := !res.IsNull()
if exists != expected {
t.Errorf("expected existence of key %s to be %v, got %v", key, expected, exists)
}
}
})
}
})
t.Run("Test_HandlePERSIST", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]KeyData
expectedResponse int
expectedValues map[string]KeyData
expectedError error
}{
{
name: "1. Successfully persist a volatile key",
command: []string{"PERSIST", "PersistKey1"},
presetValues: map[string]KeyData{
"PersistKey1": {Value: "value1", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"PersistKey1": {Value: "value1", ExpireAt: time.Time{}},
},
expectedError: nil,
},
{
name: "2. Return 0 when trying to persist a non-existent key",
command: []string{"PERSIST", "PersistKey2"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: nil,
},
{
name: "3. Return 0 when trying to persist a non-volatile key",
command: []string{"PERSIST", "PersistKey3"},
presetValues: map[string]KeyData{
"PersistKey3": {Value: "value3", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"PersistKey3": {Value: "value3", ExpireAt: time.Time{}},
},
expectedError: nil,
},
{
name: "4. Command too short",
command: []string{"PERSIST"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "5. Command too long",
command: []string{"PERSIST", "PersistKey5", "key6"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(k), resp.StringValue(v.Value.(string))}
if !v.ExpireAt.Equal(time.Time{}) {
command = append(command, []resp.Value{
resp.StringValue("PX"),
resp.StringValue(fmt.Sprintf("%d", v.ExpireAt.Sub(mockClock.Now()).Milliseconds())),
}...)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
}
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if res.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, res.Integer())
}
if test.expectedValues == nil {
return
}
for key, expected := range test.expectedValues {
// Compare the value of the key with what's expected
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if res.String() != expected.Value.(string) {
t.Errorf("expected value %s, got %s", expected.Value.(string), res.String())
}
// Compare the expiry of the key with what's expected
if err = client.WriteArray([]resp.Value{resp.StringValue("PTTL"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if expected.ExpireAt.Equal(time.Time{}) {
if res.Integer() != -1 {
t.Error("expected key to be persisted, it was not.")
}
continue
}
if res.Integer() != int(expected.ExpireAt.UnixMilli()) {
t.Errorf("expected expiry %d, got %d", expected.ExpireAt.UnixMilli(), res.Integer())
}
}
})
}
})
t.Run("Test_HandleEXPIRETIME", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]KeyData
expectedResponse int
expectedError error
}{
{
name: "1. Return expire time in seconds",
command: []string{"EXPIRETIME", "ExpireTimeKey1"},
presetValues: map[string]KeyData{
"ExpireTimeKey1": {Value: "value1", ExpireAt: mockClock.Now().Add(100 * time.Second)},
},
expectedResponse: int(mockClock.Now().Add(100 * time.Second).Unix()),
expectedError: nil,
},
{
name: "2. Return expire time in milliseconds",
command: []string{"PEXPIRETIME", "ExpireTimeKey2"},
presetValues: map[string]KeyData{
"ExpireTimeKey2": {Value: "value2", ExpireAt: mockClock.Now().Add(4096 * time.Millisecond)},
},
expectedResponse: int(mockClock.Now().Add(4096 * time.Millisecond).UnixMilli()),
expectedError: nil,
},
{
name: "3. If the key is non-volatile, return -1",
command: []string{"PEXPIRETIME", "ExpireTimeKey3"},
presetValues: map[string]KeyData{
"ExpireTimeKey3": {Value: "value3", ExpireAt: time.Time{}},
},
expectedResponse: -1,
expectedError: nil,
},
{
name: "4. If the key is non-existent return -2",
command: []string{"PEXPIRETIME", "ExpireTimeKey4"},
presetValues: nil,
expectedResponse: -2,
expectedError: nil,
},
{
name: "5. Command too short",
command: []string{"PEXPIRETIME"},
presetValues: nil,
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "6. Command too long",
command: []string{"PEXPIRETIME", "ExpireTimeKey5", "ExpireTimeKey6"},
presetValues: nil,
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(k), resp.StringValue(v.Value.(string))}
if !v.ExpireAt.Equal(time.Time{}) {
command = append(command, []resp.Value{
resp.StringValue("PX"),
resp.StringValue(fmt.Sprintf("%d", v.ExpireAt.Sub(mockClock.Now()).Milliseconds())),
}...)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
}
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if res.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, res.Integer())
}
})
}
})
t.Run("Test_HandleTTL", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]KeyData
expectedResponse int
expectedError error
}{
{
name: "1. Return TTL time in seconds",
command: []string{"TTL", "TTLKey1"},
presetValues: map[string]KeyData{
"TTLKey1": {Value: "value1", ExpireAt: mockClock.Now().Add(100 * time.Second)},
},
expectedResponse: 100,
expectedError: nil,
},
{
name: "2. Return TTL time in milliseconds",
command: []string{"PTTL", "TTLKey2"},
presetValues: map[string]KeyData{
"TTLKey2": {Value: "value2", ExpireAt: mockClock.Now().Add(4096 * time.Millisecond)},
},
expectedResponse: 4096,
expectedError: nil,
},
{
name: "3. If the key is non-volatile, return -1",
command: []string{"TTL", "TTLKey3"},
presetValues: map[string]KeyData{
"TTLKey3": {Value: "value3", ExpireAt: time.Time{}},
},
expectedResponse: -1,
expectedError: nil,
},
{
name: "4. If the key is non-existent return -2",
command: []string{"TTL", "TTLKey4"},
presetValues: nil,
expectedResponse: -2,
expectedError: nil,
},
{
name: "5. Command too short",
command: []string{"TTL"},
presetValues: nil,
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "6. Command too long",
command: []string{"TTL", "TTLKey5", "TTLKey6"},
presetValues: nil,
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(k), resp.StringValue(v.Value.(string))}
if !v.ExpireAt.Equal(time.Time{}) {
command = append(command, []resp.Value{
resp.StringValue("PX"),
resp.StringValue(fmt.Sprintf("%d", v.ExpireAt.Sub(mockClock.Now()).Milliseconds())),
}...)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
}
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if res.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, res.Integer())
}
})
}
})
t.Run("Test_HandleEXPIRE", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]KeyData
expectedResponse int
expectedValues map[string]KeyData
expectedError error
}{
{
name: "1. Set new expire by seconds",
command: []string{"EXPIRE", "ExpireKey1", "100"},
presetValues: map[string]KeyData{
"ExpireKey1": {Value: "value1", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey1": {Value: "value1", ExpireAt: mockClock.Now().Add(100 * time.Second)},
},
expectedError: nil,
},
{
name: "2. Set new expire by milliseconds",
command: []string{"PEXPIRE", "ExpireKey2", "1000"},
presetValues: map[string]KeyData{
"ExpireKey2": {Value: "value2", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey2": {Value: "value2", ExpireAt: mockClock.Now().Add(1000 * time.Millisecond)},
},
expectedError: nil,
},
{
name: "3. Set new expire only when key does not have an expiry time with NX flag",
command: []string{"EXPIRE", "ExpireKey3", "1000", "NX"},
presetValues: map[string]KeyData{
"ExpireKey3": {Value: "value3", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey3": {Value: "value3", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "4. Return 0, when NX flag is provided and key already has an expiry time",
command: []string{"EXPIRE", "ExpireKey4", "1000", "NX"},
presetValues: map[string]KeyData{
"ExpireKey4": {Value: "value4", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireKey4": {Value: "value4", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "5. Set new expire time from now key only when the key already has an expiry time with XX flag",
command: []string{"EXPIRE", "ExpireKey5", "1000", "XX"},
presetValues: map[string]KeyData{
"ExpireKey5": {Value: "value5", ExpireAt: mockClock.Now().Add(30 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey5": {Value: "value5", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "6. Return 0 when key does not have an expiry and the XX flag is provided",
command: []string{"EXPIRE", "ExpireKey6", "1000", "XX"},
presetValues: map[string]KeyData{
"ExpireKey6": {Value: "value6", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireKey6": {Value: "value6", ExpireAt: time.Time{}},
},
expectedError: nil,
},
{
name: "7. Set expiry time when the provided time is after the current expiry time when GT flag is provided",
command: []string{"EXPIRE", "ExpireKey7", "1000", "GT"},
presetValues: map[string]KeyData{
"ExpireKey7": {Value: "value7", ExpireAt: mockClock.Now().Add(30 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey7": {Value: "value7", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "8. Return 0 when GT flag is passed and current expiry time is greater than provided time",
command: []string{"EXPIRE", "ExpireKey8", "1000", "GT"},
presetValues: map[string]KeyData{
"ExpireKey8": {Value: "value8", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireKey8": {Value: "value8", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedError: nil,
},
{
name: "9. Return 0 when GT flag is passed and key does not have an expiry time",
command: []string{"EXPIRE", "ExpireKey9", "1000", "GT"},
presetValues: map[string]KeyData{
"ExpireKey9": {Value: "value9", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireKey9": {Value: "value9", ExpireAt: time.Time{}},
},
expectedError: nil,
},
{
name: "10. Set expiry time when the provided time is before the current expiry time when LT flag is provided",
command: []string{"EXPIRE", "ExpireKey10", "1000", "LT"},
presetValues: map[string]KeyData{
"ExpireKey10": {Value: "value10", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey10": {Value: "value10", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "11. Return 0 when LT flag is passed and current expiry time is less than provided time",
command: []string{"EXPIRE", "ExpireKey11", "5000", "LT"},
presetValues: map[string]KeyData{
"ExpireKey11": {Value: "value11", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireKey11": {Value: "value11", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedError: nil,
},
{
name: "12. Return 0 when LT flag is passed and key does not have an expiry time",
command: []string{"EXPIRE", "ExpireKey12", "1000", "LT"},
presetValues: map[string]KeyData{
"ExpireKey12": {Value: "value12", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireKey12": {Value: "value12", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "13. Return error when unknown flag is passed",
command: []string{"EXPIRE", "ExpireKey13", "1000", "UNKNOWN"},
presetValues: map[string]KeyData{
"ExpireKey13": {Value: "value13", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New("unknown option UNKNOWN"),
},
{
name: "14. Return error when expire time is not a valid integer",
command: []string{"EXPIRE", "ExpireKey14", "expire"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New("expire time must be integer"),
},
{
name: "15. Command too short",
command: []string{"EXPIRE"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "16. Command too long",
command: []string{"EXPIRE", "ExpireKey16", "10", "NX", "GT"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(k), resp.StringValue(v.Value.(string))}
if !v.ExpireAt.Equal(time.Time{}) {
command = append(command, []resp.Value{
resp.StringValue("PX"),
resp.StringValue(fmt.Sprintf("%d", v.ExpireAt.Sub(mockClock.Now()).Milliseconds())),
}...)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
}
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if res.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, res.Integer())
}
if test.expectedValues == nil {
return
}
for key, expected := range test.expectedValues {
// Compare the value of the key with what's expected
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if res.String() != expected.Value.(string) {
t.Errorf("expected value %s, got %s", expected.Value.(string), res.String())
}
// Compare the expiry of the key with what's expected
if err = client.WriteArray([]resp.Value{resp.StringValue("PTTL"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if expected.ExpireAt.Equal(time.Time{}) {
if res.Integer() != -1 {
t.Error("expected key to be persisted, it was not.")
}
continue
}
if res.Integer() != int(expected.ExpireAt.Sub(mockClock.Now()).Milliseconds()) {
t.Errorf("expected expiry %d, got %d", expected.ExpireAt.Sub(mockClock.Now()).Milliseconds(), res.Integer())
}
}
})
}
})
t.Run("Test_HandleEXPIREAT", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
command []string
presetValues map[string]KeyData
expectedResponse int
expectedValues map[string]KeyData
expectedError error
}{
{
name: "1. Set new expire by unix seconds",
command: []string{"EXPIREAT", "ExpireAtKey1", fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix())},
presetValues: map[string]KeyData{
"ExpireAtKey1": {Value: "value1", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey1": {Value: "value1", ExpireAt: time.Unix(mockClock.Now().Add(1000*time.Second).Unix(), 0)},
},
expectedError: nil,
},
{
name: "2. Set new expire by milliseconds",
command: []string{"PEXPIREAT", "ExpireAtKey2", fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).UnixMilli())},
presetValues: map[string]KeyData{
"ExpireAtKey2": {Value: "value2", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey2": {Value: "value2", ExpireAt: time.UnixMilli(mockClock.Now().Add(1000 * time.Second).UnixMilli())},
},
expectedError: nil,
},
{
name: "3. Set new expire only when key does not have an expiry time with NX flag",
command: []string{"EXPIREAT", "ExpireAtKey3", fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "NX"},
presetValues: map[string]KeyData{
"ExpireAtKey3": {Value: "value3", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey3": {Value: "value3", ExpireAt: time.Unix(mockClock.Now().Add(1000*time.Second).Unix(), 0)},
},
expectedError: nil,
},
{
name: "4. Return 0, when NX flag is provided and key already has an expiry time",
command: []string{"EXPIREAT", "ExpireAtKey4", fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "NX"},
presetValues: map[string]KeyData{
"ExpireAtKey4": {Value: "value4", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireAtKey4": {Value: "value4", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "5. Set new expire time from now key only when the key already has an expiry time with XX flag",
command: []string{
"EXPIREAT", "ExpireAtKey5",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "XX",
},
presetValues: map[string]KeyData{
"ExpireAtKey5": {Value: "value5", ExpireAt: mockClock.Now().Add(30 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey5": {Value: "value5", ExpireAt: time.Unix(mockClock.Now().Add(1000*time.Second).Unix(), 0)},
},
expectedError: nil,
},
{
name: "6. Return 0 when key does not have an expiry and the XX flag is provided",
command: []string{
"EXPIREAT", "ExpireAtKey6",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "XX",
},
presetValues: map[string]KeyData{
"ExpireAtKey6": {Value: "value6", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireAtKey6": {Value: "value6", ExpireAt: time.Time{}},
},
expectedError: nil,
},
{
name: "7. Set expiry time when the provided time is after the current expiry time when GT flag is provided",
command: []string{
"EXPIREAT", "ExpireAtKey7",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "GT",
},
presetValues: map[string]KeyData{
"ExpireAtKey7": {Value: "value7", ExpireAt: mockClock.Now().Add(30 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey7": {Value: "value7", ExpireAt: time.Unix(mockClock.Now().Add(1000*time.Second).Unix(), 0)},
},
expectedError: nil,
},
{
name: "8. Return 0 when GT flag is passed and current expiry time is greater than provided time",
command: []string{
"EXPIREAT", "ExpireAtKey8",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "GT",
},
presetValues: map[string]KeyData{
"ExpireAtKey8": {Value: "value8", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireAtKey8": {Value: "value8", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedError: nil,
},
{
name: "9. Return 0 when GT flag is passed and key does not have an expiry time",
command: []string{
"EXPIREAT", "ExpireAtKey9",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "GT",
},
presetValues: map[string]KeyData{
"ExpireAtKey9": {Value: "value9", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireAtKey9": {Value: "value9", ExpireAt: time.Time{}},
},
expectedError: nil,
},
{
name: "10. Set expiry time when the provided time is before the current expiry time when LT flag is provided",
command: []string{
"EXPIREAT", "ExpireAtKey10",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "LT",
},
presetValues: map[string]KeyData{
"ExpireAtKey10": {Value: "value10", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey10": {Value: "value10", ExpireAt: time.Unix(mockClock.Now().Add(1000*time.Second).Unix(), 0)},
},
expectedError: nil,
},
{
name: "11. Return 0 when LT flag is passed and current expiry time is less than provided time",
command: []string{
"EXPIREAT", "ExpireAtKey11",
fmt.Sprintf("%d", mockClock.Now().Add(3000*time.Second).Unix()), "LT",
},
presetValues: map[string]KeyData{
"ExpireAtKey11": {Value: "value11", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedResponse: 0,
expectedValues: map[string]KeyData{
"ExpireAtKey11": {Value: "value11", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
},
expectedError: nil,
},
{
name: "12. Return 0 when LT flag is passed and key does not have an expiry time",
command: []string{
"EXPIREAT", "ExpireAtKey12",
fmt.Sprintf("%d", mockClock.Now().Add(1000*time.Second).Unix()), "LT",
},
presetValues: map[string]KeyData{
"ExpireAtKey12": {Value: "value12", ExpireAt: time.Time{}},
},
expectedResponse: 1,
expectedValues: map[string]KeyData{
"ExpireAtKey12": {Value: "value12", ExpireAt: time.Unix(mockClock.Now().Add(1000*time.Second).Unix(), 0)},
},
expectedError: nil,
},
{
name: "13. Return error when unknown flag is passed",
command: []string{"EXPIREAT", "ExpireAtKey13", "1000", "UNKNOWN"},
presetValues: map[string]KeyData{
"ExpireAtKey13": {Value: "value13", ExpireAt: time.Time{}},
},
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New("unknown option UNKNOWN"),
},
{
name: "14. Return error when expire time is not a valid integer",
command: []string{"EXPIREAT", "ExpireAtKey14", "expire"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New("expire time must be integer"),
},
{
name: "15. Command too short",
command: []string{"EXPIREAT"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "16. Command too long",
command: []string{"EXPIREAT", "ExpireAtKey16", "10", "NX", "GT"},
presetValues: nil,
expectedResponse: 0,
expectedValues: nil,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValues != nil {
for k, v := range test.presetValues {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(k), resp.StringValue(v.Value.(string))}
if !v.ExpireAt.Equal(time.Time{}) {
command = append(command, []resp.Value{
resp.StringValue("PX"),
resp.StringValue(fmt.Sprintf("%d", v.ExpireAt.Sub(mockClock.Now()).Milliseconds())),
}...)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
}
command := make([]resp.Value, len(test.command))
for i, c := range test.command {
command[i] = resp.StringValue(c)
}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if res.Integer() != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, res.Integer())
}
if test.expectedValues == nil {
return
}
for key, expected := range test.expectedValues {
// Compare the value of the key with what's expected
if err = client.WriteArray([]resp.Value{resp.StringValue("GET"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if res.String() != expected.Value.(string) {
t.Errorf("expected value %s, got %s", expected.Value.(string), res.String())
}
// Compare the expiry of the key with what's expected
if err = client.WriteArray([]resp.Value{resp.StringValue("PTTL"), resp.StringValue(key)}); err != nil {
t.Error(err)
}
res, _, err = client.ReadValue()
if err != nil {
t.Error(err)
}
if expected.ExpireAt.Equal(time.Time{}) {
if res.Integer() != -1 {
t.Error("expected key to be persisted, it was not.")
}
continue
}
if res.Integer() != int(expected.ExpireAt.Sub(mockClock.Now()).Milliseconds()) {
t.Errorf("expected expiry %d, got %d", expected.ExpireAt.Sub(mockClock.Now()).Milliseconds(), res.Integer())
}
}
})
}
})
t.Run("Test_HandlerINCR", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
key string
presetValue interface{}
command []resp.Value
expectedResponse int64
expectedError error
}{
{
name: "1. Increment non-existent key",
key: "IncrKey1",
presetValue: nil,
command: []resp.Value{resp.StringValue("INCR"), resp.StringValue("IncrKey1")},
expectedResponse: 1,
expectedError: nil,
},
{
name: "2. Increment existing key with integer value",
key: "IncrKey2",
presetValue: "5",
command: []resp.Value{resp.StringValue("INCR"), resp.StringValue("IncrKey2")},
expectedResponse: 6,
expectedError: nil,
},
{
name: "3. Increment existing key with non-integer value",
key: "IncrKey3",
presetValue: "not_an_int",
command: []resp.Value{resp.StringValue("INCR"), resp.StringValue("IncrKey3")},
expectedResponse: 0,
expectedError: errors.New("value is not an integer or out of range"),
},
{
name: "4. Increment existing key with int64 value",
key: "IncrKey4",
presetValue: int64(10),
command: []resp.Value{resp.StringValue("INCR"), resp.StringValue("IncrKey4")},
expectedResponse: 11,
expectedError: nil,
},
{
name: "5. Command too short",
key: "IncrKey5",
presetValue: nil,
command: []resp.Value{resp.StringValue("INCR")},
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "6. Command too long",
key: "IncrKey6",
presetValue: nil,
command: []resp.Value{
resp.StringValue("INCR"),
resp.StringValue("IncrKey6"),
resp.StringValue("IncrKey6"),
},
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValue != nil {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(test.key), resp.StringValue(fmt.Sprintf("%v", test.presetValue))}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
if err = client.WriteArray(test.command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if err != nil {
t.Error(err)
} else {
responseInt, err := strconv.ParseInt(res.String(), 10, 64)
if err != nil {
t.Errorf("error parsing response to int64: %s", err)
}
if responseInt != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, responseInt)
}
}
})
}
})
t.Run("Test_HandlerDECR", func(t *testing.T) {
t.Parallel()
conn, err := internal.GetConnection("localhost", port)
if err != nil {
t.Error(err)
return
}
defer func() {
_ = conn.Close()
}()
client := resp.NewConn(conn)
tests := []struct {
name string
key string
presetValue interface{}
command []resp.Value
expectedResponse int64
expectedError error
}{
{
name: "1. Increment non-existent key",
key: "DecrKey1",
presetValue: nil,
command: []resp.Value{resp.StringValue("DECR"), resp.StringValue("DecrKey1")},
expectedResponse: -1,
expectedError: nil,
},
{
name: "2. Decrement existing key with integer value",
key: "DecrKey2",
presetValue: "5",
command: []resp.Value{resp.StringValue("DECR"), resp.StringValue("DecrKey2")},
expectedResponse: 4,
expectedError: nil,
},
{
name: "3. Decrement existing key with non-integer value",
key: "DecrKey3",
presetValue: "not_an_int",
command: []resp.Value{resp.StringValue("DECR"), resp.StringValue("DecrKey3")},
expectedResponse: 0,
expectedError: errors.New("value is not an integer or out of range"),
},
{
name: "4. Decrement existing key with int64 value",
key: "DecrKey4",
presetValue: int64(10),
command: []resp.Value{resp.StringValue("DECR"), resp.StringValue("DecrKey4")},
expectedResponse: 11,
expectedError: nil,
},
{
name: "5. Command too short",
key: "DencrKey5",
presetValue: nil,
command: []resp.Value{resp.StringValue("DECR")},
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
{
name: "6. Command too long",
key: "DecrKey6",
presetValue: nil,
command: []resp.Value{
resp.StringValue("DECR"),
resp.StringValue("DecrKey6"),
resp.StringValue("DecrKey6"),
},
expectedResponse: 0,
expectedError: errors.New(constants.WrongArgsResponse),
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.presetValue != nil {
command := []resp.Value{resp.StringValue("SET"), resp.StringValue(test.key), resp.StringValue(fmt.Sprintf("%v", test.presetValue))}
if err = client.WriteArray(command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if !strings.EqualFold(res.String(), "ok") {
t.Errorf("expected preset response to be OK, got %s", res.String())
}
}
if err = client.WriteArray(test.command); err != nil {
t.Error(err)
}
res, _, err := client.ReadValue()
if err != nil {
t.Error(err)
}
if test.expectedError != nil {
if !strings.Contains(res.Error().Error(), test.expectedError.Error()) {
t.Errorf("expected error \"%s\", got \"%s\"", test.expectedError.Error(), err.Error())
}
return
}
if err != nil {
t.Error(err)
} else {
responseInt, err := strconv.ParseInt(res.String(), 10, 64)
if err != nil {
t.Errorf("error parsing response to int64: %s", err)
}
if responseInt != test.expectedResponse {
t.Errorf("expected response %d, got %d", test.expectedResponse, responseInt)
}
}
})
}
})
}
Reference in New Issue View Git Blame Copy Permalink