forked from mirror/ledisdb
859 lines
16 KiB
Lua
859 lines
16 KiB
Lua
--[[
|
|
Stupid test codes for ledis.lua. Running based on openresty configuration file.
|
|
Remember setting up your `lua_package_path`.
|
|
|
|
location = /test {
|
|
default_type "application/json";
|
|
content_by_lua_file /path/to/ledis_test.lua;
|
|
}
|
|
|
|
Then use `curl` or other http clients to see the output.
|
|
--]]
|
|
|
|
local ledis = require "ledis"
|
|
|
|
-- if you want to test add_commands, remove the command from
|
|
-- `local commands `, e.g.: ``get``, then use ``add_commands`` to add
|
|
-- command ``get``
|
|
|
|
--ledis.add_commands("get")
|
|
|
|
local lds = ledis:new()
|
|
|
|
lds:set_timeout(1000)
|
|
|
|
-- connect
|
|
local ok, err = lds:connect("127.0.0.1", "6380")
|
|
if not ok then
|
|
ngx.say("failed to connect:", err)
|
|
return
|
|
end
|
|
|
|
function cleanUp()
|
|
lds:del("mykey", "key1", "key2", "key3", "non_exists_key")
|
|
lds:hmclear("myhash", "myhash1", "myhash2")
|
|
lds:lclear("mylist")
|
|
lds:zmclear("myset", "myset1", "myset2")
|
|
return
|
|
end
|
|
|
|
cleanUp()
|
|
|
|
ngx.say("======================= K/V =====================\n")
|
|
|
|
--[[KV]]--
|
|
|
|
-- decr
|
|
local res, err = lds:decr("mykey")
|
|
if not res then
|
|
ngx.say("failed to decr:", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("DECR, should be: -1 <=> ", res)
|
|
|
|
lds:del("mykey")
|
|
|
|
-- decrby
|
|
local res, err = lds:decrby("mykey", 10)
|
|
if not res then
|
|
ngx.say("failed to decrby:", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("DECRBY, should be: -10 <=> ", res)
|
|
lds:del("mykey")
|
|
|
|
-- del
|
|
lds:set("key1", "foo")
|
|
lds:set("key2", "bar")
|
|
local res, err = lds:del("key1", "key2")
|
|
if not res then
|
|
ngx.say("failed to del:", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("DEL, should be: 2 <=> 2")
|
|
|
|
--exists
|
|
lds:set("mykey", "foo")
|
|
res, err = lds:exists("mykey")
|
|
if not res then
|
|
ngx.say("failed to exists: ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("EXISTS, should be 1 <=>", res)
|
|
lds:del("mykey")
|
|
|
|
res, err = lds:exists("non_exists_key")
|
|
if not res then
|
|
ngx.say("failed to exists: ", err)
|
|
return
|
|
end
|
|
ngx.say("EXISTS, should be 0 <=>", res)
|
|
lds:del("non_exists_key")
|
|
|
|
-- get
|
|
lds:set("mykey", "foo")
|
|
res, err = lds:get("mykey")
|
|
if not res then
|
|
ngx.say("failed to get: ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("GET, should be foo <=> ", res)
|
|
lds:del("mykey")
|
|
|
|
-- getset
|
|
lds:set("mykey", "foo")
|
|
res, err = lds:getset("mykey", "bar")
|
|
if not res then
|
|
ngx.say("failed to getset ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("GETSET, should be foo <=> ", res)
|
|
res, err = lds:get("mykey")
|
|
ngx.say("GET, should be bar <=>", res)
|
|
lds:del("mykey")
|
|
|
|
-- incr
|
|
lds:set("mykey", "10")
|
|
res, err = lds:incr("mykey")
|
|
if not res then
|
|
ngx.say("failed to incr ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("INCR should be 11 <=>", res)
|
|
lds:del("mykey")
|
|
|
|
-- incrby
|
|
lds:set("mykey", "10")
|
|
res, err = lds:incrby("mykey", 10)
|
|
if not res then
|
|
ngx.say("failed to incrby ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("INCRBY should be 20 <=>", res)
|
|
lds:del("mykey")
|
|
|
|
-- mget
|
|
lds:set("key1", "foo")
|
|
lds:set("key2", "bar")
|
|
res, err = lds:mget("key1", "key2")
|
|
if not res then
|
|
ngx.say("failed to mget ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("MGET should be foobar <=>", res)
|
|
lds:del("key1", "key2")
|
|
|
|
-- mset
|
|
res, err = lds:mset("key1", "foo", "key2", "bar")
|
|
if not res then
|
|
ngx.say("failed to command ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("MSET should be OK <=>", res)
|
|
lds:del("key1", "key2")
|
|
|
|
|
|
|
|
-- set
|
|
ok, err = lds:set("mykey", "foo")
|
|
if not ok then
|
|
ngx.say("failed to set: ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("SET, should be OK <=>", ok)
|
|
lds:del("mykey")
|
|
|
|
-- setnx
|
|
res, err = lds:setnx("mykey", "foo")
|
|
if not res then
|
|
ngx.say("failed to setnx ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("setnx should be 1 <=>", res)
|
|
res, err = lds:setnx("mykey", "foo")
|
|
ngx.say("setnx should be 0 <=>", res)
|
|
lds:del("mykey")
|
|
|
|
-- expire
|
|
lds:set("mykey", "foo")
|
|
res, err = lds:expire("mykey", 60)
|
|
if not res then
|
|
ngx.say("failed to expire ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("EXPIRE should be 1 <=> ", res)
|
|
lds:del("mykey")
|
|
|
|
-- expireat
|
|
lds:set("mykey", "foo")
|
|
res, err = lds:expire("mykey", 14366666666)
|
|
if not res then
|
|
ngx.say("failed to expireat", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("EXPIREAT 1 <=>", res)
|
|
lds:del("mykey")
|
|
|
|
-- ttl
|
|
lds:set("mykey", "foo")
|
|
lds:expire("mykey", 100)
|
|
res, err = lds:ttl("mykey")
|
|
if not res then
|
|
ngx.say("failed to ttl ", err)
|
|
return
|
|
end
|
|
|
|
if not (0 < res and res <= 100) then
|
|
ngx.say("failed to ttl")
|
|
return
|
|
end
|
|
ngx.say("TTL ", res)
|
|
lds:del("mykey")
|
|
|
|
-- persist
|
|
lds:set("mykey", "foo")
|
|
lds:expire("mykey", 100)
|
|
res, err = lds:persist("mykey")
|
|
|
|
if not res then
|
|
ngx.say("failed to persist", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("PERSIST should be 1 <=>", res)
|
|
lds:del("mykey")
|
|
|
|
ngx.say("\n=================== HASH =====================\n")
|
|
|
|
-- [[ HASH ]]
|
|
|
|
-- hdel
|
|
res, err = lds:hset("myhash", "field", "foo")
|
|
if not res then
|
|
ngx.say("failed to HDEL", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HDEL should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hexists
|
|
lds:hset("myhash", "field", "foo")
|
|
res, err = lds:hexists("myhash", "field")
|
|
if not res then
|
|
ngx.say("failed to HEXISTS", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HEXISTS should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hget
|
|
lds:hset("myhash", "field", "foo")
|
|
res, err = lds:hget("myhash", "field")
|
|
if not res then
|
|
ngx.say("failed to HGET ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HGET should be foo <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hgetall
|
|
lds:hmset("myhash", "field1", "foo", "field2", "bar")
|
|
res, err = lds:hgetall("myhash")
|
|
if not res then
|
|
ngx.say("failed to HGETALL ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HGETALL should be field1foofield2bar <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hincrby
|
|
res, err = lds:hincrby("myhash", "field", 1)
|
|
if not res then
|
|
ngx.say("failed to HINCRBY ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HINCRBY should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hkeys
|
|
lds:hmset("myhash", "field1", "foo", "field2", "bar")
|
|
res, err = lds:hkeys("myhash")
|
|
if not res then
|
|
ngx.say("failed to HKEYS", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HKEYS should be field1field2 <=> ", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hlen
|
|
lds:hset("myhash", "field", "foo")
|
|
res, err = lds:hlen("myhash")
|
|
if not res then
|
|
ngx.say("failed to HLEN ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HLEN should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hmget
|
|
lds:hmset("myhash", "field1", "foo", "field2", "bar")
|
|
res, err = lds:hmget("myhash", "field1", "field2")
|
|
if not res then
|
|
ngx.say("failed to HMGET", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HMGET should be foobar <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hmset
|
|
res, err = lds:hmset("myhash", "field1", "foo", "field2", "bar")
|
|
if not res then
|
|
ngx.say("failed to HMSET ", err)
|
|
return
|
|
end
|
|
|
|
local l = lds:hlen("myhash")
|
|
if l == 2 then
|
|
ngx.say("HMSET tested !")
|
|
else
|
|
ngx.say("HMSET failed")
|
|
end
|
|
|
|
res, err = lds:hclear("myhash")
|
|
|
|
-- hset
|
|
res, err = lds:hset("myhash", "field", "foo")
|
|
if not res then
|
|
ngx.say("failed to HSET", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HSET should be 1 <=> ", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hvals
|
|
lds:hset("myhash", "field", "foo")
|
|
res, err = lds:hvals("myhash")
|
|
if not res then
|
|
ngx.say("failed to HVALS", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HVALS should be foo <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hclear
|
|
lds:hmset("myhash", "field1", "foo", "field2", "bar")
|
|
res, err = lds:hclear("myhash")
|
|
if not res then
|
|
ngx.say("failed to HCLEAR", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HCLEAR should be 2 <=>", res)
|
|
|
|
-- hmclear
|
|
lds:hset("myhash1", "field1", "foo")
|
|
lds:hset("myhash2", "field2", "bar")
|
|
res, err = lds:hmclear("myhash1", "myhash2")
|
|
if not res then
|
|
ngx.say("failed to HMCLEAR ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HMCLEAR should be 2 <=>", res)
|
|
|
|
-- hexpire
|
|
lds:hset("myhash", "field", "foo")
|
|
res, err = lds:hexpire("myhash", 100)
|
|
if not res then
|
|
ngx.say("failed to HEXPIRE", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HEXPIRE should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hexpireat
|
|
lds:hset("myhash", "field", "foo")
|
|
res, err = lds:hexpireat("myhash", 14366666666)
|
|
if not res then
|
|
ngx.say("failed to HEXPIREAT", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HEXPIREAT should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
-- hpersist
|
|
lds:hset("myhash", "field", "foo")
|
|
lds:hexpire("myhash", 100)
|
|
res, err = lds:hpersist("myhash")
|
|
|
|
if not res then
|
|
ngx.say("failed to hpersist", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HPERSIST should be 1 <=>", res)
|
|
lds:hclear("myhash")
|
|
|
|
|
|
--httl
|
|
lds:hset("myhash", "field", "foo")
|
|
lds:hexpire("myhash", 100)
|
|
res, err = lds:httl("myhash")
|
|
if not res then
|
|
ngx.say("failed to HTTL ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("HTTL value: ", res)
|
|
lds:hclear("myhash")
|
|
|
|
|
|
ngx.say("\n================== LIST ====================\n")
|
|
|
|
|
|
-- [[ LIST ]]
|
|
|
|
-- lindex
|
|
lds:rpush("mylist", "one", "two", "three")
|
|
res, err = lds:lindex("mylist", 0)
|
|
if not res then
|
|
ngx.say("failed to LINDEX ", err)
|
|
return
|
|
end
|
|
|
|
|
|
ngx.say("LINDEX should be one <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
|
|
-- llen
|
|
lds:rpush("mylist", "foo", "bar")
|
|
res, err = lds:llen("mylist")
|
|
if not res then
|
|
ngx.say("failed to LLEN ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LLEN should be 2 <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
|
|
-- lpop
|
|
lds:rpush("mylist", "one", "two", "three")
|
|
res, err = lds:lpop("mylist")
|
|
if not res then
|
|
ngx.say("failed to LPOP ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LPOP should be one <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
-- lrange
|
|
lds:rpush("mylist", "one", "two", "three")
|
|
res, err = lds:lrange("mylist", 0, 0)
|
|
if not res then
|
|
ngx.say("failed to one ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LRANGE should be one <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
-- lpush
|
|
res, err = lds:lpush("mylist", "one", "two")
|
|
if not res then
|
|
ngx.say("failed to LPUSH ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LPUSH should be 2 <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
|
|
-- rpop
|
|
lds:rpush("mylist", "one", "two")
|
|
res, err = lds:rpop("mylist")
|
|
if not res then
|
|
ngx.say("failed to RPOP ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("RPOP should be two <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
-- rpush
|
|
res, err = lds:rpush("mylist", "one", "two")
|
|
if not res then
|
|
ngx.say("failed to RPUSH ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("RPUSH should be 2 <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
-- lclear
|
|
lds:rpush("mylist", "one", "two")
|
|
res, err = lds:lclear("mylist")
|
|
if not res then
|
|
ngx.say("failed to LCLEAR ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LCLEAR should be 2 <=>", res)
|
|
|
|
|
|
-- lexpire
|
|
lds:rpush("mylist", "one")
|
|
res, err = lds:lexpire("mylist", 100)
|
|
if not res then
|
|
ngx.say("failed to LEXPIRE", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LEXPIRE should be 1 <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
-- lexpireat
|
|
lds:rpush("mylist", "one")
|
|
res, err = lds:lexpireat("mylist", 14366666666)
|
|
if not res then
|
|
ngx.say("failed to LEXPIREAT", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LEXPIREAT should be 1 <=>", res)
|
|
lds:lclear("mylist")
|
|
|
|
-- lpersist
|
|
lds:rpush("mylist", "one", "two")
|
|
lds:lexpire("mylist", 100)
|
|
res, err = lds:lpersist("mylist")
|
|
|
|
if not res then
|
|
ngx.say("failed to lpersist", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LPERSIST should be 1 <=>", res)
|
|
lds:hclear("mylist")
|
|
|
|
--lttl
|
|
lds:rpush("mylist", "field", "foo")
|
|
lds:lexpire("mylist", 100)
|
|
res, err = lds:lttl("mylist")
|
|
if not res then
|
|
ngx.say("failed to LTTL ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("LTTL value: ", res)
|
|
lds:lclear("mylist")
|
|
|
|
|
|
ngx.say("\n==================== ZSET =====================\n")
|
|
|
|
|
|
-- [[ ZSET ]]
|
|
|
|
-- zadd
|
|
res, err = lds:zadd("myset", 1, "one")
|
|
if not res then
|
|
ngx.say("failed to ZADD ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZADD should be 1 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zcard
|
|
lds:zadd("myset", 1, "one", 2, "two")
|
|
|
|
res, err = lds:zcard("myset")
|
|
if not res then
|
|
ngx.say("failed to ZCARD ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZCARD should be 2 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zcount
|
|
lds:zadd("myset", 1, "one", 2, "two")
|
|
res, err = lds:zcount("myset", "-inf", "+inf")
|
|
if not res then
|
|
ngx.say("failed to ZCOUNT ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZCOUNT should be 2 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zincrby
|
|
lds:zadd("myset", 1, "one")
|
|
res, err = lds:zincrby("myset", 2, "one")
|
|
if not res then
|
|
ngx.say("failed to ZINCRBY ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZINCRBY should be 3 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zrange
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zrange("myset", 0, -1, "WITHSCORES")
|
|
if not res then
|
|
ngx.say("failed to ZRANGE ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZRANGE should be one1two2three3<=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zrangebyscore
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zrangebyscore("myset", 1, 2)
|
|
if not res then
|
|
ngx.say("failed to ZRANGEBYSCORE ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZRANGEBYSCORE should be onetwo <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zrank
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zrank("myset", "three")
|
|
if not res then
|
|
ngx.say("failed to ZRANK ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZRANK should be 2 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zrem
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zrem("myset", "two", "three")
|
|
if not res then
|
|
ngx.say("failed to ZREM ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZREM should be 2 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zremrangebyrank
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err= lds:zremrangebyrank("myset", 0, 2)
|
|
if not res then
|
|
ngx.say("failed to ZREMRANGEBYRANK ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZREMRANGEBYRANK should be 3 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
|
|
-- zremrangebyscore
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zremrangebyscore("myset", 0, 2)
|
|
if not res then
|
|
ngx.say("failed to ZREMRANGEBYSCORE ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("zremrangebyscore should be 2 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
|
|
-- zrevrange
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zrevrange("myset", 0, -1)
|
|
if not res then
|
|
ngx.say("failed to ZREVRANGE ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZREVRANGE should be threetwoone <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zrevrangebyscore
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zrevrangebyscore("myset", "+inf", "-inf")
|
|
if not res then
|
|
ngx.say("failed to ZREVRANGEBYSCORE ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZREVRANGEBYSCORE should be threetwoone <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zscore
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zscore("myset", "two")
|
|
if not res then
|
|
ngx.say("failed to ZSCORE ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZSCORE should be 2 <=>", res)
|
|
lds.zclear("myset")
|
|
|
|
-- zclear
|
|
lds:zadd("myset", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zclear("myset")
|
|
if not res then
|
|
ngx.say("failed to ZCLEAR ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZCLEAR should be 3 <=>", res)
|
|
|
|
-- zmclear
|
|
lds:zadd("myset1", 1, "one", 2, "two", 3, "three")
|
|
lds:zadd("myset2", 1, "one", 2, "two", 3, "three")
|
|
res, err = lds:zmclear("myset1", "myset2")
|
|
if not res then
|
|
ngx.say("failed to ZMCLEAR ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZMCLEAR should be 2 <=>", res)
|
|
|
|
-- zexpire
|
|
lds:zadd("myset", 1, "one")
|
|
res, err = lds:zexpire("myset", 60)
|
|
if not res then
|
|
ngx.say("failed to zexpire ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZEXPIRE should be 1 <=> ", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zexpireat
|
|
lds:zadd("myset", 1, "one")
|
|
res, err = lds:zexpire("myset", 14366666666)
|
|
if not res then
|
|
ngx.say("failed to zexpireat", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZEXPIREAT 1 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zttl
|
|
lds:zadd("myset", 1, "one")
|
|
lds:zexpire("myset", 100)
|
|
res, err = lds:zttl("myset")
|
|
if not res then
|
|
ngx.say("failed to zttl ", err)
|
|
return
|
|
end
|
|
|
|
if not (0 < res and res <= 100) then
|
|
ngx.say("failed to zttl")
|
|
return
|
|
end
|
|
ngx.say("ZTTL ", res)
|
|
lds:zclear("myset")
|
|
|
|
-- zpersist
|
|
lds:zadd("myset", 1, "one")
|
|
lds:zexpire("myset", 100)
|
|
res, err = lds:zpersist("myset")
|
|
|
|
if not res then
|
|
ngx.say("failed to zpersist", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ZPERSIST should be 1 <=>", res)
|
|
lds:zclear("myset")
|
|
|
|
|
|
ngx.say("\n===================== SERVER INFO ==============\n")
|
|
|
|
-- [[ SERVER INFO ]]
|
|
|
|
-- ping
|
|
res, err = lds:ping()
|
|
if not res then
|
|
ngx.say("failed to PING ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("PING should be PONG <=>", res)
|
|
|
|
-- echo
|
|
res, err = lds:echo("hello, lua")
|
|
if not res then
|
|
ngx.say("failed to ECHO ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("ECHO should be hello, lua <=>", res)
|
|
|
|
-- select
|
|
res, err = lds:select(5)
|
|
if not res then
|
|
ngx.say("failed to SELECT ", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("SELECT should be OK <=>", res)
|
|
|
|
-- get_reused_times
|
|
|
|
times, err = lds:get_reused_times()
|
|
if not times then
|
|
ngx.say("failed to get_reused_times", err)
|
|
return
|
|
end
|
|
|
|
ngx.say("time is", times)
|
|
|
|
-- local ok, err = lds:set_keepalive(10000, 100)
|
|
-- if not ok then
|
|
-- ngx.say("failed to set keepalive: ", err)
|
|
-- return
|
|
-- end
|
|
-- ngx.say("set_keepalive success")
|
|
-- or just close the connection right away:
|
|
|
|
|
|
|
|
local ok, err = lds:close()
|
|
if not ok then
|
|
ngx.say("failed to close: ", err)
|
|
return
|
|
end
|
|
ngx.say("close success") |