[redis.git] / tests / unit / scripting.tcl

start_server {tags {"scripting"}} {
    test {EVAL - Does Lua interpreter replies to our requests?} {
        r eval {return 'hello'} 0
    } {hello}

    test {EVAL - Lua integer -> Redis protocol type conversion} {
        r eval {return 100.5} 0
    } {100}

    test {EVAL - Lua string -> Redis protocol type conversion} {
        r eval {return 'hello world'} 0
    } {hello world}

    test {EVAL - Lua true boolean -> Redis protocol type conversion} {
        r eval {return true} 0
    } {1}

    test {EVAL - Lua false boolean -> Redis protocol type conversion} {
        r eval {return false} 0
    } {}

    test {EVAL - Lua status code reply -> Redis protocol type conversion} {
        r eval {return {ok='fine'}} 0
    } {fine}

    test {EVAL - Lua error reply -> Redis protocol type conversion} {
        catch {
            r eval {return {err='this is an error'}} 0
        } e
        set _ $e
    } {this is an error}

    test {EVAL - Lua table -> Redis protocol type conversion} {
        r eval {return {1,2,3,'ciao',{1,2}}} 0
    } {1 2 3 ciao {1 2}}

    test {EVAL - Are the KEYS and ARGS arrays populated correctly?} {
        r eval {return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}} 2 a b c d
    } {a b c d}

    test {EVAL - is Lua able to call Redis API?} {
        r set mykey myval
        r eval {return redis.call('get','mykey')} 0
    } {myval}

    test {EVALSHA - Can we call a SHA1 if already defined?} {
        r evalsha 9bd632c7d33e571e9f24556ebed26c3479a87129 0
    } {myval}

    test {EVALSHA - Do we get an error on invalid SHA1?} {
        catch {r evalsha NotValidShaSUM 0} e
        set _ $e
    } {NOSCRIPT*}

    test {EVALSHA - Do we get an error on non defined SHA1?} {
        catch {r evalsha ffd632c7d33e571e9f24556ebed26c3479a87130 0} e
        set _ $e
    } {NOSCRIPT*}

    test {EVAL - Redis integer -> Lua type conversion} {
        r eval {
            local foo = redis.pcall('incr','x')
            return {type(foo),foo}
        } 0
    } {number 1}

    test {EVAL - Redis bulk -> Lua type conversion} {
        r set mykey myval
        r eval {
            local foo = redis.pcall('get','mykey')
            return {type(foo),foo}
        } 0
    } {string myval}

    test {EVAL - Redis multi bulk -> Lua type conversion} {
        r del mylist
        r rpush mylist a
        r rpush mylist b
        r rpush mylist c
        r eval {
            local foo = redis.pcall('lrange','mylist',0,-1)
            return {type(foo),foo[1],foo[2],foo[3],# foo}
        } 0
    } {table a b c 3}

    test {EVAL - Redis status reply -> Lua type conversion} {
        r eval {
            local foo = redis.pcall('set','mykey','myval')
            return {type(foo),foo['ok']}
        } 0
    } {table OK}

    test {EVAL - Redis error reply -> Lua type conversion} {
        r set mykey myval
        r eval {
            local foo = redis.pcall('incr','mykey')
            return {type(foo),foo['err']}
        } 0
    } {table {ERR value is not an integer or out of range}}

    test {EVAL - Redis nil bulk reply -> Lua type conversion} {
        r del mykey
        r eval {
            local foo = redis.pcall('get','mykey')
            return {type(foo),foo == false}
        } 0
    } {boolean 1}

    test {EVAL - Is Lua affecting the currently selected DB?} {
        r set mykey "this is DB 9"
        r select 10
        r set mykey "this is DB 10"
        r eval {return redis.pcall('get','mykey')} 0
    } {this is DB 10}

    test {EVAL - Is Lua seleced DB retained?} {
        r eval {return redis.pcall('select','9')} 0
        r get mykey
    } {this is DB 9}

    if 0 {
        test {EVAL - Script can't run more than configured time limit} {
            r config set lua-time-limit 1
            catch {
                r eval {
                    local i = 0
                    while true do i=i+1 end
                } 0
            } e
            set _ $e
        } {*execution time*}
    }

    test {EVAL - Scripts can't run certain commands} {
        set e {}
        catch {r eval {return redis.pcall('spop','x')} 0} e
        set e
    } {*not allowed*}

    test {EVAL - Scripts can't run certain commands} {
        set e {}
        catch {
            r eval "redis.pcall('randomkey'); return redis.pcall('set','x','ciao')" 0
        } e
        set e
    } {*not allowed after*}

    test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
        set e {}
        catch {
            r eval "redis.call('nosuchcommand')" 0
        } e
        set e
    } {*Unknown Redis*}

    test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
        set e {}
        catch {
            r eval "redis.call('get','a','b','c')" 0
        } e
        set e
    } {*number of args*}

    test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
        set e {}
        r set foo bar
        catch {
            r eval "redis.call('lpush','foo','val')" 0
        } e
        set e
    } {*against a key*}

    test {SCRIPTING FLUSH - is able to clear the scripts cache?} {
        r set mykey myval
        set v [r evalsha 9bd632c7d33e571e9f24556ebed26c3479a87129 0]
        assert_equal $v myval
        set e ""
        r script flush
        catch {r evalsha 9bd632c7d33e571e9f24556ebed26c3479a87129 0} e
        set e
    } {NOSCRIPT*}

    test {SCRIPT EXISTS - can detect already defined scripts?} {
        r eval "return 1+1" 0
        r script exists a27e7e8a43702b7046d4f6a7ccf5b60cef6b9bd9 a27e7e8a43702b7046d4f6a7ccf5b60cef6b9bda
    } {1 0}

    test {SCRIPT LOAD - is able to register scripts in the scripting cache} {
        list \
            [r script load "return 'loaded'"] \
            [r evalsha b534286061d4b9e4026607613b95c06c06015ae8 0]
    } {b534286061d4b9e4026607613b95c06c06015ae8 loaded}

    test "In the context of Lua the output of random commands gets ordered" {
        r del myset
        r sadd myset a b c d e f g h i l m n o p q r s t u v z aa aaa azz
        r eval {return redis.call('smembers','myset')} 0
    } {a aa aaa azz b c d e f g h i l m n o p q r s t u v z}

    test "SORT is normally not re-ordered by the scripting engine" {
        r del myset
        r sadd myset 1 2 3 4 10
        r eval {return redis.call('sort','myset','desc')} 0
    } {10 4 3 2 1}

    test "SORT BY <constant> output gets ordered by scripting" {
        r del myset
        r sadd myset a b c d e f g h i l m n o p q r s t u v z aa aaa azz
        r eval {return redis.call('sort','myset','by','_')} 0
    } {a aa aaa azz b c d e f g h i l m n o p q r s t u v z}

    test "SORT output containing NULLs is well handled by scripting" {
        r del myset
        r sadd myset a b c
        r eval {return redis.call('sort','myset','by','_','get','#','get','_:*')} 0
    } {{} {} {} a b c}

    test "redis.sha1hex() implementation" {
        list [r eval {return redis.sha1hex('')} 0] \
             [r eval {return redis.sha1hex('Pizza & Mandolino')} 0]
    } {da39a3ee5e6b4b0d3255bfef95601890afd80709 74822d82031af7493c20eefa13bd07ec4fada82f}

    test {Globals protection reading an undeclared global variable} {
        catch {r eval {return a} 0} e
        set e
    } {*ERR*attempted to access unexisting global*}

    test {Globals protection setting an undeclared global*} {
        catch {r eval {a=10} 0} e
        set e
    } {*ERR*attempted to create global*}

    test {Test an example script DECR_IF_GT} {
        set decr_if_gt {
            local current

            current = redis.call('get',KEYS[1])
            if not current then return nil end
            if current > ARGV[1] then
                return redis.call('decr',KEYS[1])
            else
                return redis.call('get',KEYS[1])
            end
        }
        r set foo 5
        set res {}
        lappend res [r eval $decr_if_gt 1 foo 2]
        lappend res [r eval $decr_if_gt 1 foo 2]
        lappend res [r eval $decr_if_gt 1 foo 2]
        lappend res [r eval $decr_if_gt 1 foo 2]
        lappend res [r eval $decr_if_gt 1 foo 2]
        set res
    } {4 3 2 2 2}

    test {Scripting engine resets PRNG at every script execution} {
        set rand1 [r eval {return tostring(math.random())} 0]
        set rand2 [r eval {return tostring(math.random())} 0]
        assert_equal $rand1 $rand2
    }

    test {Scripting engine PRNG can be seeded correctly} {
        set rand1 [r eval {
            math.randomseed(ARGV[1]); return tostring(math.random())
        } 0 10]
        set rand2 [r eval {
            math.randomseed(ARGV[1]); return tostring(math.random())
        } 0 10]
        set rand3 [r eval {
            math.randomseed(ARGV[1]); return tostring(math.random())
        } 0 20]
        assert_equal $rand1 $rand2
        assert {$rand2 ne $rand3}
    }
}

