diff --git a/Makefile b/Makefile index 7b76abb..5bd7f5d 100644 --- a/Makefile +++ b/Makefile @@ -7,7 +7,7 @@ build: run: make build && docker-compose up --build -test-normal: +test-unit: go clean -testcache && go test ./... -coverprofile coverage/coverage.out test-race: diff --git a/cmd/main.go b/cmd/main.go index 7719d87..d0ce2c0 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -18,7 +18,6 @@ import ( "context" "github.com/echovault/echovault/internal" "github.com/echovault/echovault/internal/config" - "github.com/echovault/echovault/pkg/commands" "github.com/echovault/echovault/pkg/echovault" "log" "os" @@ -49,7 +48,6 @@ func main() { server, err := echovault.NewEchoVault( echovault.WithContext(ctx), echovault.WithConfig(conf), - echovault.WithCommands(commands.All()), ) if err != nil { diff --git a/internal/acl/acl.go b/internal/modules/acl/acl.go similarity index 100% rename from internal/acl/acl.go rename to internal/modules/acl/acl.go diff --git a/pkg/modules/acl/commands.go b/internal/modules/acl/commands.go similarity index 96% rename from pkg/modules/acl/commands.go rename to internal/modules/acl/commands.go index 68e05ba..1f86bae 100644 --- a/pkg/modules/acl/commands.go +++ b/internal/modules/acl/commands.go @@ -18,7 +18,6 @@ import ( "encoding/json" "errors" "fmt" - internal_acl "github.com/echovault/echovault/internal/acl" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/types" "gopkg.in/yaml.v3" @@ -33,7 +32,7 @@ func handleAuth(params types.HandlerFuncParams) ([]byte, error) { if len(params.Command) < 2 || len(params.Command) > 3 { return nil, errors.New(constants.WrongArgsResponse) } - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -48,12 +47,12 @@ func handleGetUser(params types.HandlerFuncParams) ([]byte, error) { return nil, errors.New(constants.WrongArgsResponse) } - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } - var user *internal_acl.User + var user *User userFound := false for _, u := range acl.Users { if u.Username == params.Command[2] { @@ -221,7 +220,7 @@ func handleCat(params types.HandlerFuncParams) ([]byte, error) { } func handleUsers(params types.HandlerFuncParams) ([]byte, error) { - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -234,7 +233,7 @@ func handleUsers(params types.HandlerFuncParams) ([]byte, error) { } func handleSetUser(params types.HandlerFuncParams) ([]byte, error) { - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -248,7 +247,7 @@ func handleDelUser(params types.HandlerFuncParams) ([]byte, error) { if len(params.Command) < 3 { return nil, errors.New(constants.WrongArgsResponse) } - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -259,7 +258,7 @@ func handleDelUser(params types.HandlerFuncParams) ([]byte, error) { } func handleWhoAmI(params types.HandlerFuncParams) ([]byte, error) { - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -271,7 +270,7 @@ func handleList(params types.HandlerFuncParams) ([]byte, error) { if len(params.Command) > 2 { return nil, errors.New(constants.WrongArgsResponse) } - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -368,7 +367,7 @@ func handleLoad(params types.HandlerFuncParams) ([]byte, error) { return nil, errors.New(constants.WrongArgsResponse) } - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } @@ -389,7 +388,7 @@ func handleLoad(params types.HandlerFuncParams) ([]byte, error) { ext := path.Ext(f.Name()) - var users []*internal_acl.User + var users []*User if ext == ".json" { if err := json.NewDecoder(f).Decode(&users); err != nil { @@ -435,7 +434,7 @@ func handleSave(params types.HandlerFuncParams) ([]byte, error) { return nil, errors.New(constants.WrongArgsResponse) } - acl, ok := params.GetACL().(*internal_acl.ACL) + acl, ok := params.GetACL().(*ACL) if !ok { return nil, errors.New("could not load ACL") } diff --git a/internal/acl/user.go b/internal/modules/acl/user.go similarity index 100% rename from internal/acl/user.go rename to internal/modules/acl/user.go diff --git a/pkg/modules/admin/commands.go b/internal/modules/admin/commands.go similarity index 100% rename from pkg/modules/admin/commands.go rename to internal/modules/admin/commands.go diff --git a/pkg/modules/connection/commands.go b/internal/modules/connection/commands.go similarity index 100% rename from pkg/modules/connection/commands.go rename to internal/modules/connection/commands.go diff --git a/pkg/modules/generic/commands.go b/internal/modules/generic/commands.go similarity index 100% rename from pkg/modules/generic/commands.go rename to internal/modules/generic/commands.go diff --git a/pkg/modules/generic/key_funcs.go b/internal/modules/generic/key_funcs.go similarity index 100% rename from pkg/modules/generic/key_funcs.go rename to internal/modules/generic/key_funcs.go diff --git a/pkg/modules/generic/utils.go b/internal/modules/generic/utils.go similarity index 100% rename from pkg/modules/generic/utils.go rename to internal/modules/generic/utils.go diff --git a/pkg/modules/hash/commands.go b/internal/modules/hash/commands.go similarity index 100% rename from pkg/modules/hash/commands.go rename to internal/modules/hash/commands.go diff --git a/pkg/modules/hash/key_funcs.go b/internal/modules/hash/key_funcs.go similarity index 100% rename from pkg/modules/hash/key_funcs.go rename to internal/modules/hash/key_funcs.go diff --git a/pkg/modules/list/commands.go b/internal/modules/list/commands.go similarity index 100% rename from pkg/modules/list/commands.go rename to internal/modules/list/commands.go diff --git a/pkg/modules/list/key_funcs.go b/internal/modules/list/key_funcs.go similarity index 100% rename from pkg/modules/list/key_funcs.go rename to internal/modules/list/key_funcs.go diff --git a/internal/pubsub/channel.go b/internal/modules/pubsub/channel.go similarity index 100% rename from internal/pubsub/channel.go rename to internal/modules/pubsub/channel.go diff --git a/pkg/modules/pubsub/commands.go b/internal/modules/pubsub/commands.go similarity index 95% rename from pkg/modules/pubsub/commands.go rename to internal/modules/pubsub/commands.go index e8c0f79..0d876b3 100644 --- a/pkg/modules/pubsub/commands.go +++ b/internal/modules/pubsub/commands.go @@ -17,14 +17,13 @@ package pubsub import ( "errors" "fmt" - internal_pubsub "github.com/echovault/echovault/internal/pubsub" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/types" "strings" ) func handleSubscribe(params types.HandlerFuncParams) ([]byte, error) { - pubsub, ok := params.GetPubSub().(*internal_pubsub.PubSub) + pubsub, ok := params.GetPubSub().(*PubSub) if !ok { return nil, errors.New("could not load pubsub module") } @@ -42,7 +41,7 @@ func handleSubscribe(params types.HandlerFuncParams) ([]byte, error) { } func handleUnsubscribe(params types.HandlerFuncParams) ([]byte, error) { - pubsub, ok := params.GetPubSub().(*internal_pubsub.PubSub) + pubsub, ok := params.GetPubSub().(*PubSub) if !ok { return nil, errors.New("could not load pubsub module") } @@ -55,7 +54,7 @@ func handleUnsubscribe(params types.HandlerFuncParams) ([]byte, error) { } func handlePublish(params types.HandlerFuncParams) ([]byte, error) { - pubsub, ok := params.GetPubSub().(*internal_pubsub.PubSub) + pubsub, ok := params.GetPubSub().(*PubSub) if !ok { return nil, errors.New("could not load pubsub module") } @@ -71,7 +70,7 @@ func handlePubSubChannels(params types.HandlerFuncParams) ([]byte, error) { return nil, errors.New(constants.WrongArgsResponse) } - pubsub, ok := params.GetPubSub().(*internal_pubsub.PubSub) + pubsub, ok := params.GetPubSub().(*PubSub) if !ok { return nil, errors.New("could not load pubsub module") } @@ -85,7 +84,7 @@ func handlePubSubChannels(params types.HandlerFuncParams) ([]byte, error) { } func handlePubSubNumPat(params types.HandlerFuncParams) ([]byte, error) { - pubsub, ok := params.GetPubSub().(*internal_pubsub.PubSub) + pubsub, ok := params.GetPubSub().(*PubSub) if !ok { return nil, errors.New("could not load pubsub module") } @@ -94,7 +93,7 @@ func handlePubSubNumPat(params types.HandlerFuncParams) ([]byte, error) { } func handlePubSubNumSubs(params types.HandlerFuncParams) ([]byte, error) { - pubsub, ok := params.GetPubSub().(*internal_pubsub.PubSub) + pubsub, ok := params.GetPubSub().(*PubSub) if !ok { return nil, errors.New("could not load pubsub module") } diff --git a/internal/pubsub/pubsub.go b/internal/modules/pubsub/pubsub.go similarity index 100% rename from internal/pubsub/pubsub.go rename to internal/modules/pubsub/pubsub.go diff --git a/pkg/modules/set/commands.go b/internal/modules/set/commands.go similarity index 92% rename from pkg/modules/set/commands.go rename to internal/modules/set/commands.go index f7f4c72..88abedf 100644 --- a/pkg/modules/set/commands.go +++ b/internal/modules/set/commands.go @@ -18,7 +18,6 @@ import ( "errors" "fmt" "github.com/echovault/echovault/internal" - internal_set "github.com/echovault/echovault/internal/set" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/types" "slices" @@ -33,10 +32,10 @@ func handleSADD(params types.HandlerFuncParams) ([]byte, error) { key := keys.WriteKeys[0] - var set *internal_set.Set + var set *Set if !params.KeyExists(params.Context, key) { - set = internal_set.NewSet(params.Command[2:]) + set = NewSet(params.Command[2:]) if ok, err := params.CreateKeyAndLock(params.Context, key); !ok && err != nil { return nil, err } @@ -52,7 +51,7 @@ func handleSADD(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } @@ -79,7 +78,7 @@ func handleSCARD(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } @@ -103,7 +102,7 @@ func handleSDIFF(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyRUnlock(params.Context, keys.ReadKeys[0]) - baseSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*internal_set.Set) + baseSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", keys.ReadKeys[0]) } @@ -127,9 +126,9 @@ func handleSDIFF(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for _, key := range params.Command[2:] { - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { continue } @@ -166,7 +165,7 @@ func handleSDIFFSTORE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyRUnlock(params.Context, keys.ReadKeys[0]) - baseSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*internal_set.Set) + baseSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", keys.ReadKeys[0]) } @@ -190,9 +189,9 @@ func handleSDIFFSTORE(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for _, key := range keys.ReadKeys[1:] { - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { continue } @@ -252,10 +251,10 @@ func handleSINTER(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for key, _ := range locks { - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { // If the value at the key is not a set, return error return nil, fmt.Errorf("value at key %s is not a set", key) @@ -267,7 +266,7 @@ func handleSINTER(params types.HandlerFuncParams) ([]byte, error) { return nil, fmt.Errorf("not enough sets in the keys provided") } - intersect, _ := internal_set.Intersection(0, sets...) + intersect, _ := Intersection(0, sets...) elems := intersect.GetAll() res := fmt.Sprintf("*%d", len(elems)) @@ -328,10 +327,10 @@ func handleSINTERCARD(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for key, _ := range locks { - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { // If the value at the key is not a set, return error return nil, fmt.Errorf("value at key %s is not a set", key) @@ -343,7 +342,7 @@ func handleSINTERCARD(params types.HandlerFuncParams) ([]byte, error) { return nil, fmt.Errorf("not enough sets in the keys provided") } - intersect, _ := internal_set.Intersection(limit, sets...) + intersect, _ := Intersection(limit, sets...) return []byte(fmt.Sprintf(":%d\r\n", intersect.Cardinality())), nil } @@ -374,10 +373,10 @@ func handleSINTERSTORE(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for key, _ := range locks { - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { // If the value at the key is not a set, return error return nil, fmt.Errorf("value at key %s is not a set", key) @@ -385,7 +384,7 @@ func handleSINTERSTORE(params types.HandlerFuncParams) ([]byte, error) { sets = append(sets, set) } - intersect, _ := internal_set.Intersection(0, sets...) + intersect, _ := Intersection(0, sets...) destination := keys.WriteKeys[0] if params.KeyExists(params.Context, destination) { @@ -423,7 +422,7 @@ func handleSISMEMBER(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } @@ -452,7 +451,7 @@ func handleSMEMBERS(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } @@ -495,7 +494,7 @@ func handleSMISMEMBER(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } @@ -531,12 +530,12 @@ func handleSMOVE(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, source) - sourceSet, ok := params.GetValue(params.Context, source).(*internal_set.Set) + sourceSet, ok := params.GetValue(params.Context, source).(*Set) if !ok { return nil, errors.New("source is not a set") } - var destinationSet *internal_set.Set + var destinationSet *Set if !params.KeyExists(params.Context, destination) { // Destination key does not exist @@ -544,7 +543,7 @@ func handleSMOVE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyUnlock(params.Context, destination) - destinationSet = internal_set.NewSet([]string{}) + destinationSet = NewSet([]string{}) if err = params.SetValue(params.Context, destination, destinationSet); err != nil { return nil, err } @@ -554,7 +553,7 @@ func handleSMOVE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyUnlock(params.Context, destination) - ds, ok := params.GetValue(params.Context, destination).(*internal_set.Set) + ds, ok := params.GetValue(params.Context, destination).(*Set) if !ok { return nil, errors.New("destination is not a set") } @@ -592,7 +591,7 @@ func handleSPOP(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at %s is not a set", key) } @@ -636,7 +635,7 @@ func handleSRANDMEMBER(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at %s is not a set", key) } @@ -672,7 +671,7 @@ func handleSREM(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } @@ -707,20 +706,20 @@ func handleSUNION(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for key, locked := range locks { if !locked { continue } - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } sets = append(sets, set) } - union := internal_set.Union(sets...) + union := Union(sets...) res := fmt.Sprintf("*%d", union.Cardinality()) for i, e := range union.GetAll() { @@ -758,20 +757,20 @@ func handleSUNIONSTORE(params types.HandlerFuncParams) ([]byte, error) { locks[key] = true } - var sets []*internal_set.Set + var sets []*Set for key, locked := range locks { if !locked { continue } - set, ok := params.GetValue(params.Context, key).(*internal_set.Set) + set, ok := params.GetValue(params.Context, key).(*Set) if !ok { return nil, fmt.Errorf("value at key %s is not a set", key) } sets = append(sets, set) } - union := internal_set.Union(sets...) + union := Union(sets...) destination := keys.WriteKeys[0] diff --git a/pkg/modules/set/key_funcs.go b/internal/modules/set/key_funcs.go similarity index 100% rename from pkg/modules/set/key_funcs.go rename to internal/modules/set/key_funcs.go diff --git a/internal/set/set.go b/internal/modules/set/set.go similarity index 100% rename from internal/set/set.go rename to internal/modules/set/set.go diff --git a/pkg/modules/sorted_set/commands.go b/internal/modules/sorted_set/commands.go similarity index 91% rename from pkg/modules/sorted_set/commands.go rename to internal/modules/sorted_set/commands.go index d892fe4..27a8656 100644 --- a/pkg/modules/sorted_set/commands.go +++ b/internal/modules/sorted_set/commands.go @@ -19,7 +19,6 @@ import ( "errors" "fmt" "github.com/echovault/echovault/internal" - "github.com/echovault/echovault/internal/sorted_set" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/types" "math" @@ -63,7 +62,7 @@ func handleZADD(params types.HandlerFuncParams) ([]byte, error) { return nil, errors.New("score/member pairs must be float/string") } - var members []sorted_set.MemberParam + var members []MemberParam for i := 0; i < len(params.Command[membersStartIndex:]); i++ { if i%2 != 0 { @@ -77,29 +76,29 @@ func handleZADD(params types.HandlerFuncParams) ([]byte, error) { var s float64 if strings.ToLower(score.(string)) == "-inf" { s = math.Inf(-1) - members = append(members, sorted_set.MemberParam{ - Value: sorted_set.Value(params.Command[membersStartIndex:][i+1]), - Score: sorted_set.Score(s), + members = append(members, MemberParam{ + Value: Value(params.Command[membersStartIndex:][i+1]), + Score: Score(s), }) } if strings.ToLower(score.(string)) == "+inf" { s = math.Inf(1) - members = append(members, sorted_set.MemberParam{ - Value: sorted_set.Value(params.Command[membersStartIndex:][i+1]), - Score: sorted_set.Score(s), + members = append(members, MemberParam{ + Value: Value(params.Command[membersStartIndex:][i+1]), + Score: Score(s), }) } case float64: s, _ := score.(float64) - members = append(members, sorted_set.MemberParam{ - Value: sorted_set.Value(params.Command[membersStartIndex:][i+1]), - Score: sorted_set.Score(s), + members = append(members, MemberParam{ + Value: Value(params.Command[membersStartIndex:][i+1]), + Score: Score(s), }) case int: s, _ := score.(int) - members = append(members, sorted_set.MemberParam{ - Value: sorted_set.Value(params.Command[membersStartIndex:][i+1]), - Score: sorted_set.Score(s), + members = append(members, MemberParam{ + Value: Value(params.Command[membersStartIndex:][i+1]), + Score: Score(s), }) } } @@ -148,7 +147,7 @@ func handleZADD(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -171,7 +170,7 @@ func handleZADD(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set := sorted_set.NewSortedSet(members) + set := NewSortedSet(members) if err = params.SetValue(params.Context, key, set); err != nil { return nil, err } @@ -195,7 +194,7 @@ func handleZCARD(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -211,40 +210,40 @@ func handleZCOUNT(params types.HandlerFuncParams) ([]byte, error) { key := keys.ReadKeys[0] - minimum := sorted_set.Score(math.Inf(-1)) + minimum := Score(math.Inf(-1)) switch internal.AdaptType(params.Command[2]).(type) { default: return nil, errors.New("min constraint must be a double") case string: if strings.ToLower(params.Command[2]) == "+inf" { - minimum = sorted_set.Score(math.Inf(1)) + minimum = Score(math.Inf(1)) } else { return nil, errors.New("min constraint must be a double") } case float64: s, _ := internal.AdaptType(params.Command[2]).(float64) - minimum = sorted_set.Score(s) + minimum = Score(s) case int: s, _ := internal.AdaptType(params.Command[2]).(int) - minimum = sorted_set.Score(s) + minimum = Score(s) } - maximum := sorted_set.Score(math.Inf(1)) + maximum := Score(math.Inf(1)) switch internal.AdaptType(params.Command[3]).(type) { default: return nil, errors.New("max constraint must be a double") case string: if strings.ToLower(params.Command[3]) == "-inf" { - maximum = sorted_set.Score(math.Inf(-1)) + maximum = Score(math.Inf(-1)) } else { return nil, errors.New("max constraint must be a double") } case float64: s, _ := internal.AdaptType(params.Command[3]).(float64) - maximum = sorted_set.Score(s) + maximum = Score(s) case int: s, _ := internal.AdaptType(params.Command[3]).(int) - maximum = sorted_set.Score(s) + maximum = Score(s) } if !params.KeyExists(params.Context, key) { @@ -256,12 +255,12 @@ func handleZCOUNT(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } - var members []sorted_set.MemberParam + var members []MemberParam for _, m := range set.GetAll() { if m.Score >= minimum && m.Score <= maximum { members = append(members, m) @@ -290,7 +289,7 @@ func handleZLEXCOUNT(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -347,13 +346,13 @@ func handleZDIFF(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyRUnlock(params.Context, keys.ReadKeys[0]) - baseSortedSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*sorted_set.SortedSet) + baseSortedSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys.ReadKeys[0]) } // Extract the remaining sets - var sets []*sorted_set.SortedSet + var sets []*SortedSet for i := 1; i < len(keys.ReadKeys); i++ { if !params.KeyExists(params.Context, keys.ReadKeys[i]) { @@ -364,7 +363,7 @@ func handleZDIFF(params types.HandlerFuncParams) ([]byte, error) { return nil, err } locks[keys.ReadKeys[i]] = locked - set, ok := params.GetValue(params.Context, keys.ReadKeys[i]).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, keys.ReadKeys[i]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys.ReadKeys[i]) } @@ -415,19 +414,19 @@ func handleZDIFFSTORE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyRUnlock(params.Context, keys.ReadKeys[0]) - baseSortedSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*sorted_set.SortedSet) + baseSortedSet, ok := params.GetValue(params.Context, keys.ReadKeys[0]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys.ReadKeys[0]) } - var sets []*sorted_set.SortedSet + var sets []*SortedSet for i := 1; i < len(keys.ReadKeys); i++ { if params.KeyExists(params.Context, keys.ReadKeys[i]) { if _, err = params.KeyRLock(params.Context, keys.ReadKeys[i]); err != nil { return nil, err } - set, ok := params.GetValue(params.Context, keys.ReadKeys[i]).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, keys.ReadKeys[i]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys.ReadKeys[i]) } @@ -462,26 +461,26 @@ func handleZINCRBY(params types.HandlerFuncParams) ([]byte, error) { } key := keys.WriteKeys[0] - member := sorted_set.Value(params.Command[3]) - var increment sorted_set.Score + member := Value(params.Command[3]) + var increment Score switch internal.AdaptType(params.Command[2]).(type) { default: return nil, errors.New("increment must be a double") case string: if strings.EqualFold("-inf", strings.ToLower(params.Command[2])) { - increment = sorted_set.Score(math.Inf(-1)) + increment = Score(math.Inf(-1)) } else if strings.EqualFold("+inf", strings.ToLower(params.Command[2])) { - increment = sorted_set.Score(math.Inf(1)) + increment = Score(math.Inf(1)) } else { return nil, errors.New("increment must be a double") } case float64: s, _ := internal.AdaptType(params.Command[2]).(float64) - increment = sorted_set.Score(s) + increment = Score(s) case int: s, _ := internal.AdaptType(params.Command[2]).(int) - increment = sorted_set.Score(s) + increment = Score(s) } if !params.KeyExists(params.Context, key) { @@ -493,7 +492,7 @@ func handleZINCRBY(params types.HandlerFuncParams) ([]byte, error) { if err = params.SetValue( params.Context, key, - sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: member, Score: increment}}), + NewSortedSet([]MemberParam{{Value: member, Score: increment}}), ); err != nil { return nil, err } @@ -505,12 +504,12 @@ func handleZINCRBY(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } if _, err = set.AddOrUpdate( - []sorted_set.MemberParam{ + []MemberParam{ {Value: member, Score: increment}}, "xx", nil, @@ -542,7 +541,7 @@ func handleZINTER(params types.HandlerFuncParams) ([]byte, error) { } }() - var setParams []sorted_set.SortedSetParam + var setParams []SortedSetParam for i := 0; i < len(keys); i++ { if !params.KeyExists(params.Context, keys[i]) { @@ -553,17 +552,17 @@ func handleZINTER(params types.HandlerFuncParams) ([]byte, error) { return nil, err } locks[keys[i]] = true - set, ok := params.GetValue(params.Context, keys[i]).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, keys[i]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys[i]) } - setParams = append(setParams, sorted_set.SortedSetParam{ + setParams = append(setParams, SortedSetParam{ Set: set, Weight: weights[i], }) } - intersect := sorted_set.Intersect(aggregate, setParams...) + intersect := Intersect(aggregate, setParams...) res := fmt.Sprintf("*%d", intersect.Cardinality()) @@ -609,7 +608,7 @@ func handleZINTERSTORE(params types.HandlerFuncParams) ([]byte, error) { } }() - var setParams []sorted_set.SortedSetParam + var setParams []SortedSetParam for i := 0; i < len(keys); i++ { if !params.KeyExists(params.Context, keys[i]) { @@ -619,17 +618,17 @@ func handleZINTERSTORE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } locks[keys[i]] = true - set, ok := params.GetValue(params.Context, keys[i]).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, keys[i]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys[i]) } - setParams = append(setParams, sorted_set.SortedSetParam{ + setParams = append(setParams, SortedSetParam{ Set: set, Weight: weights[i], }) } - intersect := sorted_set.Intersect(aggregate, setParams...) + intersect := Intersect(aggregate, setParams...) if params.KeyExists(params.Context, destination) && intersect.Cardinality() > 0 { if _, err = params.KeyLock(params.Context, destination); err != nil { @@ -700,7 +699,7 @@ func handleZMPOP(params types.HandlerFuncParams) ([]byte, error) { if _, err = params.KeyLock(params.Context, keys.WriteKeys[i]); err != nil { continue } - v, ok := params.GetValue(params.Context, keys.WriteKeys[i]).(*sorted_set.SortedSet) + v, ok := params.GetValue(params.Context, keys.WriteKeys[i]).(*SortedSet) if !ok || v.Cardinality() == 0 { params.KeyUnlock(params.Context, keys.WriteKeys[i]) continue @@ -760,7 +759,7 @@ func handleZPOP(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at key %s is not a sorted set", key) } @@ -797,7 +796,7 @@ func handleZMSCORE(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -806,10 +805,10 @@ func handleZMSCORE(params types.HandlerFuncParams) ([]byte, error) { res := fmt.Sprintf("*%d", len(members)) - var member sorted_set.MemberObject + var member MemberObject for i := 0; i < len(members); i++ { - member = set.Get(sorted_set.Value(members[i])) + member = set.Get(Value(members[i])) if !member.Exists { res = fmt.Sprintf("%s\r\n$-1", res) } else { @@ -859,7 +858,7 @@ func handleZRANDMEMBER(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -903,13 +902,13 @@ func handleZRANK(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } members := set.GetAll() - slices.SortFunc(members, func(a, b sorted_set.MemberParam) int { + slices.SortFunc(members, func(a, b MemberParam) int { if strings.EqualFold(params.Command[0], "zrevrank") { return cmp.Compare(b.Score, a.Score) } @@ -917,7 +916,7 @@ func handleZRANK(params types.HandlerFuncParams) ([]byte, error) { }) for i := 0; i < len(members); i++ { - if members[i].Value == sorted_set.Value(member) { + if members[i].Value == Value(member) { if withscores { score := strconv.FormatFloat(float64(members[i].Score), 'f', -1, 64) return []byte(fmt.Sprintf("*2\r\n:%d\r\n$%d\r\n%s\r\n", i, len(score), score)), nil @@ -947,14 +946,14 @@ func handleZREM(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } deletedCount := 0 for _, m := range params.Command[2:] { - if set.Remove(sorted_set.Value(m)) { + if set.Remove(Value(m)) { deletedCount += 1 } } @@ -977,11 +976,11 @@ func handleZSCORE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } - member := set.Get(sorted_set.Value(params.Command[2])) + member := set.Get(Value(params.Command[2])) if !member.Exists { return []byte("$-1\r\n"), nil } @@ -1020,13 +1019,13 @@ func handleZREMRANGEBYSCORE(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } for _, m := range set.GetAll() { - if m.Score >= sorted_set.Score(minimum) && m.Score <= sorted_set.Score(maximum) { + if m.Score >= Score(minimum) && m.Score <= Score(maximum) { set.Remove(m.Value) deletedCount += 1 } @@ -1062,7 +1061,7 @@ func handleZREMRANGEBYRANK(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -1079,7 +1078,7 @@ func handleZREMRANGEBYRANK(params types.HandlerFuncParams) ([]byte, error) { } members := set.GetAll() - slices.SortFunc(members, func(a, b sorted_set.MemberParam) int { + slices.SortFunc(members, func(a, b MemberParam) int { return cmp.Compare(a.Score, b.Score) }) @@ -1119,7 +1118,7 @@ func handleZREMRANGEBYLEX(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -1217,7 +1216,7 @@ func handleZRANGE(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, key) - set, ok := params.GetValue(params.Context, key).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, key).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", key) } @@ -1231,7 +1230,7 @@ func handleZRANGE(params types.HandlerFuncParams) ([]byte, error) { members := set.GetAll() if strings.EqualFold(policy, "byscore") { - slices.SortFunc(members, func(a, b sorted_set.MemberParam) int { + slices.SortFunc(members, func(a, b MemberParam) int { // Do a score sort if reverse { return cmp.Compare(b.Score, a.Score) @@ -1246,7 +1245,7 @@ func handleZRANGE(params types.HandlerFuncParams) ([]byte, error) { return []byte("*0\r\n"), nil } } - slices.SortFunc(members, func(a, b sorted_set.MemberParam) int { + slices.SortFunc(members, func(a, b MemberParam) int { if reverse { return internal.CompareLex(string(b.Value), string(a.Value)) } @@ -1254,14 +1253,14 @@ func handleZRANGE(params types.HandlerFuncParams) ([]byte, error) { }) } - var resultMembers []sorted_set.MemberParam + var resultMembers []MemberParam for i := offset; i <= count; i++ { if i >= len(members) { break } if strings.EqualFold(policy, "byscore") { - if members[i].Score >= sorted_set.Score(scoreStart) && members[i].Score <= sorted_set.Score(scoreStop) { + if members[i].Score >= Score(scoreStart) && members[i].Score <= Score(scoreStop) { resultMembers = append(resultMembers, members[i]) } continue @@ -1354,7 +1353,7 @@ func handleZRANGESTORE(params types.HandlerFuncParams) ([]byte, error) { } defer params.KeyRUnlock(params.Context, source) - set, ok := params.GetValue(params.Context, source).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, source).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", source) } @@ -1368,7 +1367,7 @@ func handleZRANGESTORE(params types.HandlerFuncParams) ([]byte, error) { members := set.GetAll() if strings.EqualFold(policy, "byscore") { - slices.SortFunc(members, func(a, b sorted_set.MemberParam) int { + slices.SortFunc(members, func(a, b MemberParam) int { // Do a score sort if reverse { return cmp.Compare(b.Score, a.Score) @@ -1383,7 +1382,7 @@ func handleZRANGESTORE(params types.HandlerFuncParams) ([]byte, error) { return []byte(":0\r\n"), nil } } - slices.SortFunc(members, func(a, b sorted_set.MemberParam) int { + slices.SortFunc(members, func(a, b MemberParam) int { if reverse { return internal.CompareLex(string(b.Value), string(a.Value)) } @@ -1391,14 +1390,14 @@ func handleZRANGESTORE(params types.HandlerFuncParams) ([]byte, error) { }) } - var resultMembers []sorted_set.MemberParam + var resultMembers []MemberParam for i := offset; i <= count; i++ { if i >= len(members) { break } if strings.EqualFold(policy, "byscore") { - if members[i].Score >= sorted_set.Score(scoreStart) && members[i].Score <= sorted_set.Score(scoreStop) { + if members[i].Score >= Score(scoreStart) && members[i].Score <= Score(scoreStop) { resultMembers = append(resultMembers, members[i]) } continue @@ -1409,7 +1408,7 @@ func handleZRANGESTORE(params types.HandlerFuncParams) ([]byte, error) { } } - newSortedSet := sorted_set.NewSortedSet(resultMembers) + newSortedSet := NewSortedSet(resultMembers) if params.KeyExists(params.Context, destination) { if _, err = params.KeyLock(params.Context, destination); err != nil { @@ -1448,7 +1447,7 @@ func handleZUNION(params types.HandlerFuncParams) ([]byte, error) { } }() - var setParams []sorted_set.SortedSetParam + var setParams []SortedSetParam for i := 0; i < len(keys); i++ { if params.KeyExists(params.Context, keys[i]) { @@ -1456,18 +1455,18 @@ func handleZUNION(params types.HandlerFuncParams) ([]byte, error) { return nil, err } locks[keys[i]] = true - set, ok := params.GetValue(params.Context, keys[i]).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, keys[i]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys[i]) } - setParams = append(setParams, sorted_set.SortedSetParam{ + setParams = append(setParams, SortedSetParam{ Set: set, Weight: weights[i], }) } } - union := sorted_set.Union(aggregate, setParams...) + union := Union(aggregate, setParams...) res := fmt.Sprintf("*%d", union.Cardinality()) for _, m := range union.GetAll() { @@ -1510,7 +1509,7 @@ func handleZUNIONSTORE(params types.HandlerFuncParams) ([]byte, error) { } }() - var setParams []sorted_set.SortedSetParam + var setParams []SortedSetParam for i := 0; i < len(keys); i++ { if params.KeyExists(params.Context, keys[i]) { @@ -1518,18 +1517,18 @@ func handleZUNIONSTORE(params types.HandlerFuncParams) ([]byte, error) { return nil, err } locks[keys[i]] = true - set, ok := params.GetValue(params.Context, keys[i]).(*sorted_set.SortedSet) + set, ok := params.GetValue(params.Context, keys[i]).(*SortedSet) if !ok { return nil, fmt.Errorf("value at %s is not a sorted set", keys[i]) } - setParams = append(setParams, sorted_set.SortedSetParam{ + setParams = append(setParams, SortedSetParam{ Set: set, Weight: weights[i], }) } } - union := sorted_set.Union(aggregate, setParams...) + union := Union(aggregate, setParams...) if params.KeyExists(params.Context, destination) { if _, err = params.KeyLock(params.Context, destination); err != nil { diff --git a/pkg/modules/sorted_set/key_funcs.go b/internal/modules/sorted_set/key_funcs.go similarity index 100% rename from pkg/modules/sorted_set/key_funcs.go rename to internal/modules/sorted_set/key_funcs.go diff --git a/internal/sorted_set/sorted_set.go b/internal/modules/sorted_set/sorted_set.go similarity index 100% rename from internal/sorted_set/sorted_set.go rename to internal/modules/sorted_set/sorted_set.go diff --git a/pkg/modules/sorted_set/utils.go b/internal/modules/sorted_set/utils.go similarity index 62% rename from pkg/modules/sorted_set/utils.go rename to internal/modules/sorted_set/utils.go index bde1a24..11638e2 100644 --- a/pkg/modules/sorted_set/utils.go +++ b/internal/modules/sorted_set/utils.go @@ -90,3 +90,80 @@ func extractKeysWeightsAggregateWithScores(cmd []string) ([]string, []int, strin return keys, weights, aggregate, withscores, nil } + +func validateUpdatePolicy(updatePolicy interface{}) (string, error) { + if updatePolicy == nil { + return "", nil + } + err := errors.New("update policy must be a string of Value NX or XX") + policy, ok := updatePolicy.(string) + if !ok { + return "", err + } + if !slices.Contains([]string{"nx", "xx"}, strings.ToLower(policy)) { + return "", err + } + return policy, nil +} + +func validateComparison(comparison interface{}) (string, error) { + if comparison == nil { + return "", nil + } + err := errors.New("comparison condition must be a string of Value LT or GT") + comp, ok := comparison.(string) + if !ok { + return "", err + } + if !slices.Contains([]string{"lt", "gt"}, strings.ToLower(comp)) { + return "", err + } + return comp, nil +} + +func validateChanged(changed interface{}) (string, error) { + if changed == nil { + return "", nil + } + err := errors.New("changed condition should be a string of Value CH") + ch, ok := changed.(string) + if !ok { + return "", err + } + if !strings.EqualFold(ch, "ch") { + return "", err + } + return ch, nil +} + +func validateIncr(incr interface{}) (string, error) { + if incr == nil { + return "", nil + } + err := errors.New("incr condition should be a string of Value INCR") + i, ok := incr.(string) + if !ok { + return "", err + } + if !strings.EqualFold(i, "incr") { + return "", err + } + return i, nil +} + +func compareScores(old Score, new Score, comp string) Score { + switch strings.ToLower(comp) { + default: + return new + case "lt": + if new < old { + return new + } + return old + case "gt": + if new > old { + return new + } + return old + } +} diff --git a/pkg/modules/string/commands.go b/internal/modules/string/commands.go similarity index 100% rename from pkg/modules/string/commands.go rename to internal/modules/string/commands.go diff --git a/pkg/modules/string/key_funcs.go b/internal/modules/string/key_funcs.go similarity index 100% rename from pkg/modules/string/key_funcs.go rename to internal/modules/string/key_funcs.go diff --git a/internal/sorted_set/utils.go b/internal/sorted_set/utils.go deleted file mode 100644 index 73a531c..0000000 --- a/internal/sorted_set/utils.go +++ /dev/null @@ -1,98 +0,0 @@ -// 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 sorted_set - -import ( - "errors" - "slices" - "strings" -) - -func validateUpdatePolicy(updatePolicy interface{}) (string, error) { - if updatePolicy == nil { - return "", nil - } - err := errors.New("update policy must be a string of Value NX or XX") - policy, ok := updatePolicy.(string) - if !ok { - return "", err - } - if !slices.Contains([]string{"nx", "xx"}, strings.ToLower(policy)) { - return "", err - } - return policy, nil -} - -func validateComparison(comparison interface{}) (string, error) { - if comparison == nil { - return "", nil - } - err := errors.New("comparison condition must be a string of Value LT or GT") - comp, ok := comparison.(string) - if !ok { - return "", err - } - if !slices.Contains([]string{"lt", "gt"}, strings.ToLower(comp)) { - return "", err - } - return comp, nil -} - -func validateChanged(changed interface{}) (string, error) { - if changed == nil { - return "", nil - } - err := errors.New("changed condition should be a string of Value CH") - ch, ok := changed.(string) - if !ok { - return "", err - } - if !strings.EqualFold(ch, "ch") { - return "", err - } - return ch, nil -} - -func validateIncr(incr interface{}) (string, error) { - if incr == nil { - return "", nil - } - err := errors.New("incr condition should be a string of Value INCR") - i, ok := incr.(string) - if !ok { - return "", err - } - if !strings.EqualFold(i, "incr") { - return "", err - } - return i, nil -} - -func compareScores(old Score, new Score, comp string) Score { - switch strings.ToLower(comp) { - default: - return new - case "lt": - if new < old { - return new - } - return old - case "gt": - if new > old { - return new - } - return old - } -} diff --git a/pkg/commands/commands.go b/pkg/commands/commands.go deleted file mode 100644 index 4cc7643..0000000 --- a/pkg/commands/commands.go +++ /dev/null @@ -1,31 +0,0 @@ -package commands - -import ( - "github.com/echovault/echovault/pkg/modules/acl" - "github.com/echovault/echovault/pkg/modules/admin" - "github.com/echovault/echovault/pkg/modules/connection" - "github.com/echovault/echovault/pkg/modules/generic" - "github.com/echovault/echovault/pkg/modules/hash" - "github.com/echovault/echovault/pkg/modules/list" - "github.com/echovault/echovault/pkg/modules/pubsub" - "github.com/echovault/echovault/pkg/modules/set" - "github.com/echovault/echovault/pkg/modules/sorted_set" - str "github.com/echovault/echovault/pkg/modules/string" - "github.com/echovault/echovault/pkg/types" -) - -// All returns all the commands currently available on EchoVault -func All() []types.Command { - var commands []types.Command - commands = append(commands, acl.Commands()...) - commands = append(commands, admin.Commands()...) - commands = append(commands, generic.Commands()...) - commands = append(commands, hash.Commands()...) - commands = append(commands, list.Commands()...) - commands = append(commands, connection.Commands()...) - commands = append(commands, pubsub.Commands()...) - commands = append(commands, set.Commands()...) - commands = append(commands, sorted_set.Commands()...) - commands = append(commands, str.Commands()...) - return commands -} diff --git a/pkg/echovault/echovault.go b/pkg/echovault/echovault.go index 70e69bf..18911fc 100644 --- a/pkg/echovault/echovault.go +++ b/pkg/echovault/echovault.go @@ -21,13 +21,21 @@ import ( "errors" "fmt" "github.com/echovault/echovault/internal" - "github.com/echovault/echovault/internal/acl" "github.com/echovault/echovault/internal/aof" "github.com/echovault/echovault/internal/clock" "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/internal/eviction" "github.com/echovault/echovault/internal/memberlist" - "github.com/echovault/echovault/internal/pubsub" + "github.com/echovault/echovault/internal/modules/acl" + "github.com/echovault/echovault/internal/modules/admin" + "github.com/echovault/echovault/internal/modules/connection" + "github.com/echovault/echovault/internal/modules/generic" + "github.com/echovault/echovault/internal/modules/hash" + "github.com/echovault/echovault/internal/modules/list" + "github.com/echovault/echovault/internal/modules/pubsub" + "github.com/echovault/echovault/internal/modules/set" + "github.com/echovault/echovault/internal/modules/sorted_set" + str "github.com/echovault/echovault/internal/modules/string" "github.com/echovault/echovault/internal/raft" "github.com/echovault/echovault/internal/snapshot" "github.com/echovault/echovault/pkg/constants" @@ -126,11 +134,24 @@ func NewEchoVault(options ...func(echovault *EchoVault)) (*EchoVault, error) { echovault := &EchoVault{ clock: clock.NewClock(), context: context.Background(), - commands: make([]types.Command, 0), config: config.DefaultConfig(), store: make(map[string]internal.KeyData), keyLocks: make(map[string]*sync.RWMutex), keyCreationLock: &sync.Mutex{}, + commands: func() []types.Command { + var commands []types.Command + commands = append(commands, acl.Commands()...) + commands = append(commands, admin.Commands()...) + commands = append(commands, generic.Commands()...) + commands = append(commands, hash.Commands()...) + commands = append(commands, list.Commands()...) + commands = append(commands, connection.Commands()...) + commands = append(commands, pubsub.Commands()...) + commands = append(commands, set.Commands()...) + commands = append(commands, sorted_set.Commands()...) + commands = append(commands, str.Commands()...) + return commands + }(), } for _, option := range options { diff --git a/pkg/echovault/keyspace.go b/pkg/echovault/keyspace.go index a6ae9ba..a751dba 100644 --- a/pkg/echovault/keyspace.go +++ b/pkg/echovault/keyspace.go @@ -589,16 +589,3 @@ func (server *EchoVault) evictKeysWithExpiredTTL(ctx context.Context) error { return nil } - -func presetValue(server *EchoVault, key string, value interface{}) { - _, _ = server.CreateKeyAndLock(server.context, key) - _ = server.SetValue(server.context, key, value) - server.KeyUnlock(server.context, key) -} - -func presetKeyData(server *EchoVault, key string, data internal.KeyData) { - _, _ = server.CreateKeyAndLock(server.context, key) - defer server.KeyUnlock(server.context, key) - _ = server.SetValue(server.context, key, data.Value) - server.SetExpiry(server.context, key, data.ExpireAt, false) -} diff --git a/test/modules/acl/commands_test.go b/test/modules/acl/commands_test.go index 5c9a81d..09303a0 100644 --- a/test/modules/acl/commands_test.go +++ b/test/modules/acl/commands_test.go @@ -17,11 +17,10 @@ package acl import ( "crypto/sha256" "fmt" - internal_acl "github.com/echovault/echovault/internal/acl" "github.com/echovault/echovault/internal/config" + "github.com/echovault/echovault/internal/modules/acl" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - acl2 "github.com/echovault/echovault/pkg/modules/acl" "github.com/tidwall/resp" "net" "slices" @@ -61,44 +60,43 @@ func setUpServer(bindAddr string, port uint16, requirePass bool, aclConfig strin } mockServer, _ := echovault.NewEchoVault( - echovault.WithCommands(acl2.Commands()), echovault.WithConfig(conf), ) // Add the initial test users to the ACL module - acl := mockServer.GetACL().(*internal_acl.ACL) - acl.AddUsers(generateInitialTestUsers()) + a := mockServer.GetACL().(*acl.ACL) + a.AddUsers(generateInitialTestUsers()) return mockServer } -func generateInitialTestUsers() []*internal_acl.User { +func generateInitialTestUsers() []*acl.User { // User with both hash password and plaintext password - withPasswordUser := internal_acl.CreateUser("with_password_user") + withPasswordUser := acl.CreateUser("with_password_user") h := sha256.New() h.Write([]byte("password3")) - withPasswordUser.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "password2"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: string(h.Sum(nil))}, + withPasswordUser.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "password2"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: string(h.Sum(nil))}, } withPasswordUser.IncludedCategories = []string{"*"} withPasswordUser.IncludedCommands = []string{"*"} // User with NoPassword option - noPasswordUser := internal_acl.CreateUser("no_password_user") - noPasswordUser.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "password4"}, + noPasswordUser := acl.CreateUser("no_password_user") + noPasswordUser.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "password4"}, } noPasswordUser.NoPassword = true // Disabled user - disabledUser := internal_acl.CreateUser("disabled_user") - disabledUser.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "password5"}, + disabledUser := acl.CreateUser("disabled_user") + disabledUser.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "password5"}, } disabledUser.Enabled = false - return []*internal_acl.User{ + return []*acl.User{ withPasswordUser, noPasswordUser, disabledUser, @@ -129,7 +127,7 @@ func compareSlices[T comparable](res, expected []T) error { } // compareUsers compares 2 users and checks if all their fields are equal -func compareUsers(user1, user2 *internal_acl.User) error { +func compareUsers(user1, user2 *acl.User) error { // Compare flags if user1.Username != user2.Username { return fmt.Errorf("mismatched usernames \"%s\", and \"%s\"", user1.Username, user2.Username) @@ -146,14 +144,14 @@ func compareUsers(user1, user2 *internal_acl.User) error { // Compare passwords for _, password1 := range user1.Passwords { - if !slices.ContainsFunc(user2.Passwords, func(password2 internal_acl.Password) bool { + if !slices.ContainsFunc(user2.Passwords, func(password2 acl.Password) bool { return password1.PasswordType == password2.PasswordType && password1.PasswordValue == password2.PasswordValue }) { return fmt.Errorf("found password %+v in user1 that was not found in user2", password1) } } for _, password2 := range user2.Passwords { - if !slices.ContainsFunc(user1.Passwords, func(password1 internal_acl.Password) bool { + if !slices.ContainsFunc(user1.Passwords, func(password1 acl.Password) bool { return password1.PasswordType == password2.PasswordType && password1.PasswordValue == password2.PasswordValue }) { return fmt.Errorf("found password %+v in user2 that was not found in user1", password2) @@ -392,14 +390,6 @@ func Test_HandleCat(t *testing.T) { t.Errorf("could not find expected command \"%s\" in the response array for category", expected) } } - // Check if all the elements in the response array are in the expected array - for _, value := range resArr { - if !slices.ContainsFunc(test.wantRes, func(expected string) bool { - return value.String() == expected - }) { - t.Errorf("could not find response command \"%s\" in the expected array", value.String()) - } - } } } @@ -469,7 +459,7 @@ func Test_HandleSetUser(t *testing.T) { }() wg.Wait() - acl, ok := mockServer.GetACL().(*internal_acl.ACL) + a, ok := mockServer.GetACL().(*acl.ACL) if !ok { t.Error("error loading ACL module") } @@ -487,11 +477,11 @@ func Test_HandleSetUser(t *testing.T) { r := resp.NewConn(conn) tests := []struct { - presetUser *internal_acl.User + presetUser *acl.User cmd []resp.Value wantRes string wantErr string - wantUser *internal_acl.User + wantUser *acl.User }{ { // 1. Create new enabled user @@ -504,8 +494,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_1") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_1") user.Enabled = true user.Normalise() return user @@ -522,8 +512,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_2") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_2") user.Enabled = false user.Normalise() return user @@ -544,14 +534,14 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_3") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_3") user.Enabled = true - user.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_1"}, - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_2"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_1")}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_2")}, + user.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_1"}, + {PasswordType: acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_2"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_1")}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_2")}, } user.Normalise() return user @@ -559,14 +549,14 @@ func Test_HandleSetUser(t *testing.T) { }, { // 4. Remove plaintext and SHA256 password from existing user - presetUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_4") + presetUser: func() *acl.User { + user := acl.CreateUser("set_user_4") user.Enabled = true - user.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_1"}, - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_2"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_1")}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_2")}, + user.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_1"}, + {PasswordType: acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_2"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_1")}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_2")}, } user.Normalise() return user @@ -581,12 +571,12 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_4") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_4") user.Enabled = true - user.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_1"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_1")}, + user.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "set_user_3_plaintext_password_1"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("set_user_3_hash_password_1")}, } user.Normalise() return user @@ -604,8 +594,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_5") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_5") user.Enabled = true user.ExcludedCommands = []string{"*"} user.ExcludedCategories = []string{"*"} @@ -625,8 +615,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_6") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_6") user.Enabled = true user.IncludedCategories = []string{"*"} user.ExcludedCategories = []string{} @@ -646,8 +636,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_7") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_7") user.Enabled = true user.IncludedCategories = []string{"*"} user.ExcludedCategories = []string{} @@ -672,8 +662,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_8") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_8") user.Enabled = true user.IncludedCategories = []string{constants.WriteCategory, constants.ReadCategory, constants.PubSubCategory} user.ExcludedCategories = []string{constants.AdminCategory, constants.ConnectionCategory, constants.DangerousCategory} @@ -693,8 +683,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_9") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_9") user.Enabled = true user.NoKeys = true user.IncludedReadKeys = []string{} @@ -723,8 +713,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_10") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_10") user.Enabled = true user.NoKeys = false user.IncludedReadKeys = []string{"key1", "key2", "key3", "key4", "key5", "key6"} @@ -745,8 +735,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_11") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_11") user.Enabled = true user.IncludedPubSubChannels = []string{"*"} user.ExcludedPubSubChannels = []string{} @@ -766,8 +756,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_12") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_12") user.Enabled = true user.IncludedPubSubChannels = []string{"*"} user.ExcludedPubSubChannels = []string{} @@ -790,8 +780,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_13") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_13") user.Enabled = true user.IncludedPubSubChannels = []string{"channel1", "channel2"} user.ExcludedPubSubChannels = []string{"channel3", "channel4"} @@ -811,8 +801,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_14") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_14") user.Enabled = true user.IncludedCommands = []string{"*"} user.ExcludedCommands = []string{} @@ -837,8 +827,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_15") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_15") user.Enabled = true user.IncludedCommands = []string{"acl|getuser", "acl|setuser", "acl|deluser"} user.ExcludedCommands = []string{"rewriteaof", "save", "publish"} @@ -861,24 +851,24 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_16") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_16") user.Enabled = true user.NoPassword = true - user.Passwords = []internal_acl.Password{} + user.Passwords = []acl.Password{} user.Normalise() return user }(), }, { // 17. Delete all existing users passwords using 'nopass' - presetUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_17") + presetUser: func() *acl.User { + user := acl.CreateUser("set_user_17") user.Enabled = true user.NoPassword = true - user.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "password1"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("password2")}, + user.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "password1"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("password2")}, } user.Normalise() return user @@ -892,24 +882,24 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_17") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_17") user.Enabled = true user.NoPassword = true - user.Passwords = []internal_acl.Password{} + user.Passwords = []acl.Password{} user.Normalise() return user }(), }, { // 18. Clear all of an existing user's passwords using 'resetpass' - presetUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_18") + presetUser: func() *acl.User { + user := acl.CreateUser("set_user_18") user.Enabled = true user.NoPassword = true - user.Passwords = []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "password1"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("password2")}, + user.Passwords = []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "password1"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("password2")}, } user.Normalise() return user @@ -923,19 +913,19 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_18") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_18") user.Enabled = true user.NoPassword = true - user.Passwords = []internal_acl.Password{} + user.Passwords = []acl.Password{} user.Normalise() return user }(), }, { // 19. Clear all of an existing user's command privileges using 'nocommands' - presetUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_19") + presetUser: func() *acl.User { + user := acl.CreateUser("set_user_19") user.Enabled = true user.IncludedCommands = []string{"acl|getuser", "acl|setuser", "acl|deluser"} user.ExcludedCommands = []string{"rewriteaof", "save"} @@ -951,8 +941,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_19") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_19") user.Enabled = true user.IncludedCommands = []string{} user.ExcludedCommands = []string{"*"} @@ -964,8 +954,8 @@ func Test_HandleSetUser(t *testing.T) { }, { // 20. Clear all of an existing user's allowed keys using 'resetkeys' - presetUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_20") + presetUser: func() *acl.User { + user := acl.CreateUser("set_user_20") user.Enabled = true user.IncludedWriteKeys = []string{"key1", "key2", "key3", "key4", "key5", "key6"} user.IncludedReadKeys = []string{"key1", "key2", "key3", "key7", "key8", "key9"} @@ -981,8 +971,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_20") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_20") user.Enabled = true user.NoKeys = true user.IncludedReadKeys = []string{} @@ -993,8 +983,8 @@ func Test_HandleSetUser(t *testing.T) { }, { // 21. Allow user to access all channels using 'resetchannels' - presetUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_21") + presetUser: func() *acl.User { + user := acl.CreateUser("set_user_21") user.IncludedPubSubChannels = []string{"channel1", "channel2"} user.ExcludedPubSubChannels = []string{"channel3", "channel4"} user.Normalise() @@ -1008,8 +998,8 @@ func Test_HandleSetUser(t *testing.T) { }, wantRes: "OK", wantErr: "", - wantUser: func() *internal_acl.User { - user := internal_acl.CreateUser("set_user_21") + wantUser: func() *acl.User { + user := acl.CreateUser("set_user_21") user.IncludedPubSubChannels = []string{} user.ExcludedPubSubChannels = []string{"*"} user.Normalise() @@ -1020,7 +1010,7 @@ func Test_HandleSetUser(t *testing.T) { for i, test := range tests { if test.presetUser != nil { - acl.AddUsers([]*internal_acl.User{test.presetUser}) + a.AddUsers([]*acl.User{test.presetUser}) } if err = r.WriteArray(test.cmd); err != nil { t.Error(err) @@ -1042,13 +1032,13 @@ func Test_HandleSetUser(t *testing.T) { continue } expectedUser := test.wantUser - currUserIdx := slices.IndexFunc(acl.Users, func(user *internal_acl.User) bool { + currUserIdx := slices.IndexFunc(a.Users, func(user *acl.User) bool { return user.Username == expectedUser.Username }) if currUserIdx == -1 { t.Errorf("expected to find user with username \"%s\" but could not find them.", expectedUser.Username) } - if err = compareUsers(expectedUser, acl.Users[currUserIdx]); err != nil { + if err = compareUsers(expectedUser, a.Users[currUserIdx]); err != nil { t.Errorf("test idx: %d, %+v", i, err) } } @@ -1065,7 +1055,7 @@ func Test_HandleGetUser(t *testing.T) { }() wg.Wait() - acl, _ := mockServer.GetACL().(*internal_acl.ACL) + a, _ := mockServer.GetACL().(*acl.ACL) conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", bindAddr, port)) if err != nil { @@ -1080,20 +1070,20 @@ func Test_HandleGetUser(t *testing.T) { r := resp.NewConn(conn) tests := []struct { - presetUser *internal_acl.User + presetUser *acl.User cmd []resp.Value wantRes []resp.Value wantErr string }{ { // 1. Get the user and all their details - presetUser: &internal_acl.User{ + presetUser: &acl.User{ Username: "get_user_1", Enabled: true, NoPassword: false, NoKeys: false, - Passwords: []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "get_user_password_1"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("get_user_password_2")}, + Passwords: []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "get_user_password_1"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("get_user_password_2")}, }, IncludedCategories: []string{constants.WriteCategory, constants.ReadCategory, constants.PubSubCategory}, ExcludedCategories: []string{constants.AdminCategory, constants.ConnectionCategory, constants.DangerousCategory}, @@ -1165,7 +1155,7 @@ func Test_HandleGetUser(t *testing.T) { for _, test := range tests { if test.presetUser != nil { - acl.AddUsers([]*internal_acl.User{test.presetUser}) + a.AddUsers([]*acl.User{test.presetUser}) } if err = r.WriteArray(test.cmd); err != nil { t.Error(err) @@ -1218,7 +1208,7 @@ func Test_HandleDelUser(t *testing.T) { }() wg.Wait() - acl, _ := mockServer.GetACL().(*internal_acl.ACL) + a, _ := mockServer.GetACL().(*acl.ACL) conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", bindAddr, port)) if err != nil { @@ -1233,14 +1223,14 @@ func Test_HandleDelUser(t *testing.T) { r := resp.NewConn(conn) tests := []struct { - presetUser *internal_acl.User + presetUser *acl.User cmd []resp.Value wantRes string wantErr string }{ { // 1. Delete existing user while skipping default user and non-existent user - presetUser: internal_acl.CreateUser("user_to_delete"), + presetUser: acl.CreateUser("user_to_delete"), cmd: []resp.Value{ resp.StringValue("ACL"), resp.StringValue("DELUSER"), @@ -1262,7 +1252,7 @@ func Test_HandleDelUser(t *testing.T) { for _, test := range tests { if test.presetUser != nil { - acl.AddUsers([]*internal_acl.User{test.presetUser}) + a.AddUsers([]*acl.User{test.presetUser}) } if err = r.WriteArray(test.cmd); err != nil { t.Error(err) @@ -1278,13 +1268,13 @@ func Test_HandleDelUser(t *testing.T) { continue } // Check that default user still exists in the list of users - if !slices.ContainsFunc(acl.Users, func(user *internal_acl.User) bool { + if !slices.ContainsFunc(a.Users, func(user *acl.User) bool { return user.Username == "default" }) { t.Error("could not find user with username \"default\" in the ACL after deleting user") } // Check that the deleted user is no longer in the list - if slices.ContainsFunc(acl.Users, func(user *internal_acl.User) bool { + if slices.ContainsFunc(a.Users, func(user *acl.User) bool { return user.Username == "user_to_delete" }) { t.Error("deleted user found in the ACL") @@ -1368,7 +1358,7 @@ func Test_HandleList(t *testing.T) { }() wg.Wait() - acl, _ := mockServer.GetACL().(*internal_acl.ACL) + a, _ := mockServer.GetACL().(*acl.ACL) conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", bindAddr, port)) if err != nil { @@ -1383,21 +1373,21 @@ func Test_HandleList(t *testing.T) { r := resp.NewConn(conn) tests := []struct { - presetUsers []*internal_acl.User + presetUsers []*acl.User cmd []resp.Value wantRes []string wantErr string }{ { // 1. Get the user and all their details - presetUsers: []*internal_acl.User{ + presetUsers: []*acl.User{ { Username: "list_user_1", Enabled: true, NoPassword: false, NoKeys: false, - Passwords: []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "list_user_password_1"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("list_user_password_2")}, + Passwords: []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "list_user_password_1"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("list_user_password_2")}, }, IncludedCategories: []string{constants.WriteCategory, constants.ReadCategory, constants.PubSubCategory}, ExcludedCategories: []string{constants.AdminCategory, constants.ConnectionCategory, constants.DangerousCategory}, @@ -1413,7 +1403,7 @@ func Test_HandleList(t *testing.T) { Enabled: true, NoPassword: true, NoKeys: true, - Passwords: []internal_acl.Password{}, + Passwords: []acl.Password{}, IncludedCategories: []string{constants.WriteCategory, constants.ReadCategory, constants.PubSubCategory}, ExcludedCategories: []string{constants.AdminCategory, constants.ConnectionCategory, constants.DangerousCategory}, IncludedCommands: []string{"acl|setuser", "acl|getuser", "acl|deluser"}, @@ -1428,9 +1418,9 @@ func Test_HandleList(t *testing.T) { Enabled: true, NoPassword: false, NoKeys: false, - Passwords: []internal_acl.Password{ - {PasswordType: internal_acl.PasswordPlainText, PasswordValue: "list_user_password_3"}, - {PasswordType: internal_acl.PasswordSHA256, PasswordValue: generateSHA256Password("list_user_password_4")}, + Passwords: []acl.Password{ + {PasswordType: acl.PasswordPlainText, PasswordValue: "list_user_password_3"}, + {PasswordType: acl.PasswordSHA256, PasswordValue: generateSHA256Password("list_user_password_4")}, }, IncludedCategories: []string{constants.WriteCategory, constants.ReadCategory, constants.PubSubCategory}, ExcludedCategories: []string{constants.AdminCategory, constants.ConnectionCategory, constants.DangerousCategory}, @@ -1457,7 +1447,7 @@ func Test_HandleList(t *testing.T) { } for _, test := range tests { - acl.AddUsers(test.presetUsers) + a.AddUsers(test.presetUsers) if err = r.WriteArray(test.cmd); err != nil { t.Error(err) diff --git a/test/modules/admin/commands_test.go b/test/modules/admin/commands_test.go index 6e1ac3c..0f8b908 100644 --- a/test/modules/admin/commands_test.go +++ b/test/modules/admin/commands_test.go @@ -21,7 +21,6 @@ import ( "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/admin" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -33,7 +32,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(admin.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/connection/commands_test.go b/test/modules/connection/commands_test.go index 675a4e2..633e884 100644 --- a/test/modules/connection/commands_test.go +++ b/test/modules/connection/commands_test.go @@ -21,7 +21,6 @@ import ( "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/connection" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -33,7 +32,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(connection.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/generic/api_generic_test.go b/test/modules/generic/api_generic_test.go index d0f6cdc..b18281b 100644 --- a/test/modules/generic/api_generic_test.go +++ b/test/modules/generic/api_generic_test.go @@ -20,7 +20,6 @@ import ( "github.com/echovault/echovault/internal/clock" "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/generic" "reflect" "slices" "strings" @@ -30,7 +29,6 @@ import ( func createEchoVault() *echovault.EchoVault { ev, _ := echovault.NewEchoVault( - echovault.WithCommands(generic.Commands()), echovault.WithConfig(config.Config{ DataDir: "", }), diff --git a/test/modules/generic/commands_test.go b/test/modules/generic/commands_test.go index 95f012f..e89d228 100644 --- a/test/modules/generic/commands_test.go +++ b/test/modules/generic/commands_test.go @@ -23,7 +23,6 @@ import ( "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/generic" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -45,7 +44,6 @@ func init() { mockClock = clock.NewClock() mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(generic.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/hash/api_hash_test.go b/test/modules/hash/api_hash_test.go index 9ee30f1..6ef4db5 100644 --- a/test/modules/hash/api_hash_test.go +++ b/test/modules/hash/api_hash_test.go @@ -18,7 +18,6 @@ import ( "context" "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/hash" "reflect" "slices" "testing" @@ -26,7 +25,6 @@ import ( func createEchoVault() *echovault.EchoVault { ev, _ := echovault.NewEchoVault( - echovault.WithCommands(hash.Commands()), echovault.WithConfig(config.Config{ DataDir: "", }), diff --git a/test/modules/hash/commands_test.go b/test/modules/hash/commands_test.go index ba7c7fa..ec890a2 100644 --- a/test/modules/hash/commands_test.go +++ b/test/modules/hash/commands_test.go @@ -22,7 +22,6 @@ import ( "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/hash" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -35,7 +34,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(hash.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/list/api_list_test.go b/test/modules/list/api_list_test.go index 4018109..44e8552 100644 --- a/test/modules/list/api_list_test.go +++ b/test/modules/list/api_list_test.go @@ -18,14 +18,12 @@ import ( "context" "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/list" "reflect" "testing" ) func createEchoVault() *echovault.EchoVault { ev, _ := echovault.NewEchoVault( - echovault.WithCommands(list.Commands()), echovault.WithConfig(config.Config{ DataDir: "", }), diff --git a/test/modules/list/commands_test.go b/test/modules/list/commands_test.go index 1074d1b..ff40a59 100644 --- a/test/modules/list/commands_test.go +++ b/test/modules/list/commands_test.go @@ -22,7 +22,6 @@ import ( "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - "github.com/echovault/echovault/pkg/modules/list" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -34,7 +33,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(list.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/pubsub/commands_test.go b/test/modules/pubsub/commands_test.go index 07ea3b2..a8874ed 100644 --- a/test/modules/pubsub/commands_test.go +++ b/test/modules/pubsub/commands_test.go @@ -19,10 +19,9 @@ import ( "context" "fmt" "github.com/echovault/echovault/internal/config" - internal_pubsub "github.com/echovault/echovault/internal/pubsub" + "github.com/echovault/echovault/internal/modules/pubsub" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - ps "github.com/echovault/echovault/pkg/modules/pubsub" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -33,7 +32,7 @@ import ( "time" ) -var pubsub *internal_pubsub.PubSub +var ps *pubsub.PubSub var mockServer *echovault.EchoVault var bindAddr = "localhost" @@ -41,7 +40,7 @@ var port uint16 = 7490 func init() { mockServer = setUpServer(bindAddr, port) - pubsub = mockServer.GetPubSub().(*internal_pubsub.PubSub) + ps = mockServer.GetPubSub().(*pubsub.PubSub) wg := sync.WaitGroup{} wg.Add(1) @@ -54,7 +53,6 @@ func init() { func setUpServer(bindAddr string, port uint16) *echovault.EchoVault { server, _ := echovault.NewEchoVault( - echovault.WithCommands(ps.Commands()), echovault.WithConfig(config.Config{ BindAddr: bindAddr, Port: port, @@ -126,12 +124,12 @@ func Test_HandleSubscribe(t *testing.T) { } for _, channel := range channels { // Check if the channel exists in the pubsub module - if !slices.ContainsFunc(pubsub.GetAllChannels(), func(c *internal_pubsub.Channel) bool { + if !slices.ContainsFunc(ps.GetAllChannels(), func(c *pubsub.Channel) bool { return c.Name() == channel }) { t.Errorf("expected pubsub to contain channel \"%s\" but it was not found", channel) } - for _, c := range pubsub.GetAllChannels() { + for _, c := range ps.GetAllChannels() { if c.Name() == channel { // Check if channel has nil pattern if c.Pattern() != nil { @@ -157,12 +155,12 @@ func Test_HandleSubscribe(t *testing.T) { } for _, pattern := range patterns { // Check if pattern channel exists in pubsub module - if !slices.ContainsFunc(pubsub.GetAllChannels(), func(c *internal_pubsub.Channel) bool { + if !slices.ContainsFunc(ps.GetAllChannels(), func(c *pubsub.Channel) bool { return c.Name() == pattern }) { t.Errorf("expected pubsub to contain pattern channel \"%s\" but it was not found", pattern) } - for _, c := range pubsub.GetAllChannels() { + for _, c := range ps.GetAllChannels() { if c.Name() == pattern { // Check if channel has non-nil pattern if c.Pattern() == nil { @@ -322,7 +320,7 @@ func Test_HandleUnsubscribe(t *testing.T) { verifyResponse(res, test.expectedResponses["pattern"]) for _, channel := range append(test.unSubChannels, test.unSubPatterns...) { - for _, pubsubChannel := range pubsub.GetAllChannels() { + for _, pubsubChannel := range ps.GetAllChannels() { if pubsubChannel.Name() == channel { // Assert that target connection is no longer in the unsub channels and patterns if _, ok := pubsubChannel.Subscribers()[test.targetConn]; ok { @@ -339,7 +337,7 @@ func Test_HandleUnsubscribe(t *testing.T) { // Assert that the target connection is still in the remain channels and patterns for _, channel := range append(test.remainChannels, test.remainPatterns...) { - for _, pubsubChannel := range pubsub.GetAllChannels() { + for _, pubsubChannel := range ps.GetAllChannels() { if pubsubChannel.Name() == channel { if _, ok := pubsubChannel.Subscribers()[test.targetConn]; !ok { t.Errorf("could not find expected target connection in channel \"%s\"", channel) diff --git a/test/modules/set/api_set_test.go b/test/modules/set/api_set_test.go index 491eb8b..6c085b8 100644 --- a/test/modules/set/api_set_test.go +++ b/test/modules/set/api_set_test.go @@ -17,9 +17,8 @@ package set import ( "context" "github.com/echovault/echovault/internal/config" - "github.com/echovault/echovault/internal/set" + "github.com/echovault/echovault/internal/modules/set" "github.com/echovault/echovault/pkg/echovault" - s "github.com/echovault/echovault/pkg/modules/set" "reflect" "slices" "testing" @@ -27,7 +26,6 @@ import ( func createEchoVault() *echovault.EchoVault { ev, _ := echovault.NewEchoVault( - echovault.WithCommands(s.Commands()), echovault.WithConfig(config.Config{ DataDir: "", }), diff --git a/test/modules/set/commands_test.go b/test/modules/set/commands_test.go index aa716b9..abb14ec 100644 --- a/test/modules/set/commands_test.go +++ b/test/modules/set/commands_test.go @@ -20,10 +20,9 @@ import ( "errors" "fmt" "github.com/echovault/echovault/internal/config" - "github.com/echovault/echovault/internal/set" + "github.com/echovault/echovault/internal/modules/set" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - s "github.com/echovault/echovault/pkg/modules/set" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -36,7 +35,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(s.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/sorted_set/api_sorted_set_test.go b/test/modules/sorted_set/api_sorted_set_test.go index 9c674d6..8dcd57f 100644 --- a/test/modules/sorted_set/api_sorted_set_test.go +++ b/test/modules/sorted_set/api_sorted_set_test.go @@ -18,9 +18,8 @@ import ( "context" "github.com/echovault/echovault/internal" "github.com/echovault/echovault/internal/config" - "github.com/echovault/echovault/internal/sorted_set" + ss "github.com/echovault/echovault/internal/modules/sorted_set" "github.com/echovault/echovault/pkg/echovault" - ss "github.com/echovault/echovault/pkg/modules/sorted_set" "math" "reflect" "strconv" @@ -29,7 +28,6 @@ import ( func createEchoVault() *echovault.EchoVault { ev, _ := echovault.NewEchoVault( - echovault.WithCommands(ss.Commands()), echovault.WithConfig(config.Config{ DataDir: "", }), @@ -54,7 +52,7 @@ func TestEchoVault_ZADD(t *testing.T) { tests := []struct { name string preset bool - presetValue *sorted_set.SortedSet + presetValue *ss.SortedSet key string entries map[string]float64 options echovault.ZADDOptions @@ -80,10 +78,10 @@ func TestEchoVault_ZADD(t *testing.T) { { name: "Only add the elements that do not currently exist in the sorted set when NX flag is provided", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key2", entries: map[string]float64{ @@ -98,10 +96,10 @@ func TestEchoVault_ZADD(t *testing.T) { { name: "Do not add any elements when providing existing members with NX flag", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key3", entries: map[string]float64{ @@ -116,10 +114,10 @@ func TestEchoVault_ZADD(t *testing.T) { { name: "Successfully add elements to an existing set when XX flag is provided with existing elements", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key4", entries: map[string]float64{ @@ -135,10 +133,10 @@ func TestEchoVault_ZADD(t *testing.T) { { name: "Fail to add element when providing XX flag with elements that do not exist in the sorted set", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key5", entries: map[string]float64{ @@ -155,10 +153,10 @@ func TestEchoVault_ZADD(t *testing.T) { // Return only the new elements added by default name: "Only update the elements where provided score is greater than current score if GT flag", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key6", entries: map[string]float64{ @@ -175,10 +173,10 @@ func TestEchoVault_ZADD(t *testing.T) { // Return only the new elements added by default. name: "Only update the elements where provided score is less than current score if LT flag is provided", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key7", entries: map[string]float64{ @@ -193,10 +191,10 @@ func TestEchoVault_ZADD(t *testing.T) { { name: "Return all the elements that were updated AND added when CH flag is provided", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key8", entries: map[string]float64{ @@ -211,10 +209,10 @@ func TestEchoVault_ZADD(t *testing.T) { { name: "Increment the member by score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key9", entries: map[string]float64{ @@ -286,10 +284,10 @@ func TestEchoVault_ZCARD(t *testing.T) { { name: "Get cardinality of valid sorted set", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, }), key: "key1", want: 3, @@ -349,14 +347,14 @@ func TestEchoVault_ZCOUNT(t *testing.T) { { name: "Get entire count using infinity boundaries", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, - {Value: "member4", Score: sorted_set.Score(1083.13)}, - {Value: "member5", Score: sorted_set.Score(11)}, - {Value: "member6", Score: sorted_set.Score(math.Inf(-1))}, - {Value: "member7", Score: sorted_set.Score(math.Inf(1))}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, + {Value: "member4", Score: ss.Score(1083.13)}, + {Value: "member5", Score: ss.Score(11)}, + {Value: "member6", Score: ss.Score(math.Inf(-1))}, + {Value: "member7", Score: ss.Score(math.Inf(1))}, }), key: "key1", min: math.Inf(-1), @@ -367,14 +365,14 @@ func TestEchoVault_ZCOUNT(t *testing.T) { { name: "Get count of sub-set from -inf to limit", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, - {Value: "member4", Score: sorted_set.Score(1083.13)}, - {Value: "member5", Score: sorted_set.Score(11)}, - {Value: "member6", Score: sorted_set.Score(math.Inf(-1))}, - {Value: "member7", Score: sorted_set.Score(math.Inf(1))}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, + {Value: "member4", Score: ss.Score(1083.13)}, + {Value: "member5", Score: ss.Score(11)}, + {Value: "member6", Score: ss.Score(math.Inf(-1))}, + {Value: "member7", Score: ss.Score(math.Inf(1))}, }), key: "key2", min: math.Inf(-1), @@ -385,14 +383,14 @@ func TestEchoVault_ZCOUNT(t *testing.T) { { name: "Get count of sub-set from bottom boundary to +inf limit", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "member1", Score: sorted_set.Score(5.5)}, - {Value: "member2", Score: sorted_set.Score(67.77)}, - {Value: "member3", Score: sorted_set.Score(10)}, - {Value: "member4", Score: sorted_set.Score(1083.13)}, - {Value: "member5", Score: sorted_set.Score(11)}, - {Value: "member6", Score: sorted_set.Score(math.Inf(-1))}, - {Value: "member7", Score: sorted_set.Score(math.Inf(1))}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "member1", Score: ss.Score(5.5)}, + {Value: "member2", Score: ss.Score(67.77)}, + {Value: "member3", Score: ss.Score(10)}, + {Value: "member4", Score: ss.Score(1083.13)}, + {Value: "member5", Score: ss.Score(11)}, + {Value: "member6", Score: ss.Score(math.Inf(-1))}, + {Value: "member7", Score: ss.Score(math.Inf(1))}, }), key: "key3", min: 1000, @@ -448,13 +446,13 @@ func TestEchoVault_ZDIFF(t *testing.T) { name: "Get the difference between 2 sorted sets without scores", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, }), - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.MemberParam{ {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -472,13 +470,13 @@ func TestEchoVault_ZDIFF(t *testing.T) { name: "Get the difference between 2 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, }), - "key4": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.MemberParam{ {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -496,18 +494,18 @@ func TestEchoVault_ZDIFF(t *testing.T) { name: "Get the difference between 3 sets with scores", preset: true, presetValues: map[string]interface{}{ - "key5": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.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}, }), - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key7": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key7": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -522,7 +520,7 @@ func TestEchoVault_ZDIFF(t *testing.T) { name: "Return sorted set if only one key exists and is a sorted set", preset: true, presetValues: map[string]interface{}{ - "key8": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.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}, @@ -542,12 +540,12 @@ func TestEchoVault_ZDIFF(t *testing.T) { preset: true, presetValues: map[string]interface{}{ "key9": "Default value", - "key10": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key10": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key11": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key11": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -598,12 +596,12 @@ func TestEchoVault_ZDIFFSTORE(t *testing.T) { name: "Get the difference between 2 sorted sets", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, }), - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.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}, @@ -618,18 +616,18 @@ func TestEchoVault_ZDIFFSTORE(t *testing.T) { name: "Get the difference between 3 sorted sets", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key5": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -644,7 +642,7 @@ func TestEchoVault_ZDIFFSTORE(t *testing.T) { name: "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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.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}, @@ -661,12 +659,12 @@ func TestEchoVault_ZDIFFSTORE(t *testing.T) { preset: true, presetValues: map[string]interface{}{ "key7": "Default value", - "key8": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key9": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key9": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -717,7 +715,7 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { name: "Successfully increment by int. Return the new score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -731,7 +729,7 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { name: "Successfully increment by float. Return new score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -754,7 +752,7 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { // 4. name: "Increment score to +inf", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -768,7 +766,7 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { name: "Increment score to -inf", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -782,7 +780,7 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { name: "Incrementing score by negative increment should lower the score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -806,8 +804,8 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { name: "Return error when trying to increment a member that already has score -inf", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "one", Score: sorted_set.Score(math.Inf(-1))}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "one", Score: ss.Score(math.Inf(-1))}, }), key: "key8", increment: 2.5, @@ -818,8 +816,8 @@ func TestEchoVault_ZINCRBY(t *testing.T) { { name: "Return error when trying to increment a member that already has score +inf", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "one", Score: sorted_set.Score(math.Inf(1))}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "one", Score: ss.Score(math.Inf(1))}, }), key: "key9", increment: 2.5, @@ -865,12 +863,12 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Get the intersection between 2 sorted sets", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, }), - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.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}, @@ -887,18 +885,18 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -915,18 +913,18 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key7": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -942,18 +940,18 @@ func TestEchoVault_ZINTER(t *testing.T) { // Use MAX aggregate. preset: true, presetValues: map[string]interface{}{ - "key9": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key9": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key10": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key11": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -970,18 +968,18 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key12": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key12": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key13": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key14": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -998,18 +996,18 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key15": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key15": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key16": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key17": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1026,18 +1024,18 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key18": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key18": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key19": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key20": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1052,13 +1050,13 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Throw an error if there are more weights than keys", preset: true, presetValues: map[string]interface{}{ - "key21": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key21": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key22": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{"key21", "key22"}, options: echovault.ZINTEROptions{Weights: []float64{1, 2, 3}}, @@ -1069,16 +1067,16 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Throw an error if there are fewer weights than keys", preset: true, presetValues: map[string]interface{}{ - "key23": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key23": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key24": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, }), - "key25": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key25": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{"key23", "key24", "key25"}, options: echovault.ZINTEROptions{Weights: []float64{5, 4}}, @@ -1089,9 +1087,9 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Throw an error if there are no keys provided", preset: true, presetValues: map[string]interface{}{ - "key26": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), - "key27": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), - "key28": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key26": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), + "key27": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), + "key28": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{}, options: echovault.ZINTEROptions{}, @@ -1102,14 +1100,14 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "Throw an error if any of the provided keys are not sorted sets", preset: true, presetValues: map[string]interface{}{ - "key29": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key29": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key31": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{"key29", "key30", "key31"}, options: echovault.ZINTEROptions{}, @@ -1120,12 +1118,12 @@ func TestEchoVault_ZINTER(t *testing.T) { name: "If any of the keys does not exist, return an empty array", preset: true, presetValues: map[string]interface{}{ - "key32": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key32": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key33": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key33": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1177,12 +1175,12 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 2 sorted sets", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, }), - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.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}, @@ -1200,18 +1198,18 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1229,18 +1227,18 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key7": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1258,18 +1256,18 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key9": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key9": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key10": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key11": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1287,18 +1285,18 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key12": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key12": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key13": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key14": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1316,18 +1314,18 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key15": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key15": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key16": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key17": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1345,18 +1343,18 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Get the intersection between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key18": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key18": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key19": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key20": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1372,13 +1370,13 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Throw an error if there are more weights than keys", preset: true, presetValues: map[string]interface{}{ - "key21": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key21": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key22": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination8", keys: []string{"key21", "key22"}, @@ -1390,16 +1388,16 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Throw an error if there are fewer weights than keys", preset: true, presetValues: map[string]interface{}{ - "key23": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key23": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key24": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, }), - "key25": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key25": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination9", keys: []string{"key23", "key24"}, @@ -1411,9 +1409,9 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Throw an error if there are no keys provided", preset: true, presetValues: map[string]interface{}{ - "key26": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), - "key27": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), - "key28": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key26": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), + "key27": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), + "key28": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination10", keys: []string{}, @@ -1425,14 +1423,14 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "Throw an error if any of the provided keys are not sorted sets", preset: true, presetValues: map[string]interface{}{ - "key29": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key29": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key31": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination11", keys: []string{"key29", "key30", "key31"}, @@ -1444,12 +1442,12 @@ func TestEchoVault_ZINTERSTORE(t *testing.T) { name: "If any of the keys does not exist, return an empty array", preset: true, presetValues: map[string]interface{}{ - "key32": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key32": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key33": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key33": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -1501,14 +1499,14 @@ func TestEchoVault_ZLEXCOUNT(t *testing.T) { { name: "Get entire count using infinity boundaries", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "e", Score: sorted_set.Score(1)}, - {Value: "f", Score: sorted_set.Score(1)}, - {Value: "g", Score: sorted_set.Score(1)}, - {Value: "h", Score: sorted_set.Score(1)}, - {Value: "i", Score: sorted_set.Score(1)}, - {Value: "j", Score: sorted_set.Score(1)}, - {Value: "k", Score: sorted_set.Score(1)}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "e", Score: ss.Score(1)}, + {Value: "f", Score: ss.Score(1)}, + {Value: "g", Score: ss.Score(1)}, + {Value: "h", Score: ss.Score(1)}, + {Value: "i", Score: ss.Score(1)}, + {Value: "j", Score: ss.Score(1)}, + {Value: "k", Score: ss.Score(1)}, }), key: "key1", min: "f", @@ -1519,14 +1517,14 @@ func TestEchoVault_ZLEXCOUNT(t *testing.T) { { name: "Return 0 when the members do not have the same score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ - {Value: "a", Score: sorted_set.Score(5.5)}, - {Value: "b", Score: sorted_set.Score(67.77)}, - {Value: "c", Score: sorted_set.Score(10)}, - {Value: "d", Score: sorted_set.Score(1083.13)}, - {Value: "e", Score: sorted_set.Score(11)}, - {Value: "f", Score: sorted_set.Score(math.Inf(-1))}, - {Value: "g", Score: sorted_set.Score(math.Inf(1))}, + presetValue: ss.NewSortedSet([]ss.MemberParam{ + {Value: "a", Score: ss.Score(5.5)}, + {Value: "b", Score: ss.Score(67.77)}, + {Value: "c", Score: ss.Score(10)}, + {Value: "d", Score: ss.Score(1083.13)}, + {Value: "e", Score: ss.Score(11)}, + {Value: "f", Score: ss.Score(math.Inf(-1))}, + {Value: "g", Score: ss.Score(math.Inf(1))}, }), key: "key2", min: "a", @@ -1592,7 +1590,7 @@ func TestEchoVault_ZMPOP(t *testing.T) { name: "Successfully pop one min element by default", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -1609,7 +1607,7 @@ func TestEchoVault_ZMPOP(t *testing.T) { name: "Successfully pop one min element by specifying MIN", preset: true, presetValues: map[string]interface{}{ - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -1626,7 +1624,7 @@ func TestEchoVault_ZMPOP(t *testing.T) { name: "Successfully pop one max element by specifying MAX modifier", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -1643,7 +1641,7 @@ func TestEchoVault_ZMPOP(t *testing.T) { name: "Successfully pop multiple min elements", preset: true, presetValues: map[string]interface{}{ - "key4": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.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}, @@ -1661,7 +1659,7 @@ func TestEchoVault_ZMPOP(t *testing.T) { name: "Successfully pop multiple max elements", preset: true, presetValues: map[string]interface{}{ - "key5": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.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}, @@ -1676,8 +1674,8 @@ func TestEchoVault_ZMPOP(t *testing.T) { name: "Successfully pop elements from the first set which is non-empty", preset: true, presetValues: map[string]interface{}{ - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{}), - "key7": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.MemberParam{}), + "key7": ss.NewSortedSet([]ss.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}, @@ -1694,8 +1692,8 @@ func TestEchoVault_ZMPOP(t *testing.T) { presetValues: map[string]interface{}{ "key8": "Default value", "key9": 56, - "key10": sorted_set.NewSortedSet([]sorted_set.MemberParam{}), - "key11": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key10": ss.NewSortedSet([]ss.MemberParam{}), + "key11": ss.NewSortedSet([]ss.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}, @@ -1746,7 +1744,7 @@ func TestEchoVault_ZMSCORE(t *testing.T) { // Return nil for elements that do not exist in the sorted set. name: "Return multiple scores from the sorted set", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1.1}, {Value: "two", Score: 245}, {Value: "three", Score: 3}, {Value: "four", Score: 4.055}, {Value: "five", Score: 5}, @@ -1825,7 +1823,7 @@ func TestEchoVault_ZPOP(t *testing.T) { { name: "Successfully pop one min element", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -1841,7 +1839,7 @@ func TestEchoVault_ZPOP(t *testing.T) { { name: "Successfully pop one max element", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -1855,7 +1853,7 @@ func TestEchoVault_ZPOP(t *testing.T) { { name: "Successfully pop multiple min elements", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -1872,7 +1870,7 @@ func TestEchoVault_ZPOP(t *testing.T) { { name: "Successfully pop multiple max elements", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -1933,7 +1931,7 @@ func TestEchoVault_ZRANDMEMBER(t *testing.T) { name: "Return multiple random elements without removing them", preset: true, key: "key1", - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, }), @@ -1948,7 +1946,7 @@ func TestEchoVault_ZRANDMEMBER(t *testing.T) { name: "Return multiple random elements and their scores without removing them", preset: true, key: "key2", - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, }), @@ -2006,7 +2004,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { { name: "Get elements withing score range without score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -2022,7 +2020,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { { name: "Get elements within score range with score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -2040,7 +2038,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { // Offset and limit are in where we start and stop counting in the original sorted set (NOT THE RESULT). name: "Get elements within score range with offset and limit", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -2056,7 +2054,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { { name: "Get elements within lex range without score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "a", Score: 1}, {Value: "e", Score: 1}, {Value: "b", Score: 1}, {Value: "f", Score: 1}, {Value: "c", Score: 1}, {Value: "g", Score: 1}, @@ -2072,7 +2070,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { { name: "Get elements within lex range with score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "a", Score: 1}, {Value: "e", Score: 1}, {Value: "b", Score: 1}, {Value: "f", Score: 1}, {Value: "c", Score: 1}, {Value: "g", Score: 1}, @@ -2090,7 +2088,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { // Offset and limit are in where we start and stop counting in the original sorted set (NOT THE RESULT). name: "Get elements within lex range with offset and limit", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -2106,7 +2104,7 @@ func TestEchoVault_ZRANGE(t *testing.T) { { name: "Return an empty map when we use BYLEX while elements have different scores", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "a", Score: 1}, {Value: "b", Score: 5}, {Value: "c", Score: 2}, {Value: "d", Score: 6}, {Value: "e", Score: 3}, {Value: "f", Score: 7}, @@ -2171,7 +2169,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within score range without score", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.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}, @@ -2190,7 +2188,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within score range with score", preset: true, presetValues: map[string]interface{}{ - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.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}, @@ -2211,7 +2209,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within score range with offset and limit", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.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}, @@ -2230,7 +2228,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within lex range without score", preset: true, presetValues: map[string]interface{}{ - "key4": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.MemberParam{ {Value: "a", Score: 1}, {Value: "e", Score: 1}, {Value: "b", Score: 1}, {Value: "f", Score: 1}, {Value: "c", Score: 1}, {Value: "g", Score: 1}, @@ -2249,7 +2247,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within lex range with score", preset: true, presetValues: map[string]interface{}{ - "key5": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.MemberParam{ {Value: "a", Score: 1}, {Value: "e", Score: 1}, {Value: "b", Score: 1}, {Value: "f", Score: 1}, {Value: "c", Score: 1}, {Value: "g", Score: 1}, @@ -2270,7 +2268,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within lex range with offset and limit", preset: true, presetValues: map[string]interface{}{ - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.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}, @@ -2292,7 +2290,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Get elements within lex range with offset and limit + reverse the results", preset: true, presetValues: map[string]interface{}{ - "key7": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key7": ss.NewSortedSet([]ss.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}, @@ -2311,7 +2309,7 @@ func TestEchoVault_ZRANGESTORE(t *testing.T) { name: "Return an empty slice when we use BYLEX while elements have different scores", preset: true, presetValues: map[string]interface{}{ - "key8": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.MemberParam{ {Value: "a", Score: 1}, {Value: "b", Score: 5}, {Value: "c", Score: 2}, {Value: "d", Score: 6}, {Value: "e", Score: 3}, {Value: "f", Score: 7}, @@ -2380,7 +2378,7 @@ func TestEchoVault_ZRANK(t *testing.T) { { name: "Return element's rank from a sorted set", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, @@ -2394,7 +2392,7 @@ func TestEchoVault_ZRANK(t *testing.T) { { name: "Return element's rank from a sorted set with its score", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 100.1}, {Value: "two", Score: 245}, {Value: "three", Score: 305.43}, {Value: "four", Score: 411.055}, {Value: "five", Score: 500}, @@ -2418,7 +2416,7 @@ func TestEchoVault_ZRANK(t *testing.T) { { name: "If key exists and is a sorted set, but the member does not exist, return nil", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1.1}, {Value: "two", Score: 245}, {Value: "three", Score: 3}, {Value: "four", Score: 4.055}, {Value: "five", Score: 5}, @@ -2478,7 +2476,7 @@ func TestEchoVault_ZREM(t *testing.T) { // Return deleted count. name: "Successfully remove multiple elements from sorted set, skipping non-existent members", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -2546,7 +2544,7 @@ func TestEchoVault_ZREMRANGEBYSCORE(t *testing.T) { { name: "Successfully remove multiple elements with scores inside the provided range", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.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}, @@ -2615,7 +2613,7 @@ func TestEchoVault_ZSCORE(t *testing.T) { { name: "Return score from a sorted set", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1.1}, {Value: "two", Score: 245}, {Value: "three", Score: 3}, {Value: "four", Score: 4.055}, {Value: "five", Score: 5}, @@ -2637,7 +2635,7 @@ func TestEchoVault_ZSCORE(t *testing.T) { { name: "If key exists and is a sorted set, but the member does not exist, return nil", preset: true, - presetValue: sorted_set.NewSortedSet([]sorted_set.MemberParam{ + presetValue: ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1.1}, {Value: "two", Score: 245}, {Value: "three", Score: 3}, {Value: "four", Score: 4.055}, {Value: "five", Score: 5}, @@ -2694,12 +2692,12 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 2 sorted sets", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, }), - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.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}, @@ -2719,18 +2717,18 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.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}, @@ -2750,18 +2748,18 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key7": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.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}, @@ -2781,18 +2779,18 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key9": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key9": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key10": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key11": ss.NewSortedSet([]ss.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}, @@ -2812,18 +2810,18 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key12": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key12": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key13": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key14": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -2843,18 +2841,18 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key15": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key15": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key16": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key17": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -2874,18 +2872,18 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key18": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key18": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key19": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key20": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -2903,13 +2901,13 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Throw an error if there are more weights than keys", preset: true, presetValues: map[string]interface{}{ - "key21": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key21": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key22": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{"key21", "key22"}, options: echovault.ZUNIONOptions{Weights: []float64{1, 2, 3}}, @@ -2920,16 +2918,16 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Throw an error if there are fewer weights than keys", preset: true, presetValues: map[string]interface{}{ - "key23": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key23": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key24": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, }), - "key25": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key25": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{"key23", "key24", "key25"}, options: echovault.ZUNIONOptions{Weights: []float64{5, 4}}, @@ -2940,9 +2938,9 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Throw an error if there are no keys provided", preset: true, presetValues: map[string]interface{}{ - "key26": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), - "key27": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), - "key28": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key26": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), + "key27": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), + "key28": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{}, options: echovault.ZUNIONOptions{Weights: []float64{5, 4}}, @@ -2953,14 +2951,14 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "Throw an error if any of the provided keys are not sorted sets", preset: true, presetValues: map[string]interface{}{ - "key29": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key29": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key31": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, keys: []string{"key29", "key30", "key31"}, options: echovault.ZUNIONOptions{}, @@ -2971,12 +2969,12 @@ func TestEchoVault_ZUNION(t *testing.T) { name: "If any of the keys does not exist, skip it", preset: true, presetValues: map[string]interface{}{ - "key32": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key32": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key33": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key33": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -3031,12 +3029,12 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 2 sorted sets", preset: true, presetValues: map[string]interface{}{ - "key1": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key1": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "three", Score: 3}, {Value: "four", Score: 4}, {Value: "five", Score: 5}, }), - "key2": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key2": ss.NewSortedSet([]ss.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}, @@ -3054,18 +3052,18 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key3": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key3": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key4": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key5": ss.NewSortedSet([]ss.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}, @@ -3083,18 +3081,18 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key6": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key6": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key7": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key8": ss.NewSortedSet([]ss.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}, @@ -3112,18 +3110,18 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key9": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key9": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key10": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key11": ss.NewSortedSet([]ss.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}, @@ -3141,18 +3139,18 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key12": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key12": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key13": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key14": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -3170,18 +3168,18 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key15": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key15": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key16": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key17": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -3199,18 +3197,18 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Get the union between 3 sorted sets with scores", preset: true, presetValues: map[string]interface{}{ - "key18": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key18": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key19": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key20": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1000}, {Value: "eight", Score: 800}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, @@ -3226,13 +3224,13 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Throw an error if there are more weights than keys", preset: true, presetValues: map[string]interface{}{ - "key21": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key21": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key22": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination8", keys: []string{"key21", "key22"}, @@ -3244,16 +3242,16 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Throw an error if there are fewer weights than keys", preset: true, presetValues: map[string]interface{}{ - "key23": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key23": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key24": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, }), - "key25": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key25": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination9", keys: []string{"key23", "key24", "key25"}, @@ -3265,14 +3263,14 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "Throw an error if any of the provided keys are not sorted sets", preset: true, presetValues: map[string]interface{}{ - "key29": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key29": ss.NewSortedSet([]ss.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": sorted_set.NewSortedSet([]sorted_set.MemberParam{{Value: "one", Score: 1}}), + "key31": ss.NewSortedSet([]ss.MemberParam{{Value: "one", Score: 1}}), }, destination: "destination11", keys: []string{"key29", "key30", "key31"}, @@ -3284,12 +3282,12 @@ func TestEchoVault_ZUNIONSTORE(t *testing.T) { name: "If any of the keys does not exist, skip it", preset: true, presetValues: map[string]interface{}{ - "key32": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key32": ss.NewSortedSet([]ss.MemberParam{ {Value: "one", Score: 1}, {Value: "two", Score: 2}, {Value: "thirty-six", Score: 36}, {Value: "twelve", Score: 12}, {Value: "eleven", Score: 11}, }), - "key33": sorted_set.NewSortedSet([]sorted_set.MemberParam{ + "key33": ss.NewSortedSet([]ss.MemberParam{ {Value: "seven", Score: 7}, {Value: "eight", Score: 8}, {Value: "nine", Score: 9}, {Value: "ten", Score: 10}, {Value: "twelve", Score: 12}, diff --git a/test/modules/sorted_set/commands_test.go b/test/modules/sorted_set/commands_test.go index 0810b45..bfc31df 100644 --- a/test/modules/sorted_set/commands_test.go +++ b/test/modules/sorted_set/commands_test.go @@ -20,10 +20,9 @@ import ( "errors" "fmt" "github.com/echovault/echovault/internal/config" - "github.com/echovault/echovault/internal/sorted_set" + "github.com/echovault/echovault/internal/modules/sorted_set" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - ss "github.com/echovault/echovault/pkg/modules/sorted_set" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "math" @@ -38,7 +37,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(ss.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction, diff --git a/test/modules/string/api_string_test.go b/test/modules/string/api_string_test.go index 36197c9..6bb96f4 100644 --- a/test/modules/string/api_string_test.go +++ b/test/modules/string/api_string_test.go @@ -18,13 +18,11 @@ import ( "context" "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/echovault" - str "github.com/echovault/echovault/pkg/modules/string" "testing" ) func createEchoVault() *echovault.EchoVault { ev, _ := echovault.NewEchoVault( - echovault.WithCommands(str.Commands()), echovault.WithConfig(config.Config{ DataDir: "", }), diff --git a/test/modules/string/commands_test.go b/test/modules/string/commands_test.go index 9497e45..296501d 100644 --- a/test/modules/string/commands_test.go +++ b/test/modules/string/commands_test.go @@ -23,7 +23,6 @@ import ( "github.com/echovault/echovault/internal/config" "github.com/echovault/echovault/pkg/constants" "github.com/echovault/echovault/pkg/echovault" - str "github.com/echovault/echovault/pkg/modules/string" "github.com/echovault/echovault/pkg/types" "github.com/tidwall/resp" "net" @@ -36,7 +35,6 @@ var mockServer *echovault.EchoVault func init() { mockServer, _ = echovault.NewEchoVault( - echovault.WithCommands(str.Commands()), echovault.WithConfig(config.Config{ DataDir: "", EvictionPolicy: constants.NoEviction,