mirror of https://github.com/tidwall/tile38.git
679 lines
33 KiB
Go
679 lines
33 KiB
Go
package tests
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/rand"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gomodule/redigo/redis"
|
|
"github.com/tidwall/gjson"
|
|
)
|
|
|
|
func subTestKeys(g *testGroup) {
|
|
g.regSubTest("BOUNDS", keys_BOUNDS_test)
|
|
g.regSubTest("DEL", keys_DEL_test)
|
|
g.regSubTest("DROP", keys_DROP_test)
|
|
g.regSubTest("RENAME", keys_RENAME_test)
|
|
g.regSubTest("RENAMENX", keys_RENAMENX_test)
|
|
g.regSubTest("EXPIRE", keys_EXPIRE_test)
|
|
g.regSubTest("FSET", keys_FSET_test)
|
|
g.regSubTest("GET", keys_GET_test)
|
|
g.regSubTest("KEYS", keys_KEYS_test)
|
|
g.regSubTest("PERSIST", keys_PERSIST_test)
|
|
g.regSubTest("SET", keys_SET_test)
|
|
g.regSubTest("STATS", keys_STATS_test)
|
|
g.regSubTest("TTL", keys_TTL_test)
|
|
g.regSubTest("SET EX", keys_SET_EX_test)
|
|
g.regSubTest("PDEL", keys_PDEL_test)
|
|
g.regSubTest("FIELDS", keys_FIELDS_test)
|
|
g.regSubTest("WHEREIN", keys_WHEREIN_test)
|
|
g.regSubTest("WHEREEVAL", keys_WHEREEVAL_test)
|
|
g.regSubTest("TYPE", keys_TYPE_test)
|
|
g.regSubTest("FLUSHDB", keys_FLUSHDB_test)
|
|
g.regSubTest("HEALTHZ", keys_HEALTHZ_test)
|
|
g.regSubTest("SERVER", keys_SERVER_test)
|
|
g.regSubTest("INFO", keys_INFO_test)
|
|
}
|
|
|
|
func keys_BOUNDS_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("BOUNDS", "mykey").Str("<nil>"),
|
|
Do("BOUNDS", "mykey").JSON().Err("key not found"),
|
|
Do("SET", "mykey", "myid1", "POINT", 33, -115).OK(),
|
|
Do("BOUNDS", "mykey").Str("[[-115 33] [-115 33]]"),
|
|
Do("BOUNDS", "mykey").JSON().Str(`{"ok":true,"bounds":{"type":"Point","coordinates":[-115,33]}}`),
|
|
Do("SET", "mykey", "myid2", "POINT", 34, -112).OK(),
|
|
Do("BOUNDS", "mykey").Str("[[-115 33] [-112 34]]"),
|
|
Do("DEL", "mykey", "myid2").Str("1"),
|
|
Do("BOUNDS", "mykey").Str("[[-115 33] [-115 33]]"),
|
|
Do("SET", "mykey", "myid3", "OBJECT", `{"type":"Point","coordinates":[-130,38,10]}`).OK(),
|
|
Do("SET", "mykey", "myid4", "OBJECT", `{"type":"Point","coordinates":[-110,25,-8]}`).OK(),
|
|
Do("BOUNDS", "mykey").Str("[[-130 25] [-110 38]]"),
|
|
Do("BOUNDS", "mykey", "hello").Err("wrong number of arguments for 'bounds' command"),
|
|
Do("BOUNDS", "nada").Str("<nil>"),
|
|
Do("BOUNDS", "nada").JSON().Err("key not found"),
|
|
Do("BOUNDS", "").Str("<nil>"),
|
|
Do("BOUNDS", "mykey").JSON().Str(`{"ok":true,"bounds":{"type":"Polygon","coordinates":[[[-130,25],[-110,25],[-110,38],[-130,38],[-130,25]]]}}`),
|
|
)
|
|
}
|
|
|
|
func keys_DEL_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid", "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid", "POINT").Str("[33 -115]"),
|
|
Do("DEL", "mykey", "myid2", "ERRON404").Err("id not found"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("DEL", "mykey", "myid").Str("0"),
|
|
Do("DEL", "mykey").Err("wrong number of arguments for 'del' command"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
Do("DEL", "mykey", "myid", "ERRON404").Err("key not found"),
|
|
Do("DEL", "mykey", "myid", "invalid-arg").Err("invalid argument 'invalid-arg'"),
|
|
Do("SET", "mykey", "myid", "POINT", 33, -115).OK(),
|
|
Do("DEL", "mykey", "myid2", "ERRON404").JSON().Err("id not found"),
|
|
Do("DEL", "mykey", "myid").JSON().OK(),
|
|
Do("DEL", "mykey", "myid").JSON().OK(),
|
|
Do("DEL", "mykey", "myid", "ERRON404").JSON().Err("key not found"),
|
|
)
|
|
}
|
|
|
|
func keys_DROP_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey", "myid2", "HASH", "9my5xp8").OK(),
|
|
Do("SCAN", "mykey", "COUNT").Str("2"),
|
|
Do("DROP").Err("wrong number of arguments for 'drop' command"),
|
|
Do("DROP", "mykey", "arg3").Err("wrong number of arguments for 'drop' command"),
|
|
Do("DROP", "mykey").Str("1"),
|
|
Do("SCAN", "mykey", "COUNT").Str("0"),
|
|
Do("DROP", "mykey").Str("0"),
|
|
Do("SCAN", "mykey", "COUNT").Str("0"),
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("DROP", "mykey").JSON().OK(),
|
|
Do("DROP", "mykey").JSON().OK(),
|
|
)
|
|
}
|
|
func keys_RENAME_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey", "myid2", "HASH", "9my5xp8").OK(),
|
|
Do("SCAN", "mykey", "COUNT").Str("2"),
|
|
Do("RENAME", "foo", "mynewkey", "arg3").Err("wrong number of arguments for 'rename' command"),
|
|
Do("RENAME", "mykey", "mynewkey").OK(),
|
|
Do("SCAN", "mykey", "COUNT").Str("0"),
|
|
Do("SCAN", "mynewkey", "COUNT").Str("2"),
|
|
Do("SET", "mykey", "myid3", "HASH", "9my5xp7").OK(),
|
|
Do("RENAME", "mykey", "mynewkey").OK(),
|
|
Do("SCAN", "mykey", "COUNT").Str("0"),
|
|
Do("SCAN", "mynewkey", "COUNT").Str("1"),
|
|
Do("RENAME", "foo", "mynewkey").Err("key not found"),
|
|
Do("SCAN", "mynewkey", "COUNT").Str("1"),
|
|
Do("SETCHAN", "mychan", "INTERSECTS", "mynewkey", "BOUNDS", 10, 10, 20, 20).Str("1"),
|
|
Do("RENAME", "mynewkey", "foo2").Err("key has hooks set"),
|
|
Do("RENAMENX", "mynewkey", "foo2").Err("key has hooks set"),
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("RENAME", "mykey", "foo2").OK(),
|
|
Do("RENAMENX", "foo2", "foo3").Str("1"),
|
|
Do("RENAMENX", "foo2", "foo3").Err("key not found"),
|
|
Do("RENAME", "foo2", "foo3").JSON().Err("key not found"),
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("RENAMENX", "mykey", "foo3").Str("0"),
|
|
Do("RENAME", "foo3", "foo4").JSON().OK(),
|
|
)
|
|
}
|
|
func keys_RENAMENX_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey", "myid2", "HASH", "9my5xp8").OK(),
|
|
Do("SCAN", "mykey", "COUNT").Str("2"),
|
|
Do("RENAMENX", "mykey", "mynewkey").Str("1"),
|
|
Do("SCAN", "mykey", "COUNT").Str("0"),
|
|
Do("DROP", "mykey").Str("0"),
|
|
Do("SCAN", "mykey", "COUNT").Str("0"),
|
|
Do("SCAN", "mynewkey", "COUNT").Str("2"),
|
|
Do("SET", "mykey", "myid3", "HASH", "9my5xp7").OK(),
|
|
Do("RENAMENX", "mykey", "mynewkey").Str("0"),
|
|
Do("SCAN", "mykey", "COUNT").Str("1"),
|
|
Do("SCAN", "mynewkey", "COUNT").Str("2"),
|
|
Do("RENAMENX", "foo", "mynewkey").Str("ERR key not found"),
|
|
Do("SCAN", "mynewkey", "COUNT").Str("2"),
|
|
)
|
|
}
|
|
func keys_EXPIRE_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("EXPIRE", "mykey", "myid").Err("wrong number of arguments for 'expire' command"),
|
|
Do("EXPIRE", "mykey", "myid", "y").Err("invalid argument 'y'"),
|
|
Do("EXPIRE", "mykey", "myid", 1).Str("1"),
|
|
Do("EXPIRE", "mykey", "myid", 1).JSON().OK(),
|
|
Sleep(time.Second/4),
|
|
Do("GET", "mykey", "myid").Str("value"),
|
|
Sleep(time.Second),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
Do("EXPIRE", "mykey", "myid", 1).JSON().Err("key not found"),
|
|
Do("SET", "mykey", "myid1", "STRING", "value1").OK(),
|
|
Do("SET", "mykey", "myid2", "STRING", "value2").OK(),
|
|
Do("EXPIRE", "mykey", "myid1", 1).Str("1"),
|
|
Sleep(time.Second/4),
|
|
Do("GET", "mykey", "myid1").Str("value1"),
|
|
Sleep(time.Second),
|
|
Do("EXPIRE", "mykey", "myid1", 1).Str("0"),
|
|
Do("EXPIRE", "mykey", "myid1", 1).JSON().Err("id not found"),
|
|
)
|
|
}
|
|
func keys_FSET_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid", "HASH", "9my5xp7").OK(),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7]"),
|
|
Do("FSET", "mykey", "myid", "f1", 105.6).Str("1"),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7 [f1 105.6]]"),
|
|
Do("FSET", "mykey", "myid", "f1", 1.1, "f2", 2.2).Str("2"),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7 [f1 1.1 f2 2.2]]"),
|
|
Do("FSET", "mykey", "myid", "f1", 1.1, "f2", 22.22).Str("1"),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7 [f1 1.1 f2 22.22]]"),
|
|
Do("FSET", "mykey", "myid", "f1", 0).Str("1"),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7 [f2 22.22]]"),
|
|
Do("FSET", "mykey", "myid", "f2", 0).Str("1"),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7]"),
|
|
Do("FSET", "mykey", "myid2", "xx", "f1", 1.1, "f2", 2.2).Str("0"),
|
|
Do("GET", "mykey", "myid2").Str("<nil>"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
Do("SET", "mykey", "myid", "HASH", "9my5xp7").OK(),
|
|
Do("CONFIG", "SET", "maxmemory", "1").OK(),
|
|
Do("FSET", "mykey", "myid", "xx", "f1", 1.1, "f2", 2.2).Err(`OOM command not allowed when used memory > 'maxmemory'`),
|
|
Do("CONFIG", "SET", "maxmemory", "0").OK(),
|
|
Do("FSET", "mykey", "myid", "xx").Err("wrong number of arguments for 'fset' command"),
|
|
Do("FSET", "mykey", "myid", "f1", "a", "f2").Err("wrong number of arguments for 'fset' command"),
|
|
Do("FSET", "mykey", "myid", "z", "a").Err("invalid argument 'z'"),
|
|
Do("FSET", "mykey2", "myid", "a", "b").Err("key not found"),
|
|
Do("FSET", "mykey", "myid2", "a", "b").Err("id not found"),
|
|
Do("FSET", "mykey", "myid", "f2", 0).JSON().OK(),
|
|
)
|
|
}
|
|
func keys_GET_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("GET", "mykey", "myid").Str("value"),
|
|
Do("SET", "mykey", "myid", "STRING", "value2").OK(),
|
|
Do("GET", "mykey", "myid").Str("value2"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
Do("GET", "mykey").Err("wrong number of arguments for 'get' command"),
|
|
Do("GET", "mykey", "myid", "hash").Err("wrong number of arguments for 'get' command"),
|
|
Do("GET", "mykey", "myid", "hash", "0").Err("invalid argument '0'"),
|
|
Do("GET", "mykey", "myid", "hash", "-1").Err("invalid argument '-1'"),
|
|
Do("GET", "mykey", "myid", "hash", "13").Err("invalid argument '13'"),
|
|
Do("SET", "mykey", "myid", "field", "hello", "world", "field", "hiya", 55, "point", 33, -112).OK(),
|
|
Do("GET", "mykey", "myid", "hash", "1").Str("9"),
|
|
Do("GET", "mykey", "myid", "point").Str("[33 -112]"),
|
|
Do("GET", "mykey", "myid", "bounds").Str("[[33 -112] [33 -112]]"),
|
|
Do("GET", "mykey", "myid", "object").Str(`{"type":"Point","coordinates":[-112,33]}`),
|
|
Do("GET", "mykey", "myid", "object").Str(`{"type":"Point","coordinates":[-112,33]}`),
|
|
Do("GET", "mykey", "myid", "withfields", "point").Str(`[[33 -112] [hello world hiya 55]]`),
|
|
Do("GET", "mykey", "myid", "joint").Err("wrong number of arguments for 'get' command"),
|
|
Do("GET", "mykey2", "myid").Str("<nil>"),
|
|
Do("GET", "mykey2", "myid").JSON().Err("key not found"),
|
|
Do("GET", "mykey", "myid2").Str("<nil>"),
|
|
Do("GET", "mykey", "myid2").JSON().Err("id not found"),
|
|
Do("GET", "mykey", "myid", "point").JSON().Str(`{"ok":true,"point":{"lat":33,"lon":-112}}`),
|
|
Do("GET", "mykey", "myid", "object").JSON().Str(`{"ok":true,"object":{"type":"Point","coordinates":[-112,33]}}`),
|
|
Do("GET", "mykey", "myid", "hash", "1").JSON().Str(`{"ok":true,"hash":"9"}`),
|
|
Do("GET", "mykey", "myid", "bounds").JSON().Str(`{"ok":true,"bounds":{"sw":{"lat":33,"lon":-112},"ne":{"lat":33,"lon":-112}}}`),
|
|
Do("SET", "mykey", "myid2", "point", 33, -112, 55).OK(),
|
|
Do("GET", "mykey", "myid2", "point").Str("[33 -112 55]"),
|
|
Do("GET", "mykey", "myid2", "point").JSON().Str(`{"ok":true,"point":{"lat":33,"lon":-112,"z":55}}`),
|
|
Do("GET", "mykey", "myid", "withfields").JSON().Str(`{"ok":true,"object":{"type":"Point","coordinates":[-112,33]},"fields":{"hello":"world","hiya":55}}`),
|
|
)
|
|
}
|
|
func keys_KEYS_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey11", "myid4", "STRING", "value").OK(),
|
|
Do("SET", "mykey22", "myid2", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey22", "myid1", "OBJECT", `{"type":"Point","coordinates":[-130,38,10]}`).OK(),
|
|
Do("SET", "mykey11", "myid3", "OBJECT", `{"type":"Point","coordinates":[-110,25,-8]}`).OK(),
|
|
Do("SET", "mykey42", "myid2", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey31", "myid4", "STRING", "value").OK(),
|
|
Do("SET", "mykey310", "myid5", "STRING", "value").OK(),
|
|
Do("KEYS", "*").Str("[mykey11 mykey22 mykey31 mykey310 mykey42]"),
|
|
Do("KEYS", "*key*").Str("[mykey11 mykey22 mykey31 mykey310 mykey42]"),
|
|
Do("KEYS", "mykey*").Str("[mykey11 mykey22 mykey31 mykey310 mykey42]"),
|
|
Do("KEYS", "mykey4*").Str("[mykey42]"),
|
|
Do("KEYS", "mykey*1").Str("[mykey11 mykey31]"),
|
|
Do("KEYS", "mykey*1*").Str("[mykey11 mykey31 mykey310]"),
|
|
Do("KEYS", "mykey*10").Str("[mykey310]"),
|
|
Do("KEYS", "mykey*2").Str("[mykey22 mykey42]"),
|
|
Do("KEYS", "*2").Str("[mykey22 mykey42]"),
|
|
Do("KEYS", "*1*").Str("[mykey11 mykey31 mykey310]"),
|
|
Do("KEYS", "mykey").Str("[]"),
|
|
Do("KEYS", "mykey31").Str("[mykey31]"),
|
|
Do("KEYS", "mykey[^3]*").Str("[mykey11 mykey22 mykey42]"),
|
|
Do("KEYS").Err("wrong number of arguments for 'keys' command"),
|
|
Do("KEYS", "*").JSON().Str(`{"ok":true,"keys":["mykey11","mykey22","mykey31","mykey310","mykey42"]}`),
|
|
)
|
|
}
|
|
func keys_PERSIST_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("EXPIRE", "mykey", "myid", 2).Str("1"),
|
|
Do("PERSIST", "mykey", "myid").Str("1"),
|
|
Do("PERSIST", "mykey", "myid").Str("0"),
|
|
Do("PERSIST", "mykey").Err("wrong number of arguments for 'persist' command"),
|
|
Do("PERSIST", "mykey2", "myid").Str("0"),
|
|
Do("PERSIST", "mykey2", "myid").JSON().Err("key not found"),
|
|
Do("PERSIST", "mykey", "myid2").Str("0"),
|
|
Do("PERSIST", "mykey", "myid2").JSON().Err("id not found"),
|
|
Do("EXPIRE", "mykey", "myid", 2).Str("1"),
|
|
Do("PERSIST", "mykey", "myid").JSON().OK(),
|
|
)
|
|
}
|
|
func keys_SET_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
// Section: point
|
|
Do("SET", "mykey", "myid", "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid", "POINT").Str("[33 -115]"),
|
|
Do("GET", "mykey", "myid", "BOUNDS").Str("[[33 -115] [33 -115]]"),
|
|
Do("GET", "mykey", "myid", "OBJECT").Str(`{"type":"Point","coordinates":[-115,33]}`),
|
|
Do("GET", "mykey", "myid", "HASH", 7).Str("9my5xp7"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
Do("SET", "mykey", "myid", "point", "33", "-112", "99").OK(),
|
|
|
|
// Section: object
|
|
Do("SET", "mykey", "myid", "OBJECT", `{"type":"Point","coordinates":[-115,33]}`).OK(),
|
|
Do("GET", "mykey", "myid", "POINT").Str("[33 -115]"),
|
|
Do("GET", "mykey", "myid", "BOUNDS").Str("[[33 -115] [33 -115]]"),
|
|
Do("GET", "mykey", "myid", "OBJECT").Str(`{"type":"Point","coordinates":[-115,33]}`),
|
|
Do("GET", "mykey", "myid", "HASH", 7).Str("9my5xp7"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
|
|
// Section: bounds
|
|
Do("SET", "mykey", "myid", "BOUNDS", 33, -115, 33, -115).OK(),
|
|
Do("GET", "mykey", "myid", "POINT").Str("[33 -115]"),
|
|
Do("GET", "mykey", "myid", "BOUNDS").Str("[[33 -115] [33 -115]]"),
|
|
Do("GET", "mykey", "myid", "OBJECT").Str(`{"type":"Point","coordinates":[-115,33]}`),
|
|
Do("GET", "mykey", "myid", "HASH", 7).Str("9my5xp7"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
|
|
// Section: hash
|
|
Do("SET", "mykey", "myid", "HASH", "9my5xp7").OK(),
|
|
Do("GET", "mykey", "myid", "HASH", 7).Str("9my5xp7"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
Do("SET", "mykey", "myid", "HASH", "9my5xp7").JSON().OK(),
|
|
|
|
// Section: field
|
|
Do("SET", "mykey", "myid", "FIELD", "f1", 33, "FIELD", "a2", 44.5, "HASH", "9my5xp7").OK(),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7 [a2 44.5 f1 33]]"),
|
|
Do("FSET", "mykey", "myid", "f1", 0).Str("1"),
|
|
Do("FSET", "mykey", "myid", "f1", 0).Str("0"),
|
|
Do("GET", "mykey", "myid", "WITHFIELDS", "HASH", 7).Str("[9my5xp7 [a2 44.5]]"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
|
|
// Section: string
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("GET", "mykey", "myid").Str("value"),
|
|
Do("SET", "mykey", "myid", "STRING", "value2").OK(),
|
|
Do("GET", "mykey", "myid").Str("value2"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("GET", "mykey", "myid").Str("<nil>"),
|
|
|
|
// Test error conditions
|
|
Do("CONFIG", "SET", "maxmemory", "1").OK(),
|
|
Do("SET", "mykey", "myid", "STRING", "value2").Err("OOM command not allowed when used memory > 'maxmemory'"),
|
|
Do("CONFIG", "SET", "maxmemory", "0").OK(),
|
|
Do("SET").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "FIELD", "f1").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "FIELD", "z", "1").Err("invalid argument 'z'"),
|
|
Do("SET", "mykey", "myid", "EX").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "EX", "yyy").Err("invalid argument 'yyy'"),
|
|
Do("SET", "mykey", "myid", "EX", "123").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "nx").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "nx", "xx").Err("invalid argument 'xx'"),
|
|
Do("SET", "mykey", "myid", "xx", "nx").Err("invalid argument 'nx'"),
|
|
Do("SET", "mykey", "myid", "string").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "point").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "point", "33").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "point", "33f", "-112").Err("invalid argument '33f'"),
|
|
Do("SET", "mykey", "myid", "point", "33", "-112f").Err("invalid argument '-112f'"),
|
|
Do("SET", "mykey", "myid", "point", "33", "-112f", "99").Err("invalid argument '-112f'"),
|
|
Do("SET", "mykey", "myid", "bounds").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "bounds", "fff", "1", "2", "3").Err("invalid argument 'fff'"),
|
|
Do("SET", "mykey", "myid", "hash").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "object").Err("wrong number of arguments for 'set' command"),
|
|
Do("SET", "mykey", "myid", "object", "asd").Err("invalid data"),
|
|
Do("SET", "mykey", "myid", "joint").Err("invalid argument 'joint'"),
|
|
Do("SET", "mykey", "myid", "XX", "HASH", "9my5xp7").Err("<nil>"),
|
|
Do("SET", "mykey", "myid", "XX", "HASH", "9my5xp7").JSON().Err("id not found"),
|
|
Do("SET", "mykey", "myid1", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey", "myid", "XX", "HASH", "9my5xp7").Err("<nil>"),
|
|
Do("SET", "mykey", "myid", "NX", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey", "myid", "XX", "HASH", "9my5xp7").OK(),
|
|
Do("SET", "mykey", "myid", "NX", "HASH", "9my5xp7").Err("<nil>"),
|
|
Do("SET", "mykey", "myid", "NX", "HASH", "9my5xp7").JSON().Err("id already exists"),
|
|
)
|
|
}
|
|
|
|
func keys_STATS_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("STATS", "mykey").Str("[nil]"),
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("STATS", "mykey").Str("[[in_memory_size 9 num_objects 1 num_points 0 num_strings 1]]"),
|
|
Do("STATS", "mykey", "hello").JSON().Str(`{"ok":true,"stats":[{"in_memory_size":9,"num_objects":1,"num_points":0,"num_strings":1},null]}`),
|
|
Do("SET", "mykey", "myid2", "STRING", "value").OK(),
|
|
Do("STATS", "mykey").Str("[[in_memory_size 19 num_objects 2 num_points 0 num_strings 2]]"),
|
|
Do("SET", "mykey", "myid3", "OBJECT", `{"type":"Point","coordinates":[-115,33]}`).OK(),
|
|
Do("STATS", "mykey").Str("[[in_memory_size 40 num_objects 3 num_points 1 num_strings 2]]"),
|
|
Do("DEL", "mykey", "myid").Str("1"),
|
|
Do("STATS", "mykey").Str("[[in_memory_size 31 num_objects 2 num_points 1 num_strings 1]]"),
|
|
Do("DEL", "mykey", "myid3").Str("1"),
|
|
Do("STATS", "mykey").Str("[[in_memory_size 10 num_objects 1 num_points 0 num_strings 1]]"),
|
|
Do("STATS", "mykey", "mykey2").Str("[[in_memory_size 10 num_objects 1 num_points 0 num_strings 1] nil]"),
|
|
Do("DEL", "mykey", "myid2").Str("1"),
|
|
Do("STATS", "mykey").Str("[nil]"),
|
|
Do("STATS", "mykey", "mykey2").Str("[nil nil]"),
|
|
Do("STATS", "mykey").Str("[nil]"),
|
|
Do("STATS").Err(`wrong number of arguments for 'stats' command`),
|
|
)
|
|
}
|
|
func keys_TTL_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("EXPIRE", "mykey", "myid", 2).Str("1"),
|
|
Do("EXPIRE", "mykey", "myid", 2).JSON().OK(),
|
|
Sleep(time.Millisecond*10),
|
|
Do("TTL", "mykey", "myid").Str("1"),
|
|
Do("EXPIRE", "mykey", "myid", 1).Str("1"),
|
|
Sleep(time.Millisecond*10),
|
|
Do("TTL", "mykey", "myid").Str("0"),
|
|
Do("TTL", "mykey", "myid").JSON().Str(`{"ok":true,"ttl":0}`),
|
|
Do("TTL", "mykey2", "myid").Str("-2"),
|
|
Do("TTL", "mykey", "myid2").Str("-2"),
|
|
Do("TTL", "mykey").Err("wrong number of arguments for 'ttl' command"),
|
|
Do("SET", "mykey", "myid", "STRING", "value").OK(),
|
|
Do("TTL", "mykey", "myid").Str("-1"),
|
|
Do("TTL", "mykey2", "myid").JSON().Err("key not found"),
|
|
Do("TTL", "mykey", "myid2").JSON().Err("id not found"),
|
|
)
|
|
}
|
|
|
|
func keys_SET_EX_test(mc *mockServer) (err error) {
|
|
rand.Seed(time.Now().UnixNano())
|
|
|
|
// add a bunch of points
|
|
for i := 0; i < 20000; i++ {
|
|
val := fmt.Sprintf("val:%d", i)
|
|
var resp string
|
|
var lat, lon float64
|
|
lat = rand.Float64()*180 - 90
|
|
lon = rand.Float64()*360 - 180
|
|
resp, err = redis.String(mc.conn.Do("SET",
|
|
fmt.Sprintf("mykey%d", i%3), val,
|
|
"EX", 1+rand.Float64(),
|
|
"POINT", lat, lon))
|
|
if err != nil {
|
|
return
|
|
}
|
|
if resp != "OK" {
|
|
err = fmt.Errorf("expected 'OK', got '%s'", resp)
|
|
return
|
|
}
|
|
time.Sleep(time.Nanosecond)
|
|
}
|
|
time.Sleep(time.Second * 3)
|
|
mc.conn.Do("OUTPUT", "json")
|
|
json, _ := redis.String(mc.conn.Do("SERVER"))
|
|
if !gjson.Get(json, "ok").Bool() {
|
|
return errors.New("not ok")
|
|
}
|
|
if gjson.Get(json, "stats.num_objects").Int() > 0 {
|
|
return errors.New("items left in database")
|
|
}
|
|
mc.conn.Do("FLUSHDB")
|
|
return nil
|
|
}
|
|
|
|
func keys_FIELDS_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid1a", "FIELD", "a", 1, "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid1a", "WITHFIELDS").Str(`[{"type":"Point","coordinates":[-115,33]} [a 1]]`),
|
|
Do("SET", "mykey", "myid1a", "FIELD", "a", "a", "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid1a", "WITHFIELDS").Str(`[{"type":"Point","coordinates":[-115,33]} [a a]]`),
|
|
Do("SET", "mykey", "myid1a", "FIELD", "a", 1, "FIELD", "b", 2, "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid1a", "WITHFIELDS").Str(`[{"type":"Point","coordinates":[-115,33]} [a 1 b 2]]`),
|
|
Do("SET", "mykey", "myid1a", "FIELD", "b", 2, "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid1a", "WITHFIELDS").Str(`[{"type":"Point","coordinates":[-115,33]} [a 1 b 2]]`),
|
|
Do("SET", "mykey", "myid1a", "FIELD", "b", 2, "FIELD", "a", "1", "FIELD", "c", 3, "POINT", 33, -115).OK(),
|
|
Do("GET", "mykey", "myid1a", "WITHFIELDS").Str(`[{"type":"Point","coordinates":[-115,33]} [a 1 b 2 c 3]]`),
|
|
|
|
Do("GET", "fleet", "truck1", "WITHFIELDS").JSON().Err("key not found"),
|
|
Do("SET", "fleet", "truck1", "FIELD", "speed", "0", "POINT", "-112", "33").JSON().OK(),
|
|
Do("GET", "fleet", "truck1", "WITHFIELDS").JSON().Str(`{"ok":true,"object":{"type":"Point","coordinates":[33,-112]}}`),
|
|
Do("SET", "fleet", "truck1", "FIELD", "speed", "1", "POINT", "-112", "33").JSON().OK(),
|
|
Do("GET", "fleet", "truck1", "WITHFIELDS").JSON().Str(`{"ok":true,"object":{"type":"Point","coordinates":[33,-112]},"fields":{"speed":1}}`),
|
|
Do("SET", "fleet", "truck1", "FIELD", "speed", "0", "POINT", "-112", "33").JSON().OK(),
|
|
Do("GET", "fleet", "truck1", "WITHFIELDS").JSON().Str(`{"ok":true,"object":{"type":"Point","coordinates":[33,-112]}}`),
|
|
Do("SET", "fleet", "truck1", "FIELD", "speed", "2", "POINT", "-112", "33").JSON().OK(),
|
|
Do("GET", "fleet", "truck1", "WITHFIELDS").JSON().Str(`{"ok":true,"object":{"type":"Point","coordinates":[33,-112]},"fields":{"speed":2}}`),
|
|
|
|
// Do some GJSON queries.
|
|
Do("SET", "fleet", "truck2", "FIELD", "hello", `{"world":"tom"}`, "POINT", "-112", "33").JSON().OK(),
|
|
Do("SCAN", "fleet", "WHERE", "hello", `{"world":"tom"}`, `{"world":"tom"}`, "COUNT").JSON().Str(`{"ok":true,"count":1,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world == 'tom'", "COUNT").JSON().Str(`{"ok":true,"count":1,"cursor":0}`),
|
|
// The next scan does not match on anything, but since we're matching
|
|
// on zeros, which is the default, then all (two) objects are returned.
|
|
Do("SCAN", "fleet", "WHERE", "hello.world.1", `0`, `0`, "IDS").JSON().Str(`{"ok":true,"ids":["truck1","truck2"],"count":2,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", ">", `tom`, "IDS").JSON().Str(`{"ok":true,"ids":[],"count":0,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", ">=", `Tom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck2"],"count":1,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", ">=", `tom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck2"],"count":1,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", "==", `tom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck2"],"count":1,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", "<", `tom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck1"],"count":1,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", "<=", `tom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck1","truck2"],"count":2,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", "<", `uom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck1","truck2"],"count":2,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "hello.world", "!=", `tom`, "IDS").JSON().Str(`{"ok":true,"ids":["truck1"],"count":1,"cursor":0}`),
|
|
|
|
Do("SET", "fleet", "truck1", "OBJECT", `{"type":"Feature","geometry":{"type":"Point","coordinates":[-112,33]},"properties":{"speed":50},"asdf":"Adsf"}`).JSON().OK(),
|
|
Do("SCAN", "fleet", "WHERE", "properties.speed", ">", 49, "IDS").JSON().Str(`{"ok":true,"ids":["truck1"],"count":1,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "properties.speed", ">", 50, "IDS").JSON().Str(`{"ok":true,"ids":[],"count":0,"cursor":0}`),
|
|
Do("SCAN", "fleet", "WHERE", "properties.speed", "<", 51, "IDS").JSON().Str(`{"ok":true,"ids":["truck1","truck2"],"count":2,"cursor":0}`),
|
|
)
|
|
}
|
|
|
|
func keys_PDEL_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid1a", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid1b", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid2a", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid2b", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid3a", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid3b", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid4a", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid4b", "POINT", 33, -115).OK(),
|
|
Do("PDEL", "mykey").Err("wrong number of arguments for 'pdel' command"),
|
|
Do("PDEL", "mykeyNA", "*").Str("0"),
|
|
Do("PDEL", "mykey", "myid1a").Str("1"),
|
|
Do("PDEL", "mykey", "myid1a").Str("0"),
|
|
Do("PDEL", "mykey", "myid1*").Str("1"),
|
|
Do("PDEL", "mykey", "myid2*").Str("2"),
|
|
Do("PDEL", "mykey", "*b").Str("2"),
|
|
Do("PDEL", "mykey", "*").Str("2"),
|
|
Do("PDEL", "mykey", "*").Str("0"),
|
|
Do("SET", "mykey", "myid1a", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid1b", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid2a", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid2b", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey", "myid3a", "POINT", 33, -115).OK(),
|
|
Do("PDEL", "mykey", "*").JSON().OK(),
|
|
)
|
|
}
|
|
|
|
func keys_WHEREIN_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid_a1", "FIELD", "a", 1, "POINT", 33, -115).OK(),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", 3, 0, 1, 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str(`[0 [[myid_a1 {"type":"Point","coordinates":[-115,33]} [a 1]]]]`),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", "a", 0, 1, 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Err("invalid argument 'a'"),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", 1, 0, 1, 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Err("invalid argument '1'"),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", 3, 0, "a", 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str("[0 []]"),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", 4, 0, "a", 1, 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str(`[0 [[myid_a1 {"type":"Point","coordinates":[-115,33]} [a 1]]]]`),
|
|
Do("SET", "mykey", "myid_a2", "FIELD", "a", 2, "POINT", 32.99, -115).OK(),
|
|
Do("SET", "mykey", "myid_a3", "FIELD", "a", 3, "POINT", 33, -115.02).OK(),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", 3, 0, 1, 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str(`[0 [[myid_a2 {"type":"Point","coordinates":[-115,32.99]} [a 2]] [myid_a1 {"type":"Point","coordinates":[-115,33]} [a 1]]]]`),
|
|
// zero value should not match 1 and 2
|
|
Do("SET", "mykey", "myid_a0", "FIELD", "a", 0, "POINT", 33, -115.02).OK(),
|
|
Do("WITHIN", "mykey", "WHEREIN", "a", 2, 1, 2, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str(`[0 [[myid_a2 {"type":"Point","coordinates":[-115,32.99]} [a 2]] [myid_a1 {"type":"Point","coordinates":[-115,33]} [a 1]]]]`),
|
|
)
|
|
}
|
|
|
|
func keys_WHEREEVAL_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid_a1", "FIELD", "a", 1, "POINT", 33, -115).OK(),
|
|
Do("WITHIN", "mykey", "WHEREEVAL", "return FIELDS.a > tonumber(ARGV[1])", 1, 0.5, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str(`[0 [[myid_a1 {"type":"Point","coordinates":[-115,33]} [a 1]]]]`),
|
|
Do("WITHIN", "mykey", "WHEREEVAL", "return FIELDS.a > tonumber(ARGV[1])", "a", 0.5, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Err("invalid argument 'a'"),
|
|
Do("WITHIN", "mykey", "WHEREEVAL", "return FIELDS.a > tonumber(ARGV[1])", 1, 0.5, 4, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Err("invalid argument '4'"),
|
|
Do("SET", "mykey", "myid_a2", "FIELD", "a", 2, "POINT", 32.99, -115).OK(),
|
|
Do("SET", "mykey", "myid_a3", "FIELD", "a", 3, "POINT", 33, -115.02).OK(),
|
|
Do("WITHIN", "mykey", "WHEREEVAL", "return FIELDS.a > tonumber(ARGV[1]) and FIELDS.a ~= tonumber(ARGV[2])", 2, 0.5, 3, "BOUNDS", 32.8, -115.2, 33.2, -114.8).Str(`[0 [[myid_a2 {"type":"Point","coordinates":[-115,32.99]} [a 2]] [myid_a1 {"type":"Point","coordinates":[-115,33]} [a 1]]]]`),
|
|
)
|
|
}
|
|
|
|
func keys_TYPE_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey", "myid1", "POINT", 33, -115).OK(),
|
|
Do("TYPE", "mykey").Str("hash"),
|
|
Do("TYPE", "mykey", "hello").Err("wrong number of arguments for 'type' command"),
|
|
Do("TYPE", "mykey2").Str("none"),
|
|
Do("TYPE", "mykey2").JSON().Err("key not found"),
|
|
Do("TYPE", "mykey").JSON().Str(`{"ok":true,"type":"hash"}`),
|
|
)
|
|
}
|
|
|
|
func keys_FLUSHDB_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SET", "mykey1", "myid1", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey2", "myid1", "POINT", 33, -115).OK(),
|
|
Do("SETCHAN", "mychan", "INTERSECTS", "mykey1", "BOUNDS", 10, 10, 10, 10).Str("1"),
|
|
Do("KEYS", "*").Str("[mykey1 mykey2]"),
|
|
Do("CHANS", "*").JSON().Func(func(s string) error {
|
|
if gjson.Get(s, "chans.#").Int() != 1 {
|
|
return fmt.Errorf("expected '%d', got '%d'", 1, gjson.Get(s, "chans.#").Int())
|
|
}
|
|
return nil
|
|
}),
|
|
Do("FLUSHDB", "arg2").Err("wrong number of arguments for 'flushdb' command"),
|
|
Do("FLUSHDB").OK(),
|
|
Do("KEYS", "*").Str("[]"),
|
|
Do("CHANS", "*").Str("[]"),
|
|
Do("SET", "mykey1", "myid1", "POINT", 33, -115).OK(),
|
|
Do("SET", "mykey2", "myid1", "POINT", 33, -115).OK(),
|
|
Do("SETCHAN", "mychan", "INTERSECTS", "mykey1", "BOUNDS", 10, 10, 10, 10).Str("1"),
|
|
Do("FLUSHDB").JSON().OK(),
|
|
)
|
|
}
|
|
|
|
func keys_HEALTHZ_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("HEALTHZ").OK(),
|
|
Do("HEALTHZ").JSON().OK(),
|
|
Do("HEALTHZ", "arg").Err(`wrong number of arguments for 'healthz' command`),
|
|
)
|
|
}
|
|
|
|
func keys_SERVER_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("SERVER").Func(func(s string) error {
|
|
valid := strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") &&
|
|
strings.Contains(s, "cpus") && strings.Contains(s, "mem_alloc")
|
|
if !valid {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("SERVER").JSON().Func(func(s string) error {
|
|
if !gjson.Get(s, "ok").Bool() {
|
|
return errors.New("not ok")
|
|
}
|
|
valid := gjson.Get(s, "stats.cpus").Exists() &&
|
|
gjson.Get(s, "stats.mem_alloc").Exists()
|
|
if !valid {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("SERVER", "ext").Func(func(s string) error {
|
|
valid := strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") &&
|
|
strings.Contains(s, "sys_cpus") &&
|
|
strings.Contains(s, "tile38_connected_clients")
|
|
|
|
if !valid {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("SERVER", "ext").JSON().Func(func(s string) error {
|
|
if !gjson.Get(s, "ok").Bool() {
|
|
return errors.New("not ok")
|
|
}
|
|
valid := gjson.Get(s, "stats.sys_cpus").Exists() &&
|
|
gjson.Get(s, "stats.tile38_connected_clients").Exists()
|
|
if !valid {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("SERVER", "ett").Err(`invalid argument 'ett'`),
|
|
Do("SERVER", "ett").JSON().Err(`invalid argument 'ett'`),
|
|
)
|
|
}
|
|
|
|
func keys_INFO_test(mc *mockServer) error {
|
|
return mc.DoBatch(
|
|
Do("INFO").Func(func(s string) error {
|
|
if !strings.Contains(s, "# Clients") ||
|
|
!strings.Contains(s, "# Stats") {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("INFO", "all").Func(func(s string) error {
|
|
if !strings.Contains(s, "# Clients") ||
|
|
!strings.Contains(s, "# Stats") {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("INFO", "default").Func(func(s string) error {
|
|
if !strings.Contains(s, "# Clients") ||
|
|
!strings.Contains(s, "# Stats") {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("INFO", "cpu").Func(func(s string) error {
|
|
if !strings.Contains(s, "# CPU") ||
|
|
strings.Contains(s, "# Clients") ||
|
|
strings.Contains(s, "# Stats") {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("INFO", "cpu", "clients").Func(func(s string) error {
|
|
if !strings.Contains(s, "# CPU") ||
|
|
!strings.Contains(s, "# Clients") ||
|
|
strings.Contains(s, "# Stats") {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
Do("INFO").JSON().Func(func(s string) error {
|
|
if gjson.Get(s, "info.tile38_version").String() == "" {
|
|
return errors.New("looks invalid")
|
|
}
|
|
return nil
|
|
}),
|
|
)
|
|
}
|