# Start a new server since the last test in this stanza will kill the
# instance at all.
start_server {tags {"scripting"}} {
    test {Timedout read-only scripts can be killed by SCRIPT KILL} {
        set rd [redis_deferring_client]
        r config set lua-time-limit 10
        $rd eval {while true do end} 0
        after 200
        catch {r ping} e
        assert_match {BUSY*} $e
        r script kill
        assert_equal [r ping] "PONG"
    }

    test {Timedout scripts that modified data can't be killed by SCRIPT KILL} {
        set rd [redis_deferring_client]
        r config set lua-time-limit 10
        $rd eval {redis.call('set','x','y'); while true do end} 0
        after 200
        catch {r ping} e
        assert_match {BUSY*} $e
        catch {r script kill} e
        assert_match {ERR*} $e
        catch {r ping} e
        assert_match {BUSY*} $e
    }

    test {SHUTDOWN NOSAVE can kill a timedout script anyway} {
        # The server sould be still unresponding to normal commands.
        catch {r ping} e
        assert_match {BUSY*} $e
        catch {r shutdown nosave}
        # Make sure the server was killed
        catch {set rd [redis_deferring_client]} e
        assert_match {*connection refused*} $e
    }
}

start_server {tags {"scripting repl"}} {
    start_server {} {
        test {Before the slave connects we issue an EVAL command} {
            r eval {return redis.call('incr','x')} 0
        } {1}

        test {Connect a slave to the main instance} {
            r -1 slaveof [srv 0 host] [srv 0 port]
            after 1000
            s -1 role
        } {slave}

        test {Now use EVALSHA against the master} {
            r evalsha ae3477e27be955de7e1bc9adfdca626b478d3cb2 0
        } {2}

        test {If EVALSHA was replicated as EVAL the slave should be ok} {
            wait_for_condition 50 100 {
                [r -1 get x] eq {2}
            } else {
                fail "Expected 2 in x, but value is '[r -1 get x]'"
            }
        }
    }
}
Commit	Line	Data
449286a5	1	start_server {tags {"scripting"}} {
	2	test {EVAL - Does Lua interpreter replies to our requests?} {
	3	r eval {return 'hello'} 0
	4	} {hello}
	5
	6	test {EVAL - Lua integer -> Redis protocol type conversion} {
	7	r eval {return 100.5} 0
	8	} {100}
	9
	10	test {EVAL - Lua string -> Redis protocol type conversion} {
	11	r eval {return 'hello world'} 0
	12	} {hello world}
	13
	14	test {EVAL - Lua true boolean -> Redis protocol type conversion} {
	15	r eval {return true} 0
	16	} {1}
	17
	18	test {EVAL - Lua false boolean -> Redis protocol type conversion} {
	19	r eval {return false} 0
	20	} {}
	21
	22	test {EVAL - Lua status code reply -> Redis protocol type conversion} {
	23	r eval {return {ok='fine'}} 0
	24	} {fine}
	25
	26	test {EVAL - Lua error reply -> Redis protocol type conversion} {
	27	catch {
	28	r eval {return {err='this is an error'}} 0
	29	} e
	30	set _ $e
	31	} {this is an error}
	32
	33	test {EVAL - Lua table -> Redis protocol type conversion} {
	34	r eval {return {1,2,3,'ciao',{1,2}}} 0
	35	} {1 2 3 ciao {1 2}}
	36
	37	test {EVAL - Are the KEYS and ARGS arrays populated correctly?} {
	38	r eval {return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}} 2 a b c d
	39	} {a b c d}
	40
	41	test {EVAL - is Lua able to call Redis API?} {
	42	r set mykey myval
	43	r eval {return redis.call('get','mykey')} 0
	44	} {myval}
	45
	46	test {EVALSHA - Can we call a SHA1 if already defined?} {
	47	r evalsha 9bd632c7d33e571e9f24556ebed26c3479a87129 0
	48	} {myval}
	49
