mirror of
https://github.com/EchoVault/SugarDB.git
synced 2025-10-06 08:27:04 +08:00
Renamed all api test files to api_test.go
This commit is contained in:
Kelvin Clement Mwinuka
934
test/modules/generic/api_test.go
Normal file
934
test/modules/generic/api_test.go
Normal file
@@ -0,0 +1,934 @@
|
||||
// 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
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/echovault/echovault/internal"
|
||||
"github.com/echovault/echovault/internal/clock"
|
||||
"github.com/echovault/echovault/internal/config"
|
||||
"github.com/echovault/echovault/pkg/echovault"
|
||||
"reflect"
|
||||
"slices"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func createEchoVault() *echovault.EchoVault {
|
||||
ev, _ := echovault.NewEchoVault(
|
||||
echovault.WithConfig(config.Config{
|
||||
DataDir: "",
|
||||
}),
|
||||
)
|
||||
return ev
|
||||
}
|
||||
|
||||
func presetValue(server *echovault.EchoVault, ctx context.Context, key string, value interface{}) error {
|
||||
if _, err := server.CreateKeyAndLock(ctx, key); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := server.SetValue(ctx, key, value); err != nil {
|
||||
return err
|
||||
}
|
||||
server.KeyUnlock(ctx, key)
|
||||
return nil
|
||||
}
|
||||
|
||||
func presetKeyData(server *echovault.EchoVault, ctx context.Context, key string, data internal.KeyData) {
|
||||
_, _ = server.CreateKeyAndLock(ctx, key)
|
||||
defer server.KeyUnlock(ctx, key)
|
||||
_ = server.SetValue(ctx, key, data.Value)
|
||||
server.SetExpiry(ctx, key, data.ExpireAt, false)
|
||||
}
|
||||
|
||||
func TestEchoVault_DEL(t *testing.T) {
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
keys []string
|
||||
want int
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Delete several keys and return deleted count",
|
||||
keys: []string{"key1", "key2", "key3", "key4", "key5"},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key1": {Value: "value1", ExpireAt: time.Time{}},
|
||||
"key2": {Value: "value2", ExpireAt: time.Time{}},
|
||||
"key3": {Value: "value3", ExpireAt: time.Time{}},
|
||||
"key4": {Value: "value4", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 4,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
got, err := server.DEL(tt.keys...)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("DEL() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("DEL() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_EXPIRE(t *testing.T) {
|
||||
mockClock := clock.NewClock()
|
||||
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
cmd string
|
||||
key string
|
||||
time int
|
||||
expireOpts echovault.EXPIREOptions
|
||||
pexpireOpts echovault.PEXPIREOptions
|
||||
want int
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Set new expire by seconds",
|
||||
cmd: "EXPIRE",
|
||||
key: "key1",
|
||||
time: 100,
|
||||
expireOpts: echovault.EXPIREOptions{},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key1": {Value: "value1", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set new expire by milliseconds",
|
||||
cmd: "PEXPIRE",
|
||||
key: "key2",
|
||||
time: 1000,
|
||||
pexpireOpts: echovault.PEXPIREOptions{},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key2": {Value: "value2", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set new expire only when key does not have an expiry time with NX flag",
|
||||
cmd: "EXPIRE",
|
||||
key: "key3",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{NX: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key3": {Value: "value3", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when NX flag is provided and key already has an expiry time",
|
||||
cmd: "EXPIRE",
|
||||
key: "key4",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{NX: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key4": {Value: "value4", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set new expire time from now key only when the key already has an expiry time with XX flag",
|
||||
cmd: "EXPIRE",
|
||||
key: "key5",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{XX: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key5": {Value: "value5", ExpireAt: mockClock.Now().Add(30 * time.Second)},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when key does not have an expiry and the XX flag is provided",
|
||||
cmd: "EXPIRE",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{XX: true},
|
||||
key: "key6",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key6": {Value: "value6", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set expiry time when the provided time is after the current expiry time when GT flag is provided",
|
||||
cmd: "EXPIRE",
|
||||
key: "key7",
|
||||
time: 100000,
|
||||
expireOpts: echovault.EXPIREOptions{GT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key7": {Value: "value7", ExpireAt: mockClock.Now().Add(30 * time.Second)},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when GT flag is passed and current expiry time is greater than provided time",
|
||||
cmd: "EXPIRE",
|
||||
key: "key8",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{GT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key8": {Value: "value8", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when GT flag is passed and key does not have an expiry time",
|
||||
cmd: "EXPIRE",
|
||||
key: "key9",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{GT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key9": {Value: "value9", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set expiry time when the provided time is before the current expiry time when LT flag is provided",
|
||||
cmd: "EXPIRE",
|
||||
key: "key10",
|
||||
time: 1000,
|
||||
expireOpts: echovault.EXPIREOptions{LT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key10": {Value: "value10", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when LT flag is passed and current expiry time is less than provided time",
|
||||
cmd: "EXPIRE",
|
||||
key: "key11",
|
||||
time: 50000,
|
||||
expireOpts: echovault.EXPIREOptions{LT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key11": {Value: "value11", ExpireAt: mockClock.Now().Add(30 * time.Second)},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
var got int
|
||||
var err error
|
||||
if strings.EqualFold(tt.cmd, "PEXPIRE") {
|
||||
got, err = server.PEXPIRE(tt.key, tt.time, tt.pexpireOpts)
|
||||
} else {
|
||||
got, err = server.EXPIRE(tt.key, tt.time, tt.expireOpts)
|
||||
}
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("(P)EXPIRE() error = %v, wantErr %v, key %s", err, tt.wantErr, tt.key)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("(P)EXPIRE() got = %v, want %v, key %s", got, tt.want, tt.key)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_EXPIREAT(t *testing.T) {
|
||||
mockClock := clock.NewClock()
|
||||
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
cmd string
|
||||
key string
|
||||
time int
|
||||
expireAtOpts echovault.EXPIREATOptions
|
||||
pexpireAtOpts echovault.PEXPIREATOptions
|
||||
want int
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Set new expire by unix seconds",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key1",
|
||||
expireAtOpts: echovault.EXPIREATOptions{},
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key1": {Value: "value1", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set new expire by milliseconds",
|
||||
cmd: "PEXPIREAT",
|
||||
key: "key2",
|
||||
pexpireAtOpts: echovault.PEXPIREATOptions{},
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).UnixMilli()),
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key2": {Value: "value2", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{ // 3.
|
||||
name: "Set new expire only when key does not have an expiry time with NX flag",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key3",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{NX: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key3": {Value: "value3", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0, when NX flag is provided and key already has an expiry time",
|
||||
cmd: "EXPIREAT",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{NX: true},
|
||||
key: "key4",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key4": {Value: "value4", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set new expire time from now key only when the key already has an expiry time with XX flag",
|
||||
cmd: "EXPIREAT",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
key: "key5",
|
||||
expireAtOpts: echovault.EXPIREATOptions{XX: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key5": {Value: "value5", ExpireAt: mockClock.Now().Add(30 * time.Second)},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when key does not have an expiry and the XX flag is provided",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key6",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{XX: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key6": {Value: "value6", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set expiry time when the provided time is after the current expiry time when GT flag is provided",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key7",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{GT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key7": {Value: "value7", ExpireAt: mockClock.Now().Add(30 * time.Second)},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when GT flag is passed and current expiry time is greater than provided time",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key8",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{GT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key8": {Value: "value8", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when GT flag is passed and key does not have an expiry time",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key9",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{GT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key9": {Value: "value9", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 0,
|
||||
},
|
||||
{
|
||||
name: "Set expiry time when the provided time is before the current expiry time when LT flag is provided",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key10",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{LT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key10": {Value: "value10", ExpireAt: mockClock.Now().Add(3000 * time.Second)},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when LT flag is passed and current expiry time is less than provided time",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key11",
|
||||
time: int(mockClock.Now().Add(3000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{LT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key11": {Value: "value11", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
|
||||
},
|
||||
want: 0,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return 0 when LT flag is passed and key does not have an expiry time",
|
||||
cmd: "EXPIREAT",
|
||||
key: "key12",
|
||||
time: int(mockClock.Now().Add(1000 * time.Second).Unix()),
|
||||
expireAtOpts: echovault.EXPIREATOptions{LT: true},
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key12": {Value: "value12", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: 1,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
var got int
|
||||
var err error
|
||||
if strings.EqualFold(tt.cmd, "PEXPIREAT") {
|
||||
got, err = server.PEXPIREAT(tt.key, tt.time, tt.pexpireAtOpts)
|
||||
} else {
|
||||
got, err = server.EXPIREAT(tt.key, tt.time, tt.expireAtOpts)
|
||||
}
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("(P)EXPIREAT() error = %v, wantErr %v, KEY %s", err, tt.wantErr, tt.key)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("(P)EXPIREAT() got = %v, want %v, KEY %s", got, tt.want, tt.key)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_EXPIRETIME(t *testing.T) {
|
||||
mockClock := clock.NewClock()
|
||||
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
key string
|
||||
expiretimeFunc func(key string) (int, error)
|
||||
want int
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Return expire time in seconds",
|
||||
key: "key1",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key1": {Value: "value1", ExpireAt: mockClock.Now().Add(100 * time.Second)},
|
||||
},
|
||||
expiretimeFunc: server.EXPIRETIME,
|
||||
want: int(mockClock.Now().Add(100 * time.Second).Unix()),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return expire time in milliseconds",
|
||||
key: "key2",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key2": {Value: "value2", ExpireAt: mockClock.Now().Add(4096 * time.Millisecond)},
|
||||
},
|
||||
expiretimeFunc: server.PEXPIRETIME,
|
||||
want: int(mockClock.Now().Add(4096 * time.Millisecond).UnixMilli()),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "If the key is non-volatile, return -1",
|
||||
key: "key3",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key3": {Value: "value3", ExpireAt: time.Time{}},
|
||||
},
|
||||
expiretimeFunc: server.PEXPIRETIME,
|
||||
want: -1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "If the key is non-existent return -2",
|
||||
presetValues: nil,
|
||||
expiretimeFunc: server.PEXPIRETIME,
|
||||
want: -2,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
got, err := tt.expiretimeFunc(tt.key)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("(P)EXPIRETIME() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("(P)EXPIRETIME() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_GET(t *testing.T) {
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValue interface{}
|
||||
key string
|
||||
want string
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Return string from existing key",
|
||||
presetValue: "value1",
|
||||
key: "key1",
|
||||
want: "value1",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return empty string if the key does not exist",
|
||||
presetValue: nil,
|
||||
key: "key2",
|
||||
want: "",
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValue != nil {
|
||||
err := presetValue(server, context.Background(), tt.key, tt.presetValue)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
got, err := server.GET(tt.key)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("GET() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("GET() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_MGET(t *testing.T) {
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]interface{}
|
||||
keys []string
|
||||
want []string
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Get all values in the same order the keys were provided in",
|
||||
presetValues: map[string]interface{}{"key1": "value1", "key2": "value2", "key3": "value3", "key4": "value4"},
|
||||
keys: []string{"key1", "key4", "key2", "key3", "key1"},
|
||||
want: []string{"value1", "value4", "value2", "value3", "value1"},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return empty strings for non-existent keys",
|
||||
presetValues: map[string]interface{}{"key5": "value5", "key6": "value6", "key7": "value7"},
|
||||
keys: []string{"key5", "key6", "non-existent", "non-existent", "key7", "non-existent"},
|
||||
want: []string{"value5", "value6", "", "", "value7", ""},
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, v := range tt.presetValues {
|
||||
err := presetValue(server, context.Background(), k, v)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
got, err := server.MGET(tt.keys...)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("MGET() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if len(got) != len(tt.want) {
|
||||
t.Errorf("MGET() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
for _, g := range got {
|
||||
if !slices.Contains(tt.want, g) {
|
||||
t.Errorf("MGET() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("MGET() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_SET(t *testing.T) {
|
||||
mockClock := clock.NewClock()
|
||||
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
key string
|
||||
value string
|
||||
options echovault.SETOptions
|
||||
want string
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Set normal value",
|
||||
presetValues: nil,
|
||||
key: "key1",
|
||||
value: "value1",
|
||||
options: echovault.SETOptions{},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Only set the value if the key does not exist",
|
||||
presetValues: nil,
|
||||
key: "key2",
|
||||
value: "value2",
|
||||
options: echovault.SETOptions{NX: true},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Throw error when value already exists with NX flag passed",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key3": {
|
||||
Value: "preset-value3",
|
||||
ExpireAt: time.Time{},
|
||||
},
|
||||
},
|
||||
key: "key3",
|
||||
value: "value3",
|
||||
options: echovault.SETOptions{NX: true},
|
||||
want: "",
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "Set new key value when key exists with XX flag passed",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key4": {
|
||||
Value: "preset-value4",
|
||||
ExpireAt: time.Time{},
|
||||
},
|
||||
},
|
||||
key: "key4",
|
||||
value: "value4",
|
||||
options: echovault.SETOptions{XX: true},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return error when setting non-existent key with XX flag",
|
||||
presetValues: nil,
|
||||
key: "key5",
|
||||
value: "value5",
|
||||
options: echovault.SETOptions{XX: true},
|
||||
want: "",
|
||||
wantErr: true,
|
||||
},
|
||||
{
|
||||
name: "Set expiry time on the key to 100 seconds from now",
|
||||
presetValues: nil,
|
||||
key: "key6",
|
||||
value: "value6",
|
||||
options: echovault.SETOptions{EX: 100},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set expiry time on the key in unix milliseconds",
|
||||
presetValues: nil,
|
||||
key: "key7",
|
||||
value: "value7",
|
||||
options: echovault.SETOptions{PX: 4096},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set exact expiry time in seconds from unix epoch",
|
||||
presetValues: nil,
|
||||
key: "key8",
|
||||
value: "value8",
|
||||
options: echovault.SETOptions{EXAT: int(mockClock.Now().Add(200 * time.Second).Unix())},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Set exact expiry time in milliseconds from unix epoch",
|
||||
key: "key9",
|
||||
value: "value9",
|
||||
options: echovault.SETOptions{PXAT: int(mockClock.Now().Add(4096 * time.Millisecond).UnixMilli())},
|
||||
presetValues: nil,
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Get the previous value when GET flag is passed",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key10": {
|
||||
Value: "previous-value",
|
||||
ExpireAt: time.Time{},
|
||||
},
|
||||
},
|
||||
key: "key10",
|
||||
value: "value10",
|
||||
options: echovault.SETOptions{GET: true, EX: 1000},
|
||||
want: "previous-value",
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return nil when GET value is passed and no previous value exists",
|
||||
presetValues: nil,
|
||||
key: "key11",
|
||||
value: "value11",
|
||||
options: echovault.SETOptions{GET: true, EX: 1000},
|
||||
want: "",
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
got, err := server.SET(tt.key, tt.value, tt.options)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("SET() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("SET() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_MSET(t *testing.T) {
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
kvPairs map[string]string
|
||||
want string
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Set multiple keys",
|
||||
kvPairs: map[string]string{"key1": "value1", "key2": "10", "key3": "3.142"},
|
||||
want: "OK",
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := server.MSET(tt.kvPairs)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("MSET() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("MSET() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_PERSIST(t *testing.T) {
|
||||
mockClock := clock.NewClock()
|
||||
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
key string
|
||||
want bool
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Successfully persist a volatile key",
|
||||
key: "key1",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key1": {Value: "value1", ExpireAt: mockClock.Now().Add(1000 * time.Second)},
|
||||
},
|
||||
want: true,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return false when trying to persist a non-existent key",
|
||||
key: "key2",
|
||||
presetValues: nil,
|
||||
want: false,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return false when trying to persist a non-volatile key",
|
||||
key: "key3",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key3": {Value: "value3", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: false,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
got, err := server.PERSIST(tt.key)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("PERSIST() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("PERSIST() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEchoVault_TTL(t *testing.T) {
|
||||
mockClock := clock.NewClock()
|
||||
|
||||
server := createEchoVault()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
presetValues map[string]internal.KeyData
|
||||
key string
|
||||
ttlFunc func(key string) (int, error)
|
||||
want int
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Return TTL time in seconds",
|
||||
key: "key1",
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key1": {Value: "value1", ExpireAt: mockClock.Now().Add(100 * time.Second)},
|
||||
},
|
||||
ttlFunc: server.TTL,
|
||||
want: 100,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Return TTL time in milliseconds",
|
||||
key: "key2",
|
||||
ttlFunc: server.PTTL,
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key2": {Value: "value2", ExpireAt: mockClock.Now().Add(4096 * time.Millisecond)},
|
||||
},
|
||||
want: 4096,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "If the key is non-volatile, return -1",
|
||||
key: "key3",
|
||||
ttlFunc: server.TTL,
|
||||
presetValues: map[string]internal.KeyData{
|
||||
"key3": {Value: "value3", ExpireAt: time.Time{}},
|
||||
},
|
||||
want: -1,
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "If the key is non-existent return -2",
|
||||
key: "key4",
|
||||
ttlFunc: server.TTL,
|
||||
presetValues: nil,
|
||||
want: -2,
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if tt.presetValues != nil {
|
||||
for k, d := range tt.presetValues {
|
||||
presetKeyData(server, context.Background(), k, d)
|
||||
}
|
||||
}
|
||||
got, err := tt.ttlFunc(tt.key)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("TTL() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("TTL() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user