e8c993f0	50	test {EVALSHA - Do we get an error on invalid SHA1?} {
	51	catch {r evalsha NotValidShaSUM 0} e
	52	set _ $e
	53	} {NOSCRIPT*}
	54
449286a5	55	test {EVALSHA - Do we get an error on non defined SHA1?} {
e8c993f0	56	catch {r evalsha ffd632c7d33e571e9f24556ebed26c3479a87130 0} e
449286a5	57	set _ $e
	58	} {NOSCRIPT*}
	59
	60	test {EVAL - Redis integer -> Lua type conversion} {
	61	r eval {
9ed32ba0	62	local foo = redis.pcall('incr','x')
449286a5	63	return {type(foo),foo}
	64	} 0
	65	} {number 1}
	66
	67	test {EVAL - Redis bulk -> Lua type conversion} {
	68	r set mykey myval
	69	r eval {
9ed32ba0	70	local foo = redis.pcall('get','mykey')
449286a5	71	return {type(foo),foo}
	72	} 0
	73	} {string myval}
	74
	75	test {EVAL - Redis multi bulk -> Lua type conversion} {
	76	r del mylist
	77	r rpush mylist a
	78	r rpush mylist b
	79	r rpush mylist c
	80	r eval {
9ed32ba0	81	local foo = redis.pcall('lrange','mylist',0,-1)
449286a5	82	return {type(foo),foo[1],foo[2],foo[3],# foo}
	83	} 0
	84	} {table a b c 3}
	85
	86	test {EVAL - Redis status reply -> Lua type conversion} {
	87	r eval {
9ed32ba0	88	local foo = redis.pcall('set','mykey','myval')
449286a5	89	return {type(foo),foo['ok']}
	90	} 0
	91	} {table OK}
	92
	93	test {EVAL - Redis error reply -> Lua type conversion} {
	94	r set mykey myval
	95	r eval {
9ed32ba0	96	local foo = redis.pcall('incr','mykey')
449286a5	97	return {type(foo),foo['err']}
	98	} 0
	99	} {table {ERR value is not an integer or out of range}}
	100
	101	test {EVAL - Redis nil bulk reply -> Lua type conversion} {
	102	r del mykey
	103	r eval {
9ed32ba0	104	local foo = redis.pcall('get','mykey')
449286a5	105	return {type(foo),foo == false}
	106	} 0
	107	} {boolean 1}
	108
	109	test {EVAL - Is Lua affecting the currently selected DB?} {
	110	r set mykey "this is DB 9"
	111	r select 10
	112	r set mykey "this is DB 10"
9ed32ba0	113	r eval {return redis.pcall('get','mykey')} 0
449286a5	114	} {this is DB 10}
	115
	116	test {EVAL - Is Lua seleced DB retained?} {
9ed32ba0	117	r eval {return redis.pcall('select','9')} 0
449286a5	118	r get mykey
	119	} {this is DB 9}
	120
ef23f3ac	121	if 0 {
	122	test {EVAL - Script can't run more than configured time limit} {
	123	r config set lua-time-limit 1
	124	catch {
	125	r eval {
	126	local i = 0
	127	while true do i=i+1 end
	128	} 0
	129	} e
	130	set _ $e
	131	} {execution time}
	132	}
7864ef85	133
	134	test {EVAL - Scripts can't run certain commands} {
	135	set e {}
9ed32ba0	136	catch {r eval {return redis.pcall('spop','x')} 0} e
7864ef85	137	set e
	138	} {not allowed}
	139
	140	test {EVAL - Scripts can't run certain commands} {
	141	set e {}
	142	catch {
9ed32ba0	143	r eval "redis.pcall('randomkey'); return redis.pcall('set','x','ciao')" 0
7864ef85	144	} e
	145	set e
	146	} {not allowed after}
	147
9ed32ba0	148	test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
	149	set e {}
	150	catch {
	151	r eval "redis.call('nosuchcommand')" 0
	152	} e
	153	set e
	154	} {Unknown Redis}
	155
	156	test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
	157	set e {}
	158	catch {
	159	r eval "redis.call('get','a','b','c')" 0
	160	} e
	161	set e
	162	} {number of args}
	163
	164	test {EVAL - redis.call variant raises a Lua error on Redis cmd error (1)} {
	165	set e {}
	166	r set foo bar
	167	catch {
	168	r eval "redis.call('lpush','foo','val')" 0
	169	} e
	170	set e
	171	} {against a key}
e8c993f0	172
	173	test {SCRIPTING FLUSH - is able to clear the scripts cache?} {
	174	r set mykey myval
	175	set v [r evalsha 9bd632c7d33e571e9f24556ebed26c3479a87129 0]
	176	assert_equal $v myval
	177	set e ""
	178	r script flush
	179	catch {r evalsha 9bd632c7d33e571e9f24556ebed26c3479a87129 0} e
	180	set e
	181	} {NOSCRIPT*}
	182
	183	test {SCRIPT EXISTS - can detect already defined scripts?} {
	184	r eval "return 1+1" 0
	185	r script exists a27e7e8a43702b7046d4f6a7ccf5b60cef6b9bd9 a27e7e8a43702b7046d4f6a7ccf5b60cef6b9bda
	186	} {1 0}
	187
	188	test {SCRIPT LOAD - is able to register scripts in the scripting cache} {
	189	list \
	190	[r script load "return 'loaded'"] \
	191	[r evalsha b534286061d4b9e4026607613b95c06c06015ae8 0]
e5abf6ef	192	} {b534286061d4b9e4026607613b95c06c06015ae8 loaded}
c1794728	193
	194	test "In the context of Lua the output of random commands gets ordered" {
	195	r del myset
	196	r sadd myset a b c d e f g h i l m n o p q r s t u v z aa aaa azz
	197	r eval {return redis.call('smembers','myset')} 0
	198	} {a aa aaa azz b c d e f g h i l m n o p q r s t u v z}
	199
	200	test "SORT is normally not re-ordered by the scripting engine" {
	201	r del myset
	202	r sadd myset 1 2 3 4 10
	203	r eval {return redis.call('sort','myset','desc')} 0
	204	} {10 4 3 2 1}
	205
	206	test "SORT BY <constant> output gets ordered by scripting" {
	207	r del myset
	208	r sadd myset a b c d e f g h i l m n o p q r s t u v z aa aaa azz
	209	r eval {return redis.call('sort','myset','by','_')} 0
	210	} {a aa aaa azz b c d e f g h i l m n o p q r s t u v z}
	211
	212	test "SORT output containing NULLs is well handled by scripting" {
	213	r del myset
	214	r sadd myset a b c
	215	r eval {return redis.call('sort','myset','by','_','get','#','get','_:*')} 0
	216	} {{} {} {} a b c}
6aa2f989	217
	218	test "redis.sha1hex() implementation" {
	219	list [r eval {return redis.sha1hex('')} 0] \
	220	[r eval {return redis.sha1hex('Pizza & Mandolino')} 0]
	221	} {da39a3ee5e6b4b0d3255bfef95601890afd80709 74822d82031af7493c20eefa13bd07ec4fada82f}
2fd7c9ef	222
	223	test {Globals protection reading an undeclared global variable} {
	224	catch {r eval {return a} 0} e
	225	set e
3cd4ad26	226	} {ERRattempted to access unexisting global*}
2fd7c9ef	227
3cd4ad26	228	test {Globals protection setting an undeclared global*} {
2fd7c9ef	229	catch {r eval {a=10} 0} e
2fd7c9ef	230	set e
3cd4ad26	231	} {ERRattempted to create global*}
13a21caa	232
	233	test {Test an example script DECR_IF_GT} {
	234	set decr_if_gt {
	235	local current
	236
	237	current = redis.call('get',KEYS[1])
	238	if not current then return nil end
	239	if current > ARGV[1] then
	240	return redis.call('decr',KEYS[1])
	241	else
	242	return redis.call('get',KEYS[1])
	243	end
	244	}
	245	r set foo 5
	246	set res {}
	247	lappend res [r eval $decr_if_gt 1 foo 2]
	248	lappend res [r eval $decr_if_gt 1 foo 2]
	249	lappend res [r eval $decr_if_gt 1 foo 2]
	250	lappend res [r eval $decr_if_gt 1 foo 2]
	251	lappend res [r eval $decr_if_gt 1 foo 2]
	252	set res
	253	} {4 3 2 2 2}
5498e7bc	254
	255	test {Scripting engine resets PRNG at every script execution} {
	256	set rand1 [r eval {return tostring(math.random())} 0]
	257	set rand2 [r eval {return tostring(math.random())} 0]
	258	assert_equal $rand1 $rand2
	259	}
	260
	261	test {Scripting engine PRNG can be seeded correctly} {
	262	set rand1 [r eval {
	263	math.randomseed(ARGV[1]); return tostring(math.random())
	264	} 0 10]
	265	set rand2 [r eval {
	266	math.randomseed(ARGV[1]); return tostring(math.random())
	267	} 0 10]
	268	set rand3 [r eval {
	269	math.randomseed(ARGV[1]); return tostring(math.random())
	270	} 0 20]
	271	assert_equal $rand1 $rand2
	272	assert {$rand2 ne $rand3}
	273	}
449286a5	274	}
61fee319	275
47db53c3	276	# Start a new server since the last test in this stanza will kill the
	277	# instance at all.
	278	start_server {tags {"scripting"}} {
	279	test {Timedout read-only scripts can be killed by SCRIPT KILL} {
	280	set rd [redis_deferring_client]
	281	r config set lua-time-limit 10
	282	$rd eval {while true do end} 0
	283	after 200
	284	catch {r ping} e
	285	assert_match {BUSY*} $e
	286	r script kill
	287	assert_equal [r ping] "PONG"
	288	}
	289
	290	test {Timedout scripts that modified data can't be killed by SCRIPT KILL} {
	291	set rd [redis_deferring_client]
	292	r config set lua-time-limit 10
	293	$rd eval {redis.call('set','x','y'); while true do end} 0
	294	after 200
	295	catch {r ping} e
	296	assert_match {BUSY*} $e
	297	catch {r script kill} e
	298	assert_match {ERR*} $e
	299	catch {r ping} e
	300	assert_match {BUSY*} $e
	301	}
	302
	303	test {SHUTDOWN NOSAVE can kill a timedout script anyway} {
	304	# The server sould be still unresponding to normal commands.
	305	catch {r ping} e
	306	assert_match {BUSY*} $e
	307	catch {r shutdown nosave}
	308	# Make sure the server was killed
	309	catch {set rd [redis_deferring_client]} e
	310	assert_match {connection refused} $e
	311	}
	312	}
	313
61fee319	314	start_server {tags {"scripting repl"}} {
	315	start_server {} {
	316	test {Before the slave connects we issue an EVAL command} {
	317	r eval {return redis.call('incr','x')} 0
	318	} {1}
	319
	320	test {Connect a slave to the main instance} {
	321	r -1 slaveof [srv 0 host] [srv 0 port]
	322	after 1000
	323	s -1 role
	324	} {slave}
	325
	326	test {Now use EVALSHA against the master} {
	327	r evalsha ae3477e27be955de7e1bc9adfdca626b478d3cb2 0
	328	} {2}
	329
61fee319	330	test {If EVALSHA was replicated as EVAL the slave should be ok} {
5080e625	331	wait_for_condition 50 100 {
	332	[r -1 get x] eq {2}
	333	} else {
	334	fail "Expected 2 in x, but value is '[r -1 get x]'"
	335	}
	336	}
61fee319	337	}
61fee319	338	}