xref: /redis-3.2.3/tests/unit/expire.tcl (revision 940be9ab) 
1start_server {tags {"expire"}} {
2    test {EXPIRE - set timeouts multiple times} {
3        r set x foobar
4        set v1 [r expire x 5]
5        set v2 [r ttl x]
6        set v3 [r expire x 10]
7        set v4 [r ttl x]
8        r expire x 2
9        list $v1 $v2 $v3 $v4
10    } {1 [45] 1 10}
11
12    test {EXPIRE - It should be still possible to read 'x'} {
13        r get x
14    } {foobar}
15
16    tags {"slow"} {
17        test {EXPIRE - After 2.1 seconds the key should no longer be here} {
18            after 2100
19            list [r get x] [r exists x]
20        } {{} 0}
21    }
22
23    test {EXPIRE - write on expire should work} {
24        r del x
25        r lpush x foo
26        r expire x 1000
27        r lpush x bar
28        r lrange x 0 -1
29    } {bar foo}
30
31    test {EXPIREAT - Check for EXPIRE alike behavior} {
32        r del x
33        r set x foo
34        r expireat x [expr [clock seconds]+15]
35        r ttl x
36    } {1[345]}
37
38    test {SETEX - Set + Expire combo operation. Check for TTL} {
39        r setex x 12 test
40        r ttl x
41    } {1[012]}
42
43    test {SETEX - Check value} {
44        r get x
45    } {test}
46
47    test {SETEX - Overwrite old key} {
48        r setex y 1 foo
49        r get y
50    } {foo}
51
52    tags {"slow"} {
53        test {SETEX - Wait for the key to expire} {
54            after 1100
55            r get y
56        } {}
57    }
58
59    test {SETEX - Wrong time parameter} {
60        catch {r setex z -10 foo} e
61        set _ $e
62    } {*invalid expire*}
63
64    test {PERSIST can undo an EXPIRE} {
65        r set x foo
66        r expire x 50
67        list [r ttl x] [r persist x] [r ttl x] [r get x]
68    } {50 1 -1 foo}
69
70    test {PERSIST returns 0 against non existing or non volatile keys} {
71        r set x foo
72        list [r persist foo] [r persist nokeyatall]
73    } {0 0}
74
75    test {EXPIRE pricision is now the millisecond} {
76        # This test is very likely to do a false positive if the
77        # server is under pressure, so if it does not work give it a few more
78        # chances.
79        for {set j 0} {$j < 3} {incr j} {
80            r del x
81            r setex x 1 somevalue
82            after 900
83            set a [r get x]
84            after 1100
85            set b [r get x]
86            if {$a eq {somevalue} && $b eq {}} break
87        }
88        list $a $b
89    } {somevalue {}}
90
91    test {PEXPIRE/PSETEX/PEXPIREAT can set sub-second expires} {
92        # This test is very likely to do a false positive if the
93        # server is under pressure, so if it does not work give it a few more
94        # chances.
95        for {set j 0} {$j < 3} {incr j} {
96            r del x y z
97            r psetex x 100 somevalue
98            after 80
99            set a [r get x]
100            after 120
101            set b [r get x]
102
103            r set x somevalue
104            r pexpire x 100
105            after 80
106            set c [r get x]
107            after 120
108            set d [r get x]
109
110            r set x somevalue
111            r pexpireat x [expr ([clock seconds]*1000)+100]
112            after 80
113            set e [r get x]
114            after 120
115            set f [r get x]
116
117            if {$a eq {somevalue} && $b eq {} &&
118                $c eq {somevalue} && $d eq {} &&
119                $e eq {somevalue} && $f eq {}} break
120        }
121        list $a $b
122    } {somevalue {}}
123
124    test {TTL returns tiem to live in seconds} {
125        r del x
126        r setex x 10 somevalue
127        set ttl [r ttl x]
128        assert {$ttl > 8 && $ttl <= 10}
129    }
130
131    test {PTTL returns time to live in milliseconds} {
132        r del x
133        r setex x 1 somevalue
134        set ttl [r pttl x]
135        assert {$ttl > 900 && $ttl <= 1000}
136    }
137
138    test {TTL / PTTL return -1 if key has no expire} {
139        r del x
140        r set x hello
141        list [r ttl x] [r pttl x]
142    } {-1 -1}
143
144    test {TTL / PTTL return -2 if key does not exit} {
145        r del x
146        list [r ttl x] [r pttl x]
147    } {-2 -2}
148
149    test {Redis should actively expire keys incrementally} {
150        r flushdb
151        r psetex key1 500 a
152        r psetex key2 500 a
153        r psetex key3 500 a
154        set size1 [r dbsize]
155        # Redis expires random keys ten times every second so we are
156        # fairly sure that all the three keys should be evicted after
157        # one second.
158        after 1000
159        set size2 [r dbsize]
160        list $size1 $size2
161    } {3 0}
162
163    test {Redis should lazy expire keys} {
164        r flushdb
165        r debug set-active-expire 0
166        r psetex key1 500 a
167        r psetex key2 500 a
168        r psetex key3 500 a
169        set size1 [r dbsize]
170        # Redis expires random keys ten times every second so we are
171        # fairly sure that all the three keys should be evicted after
172        # one second.
173        after 1000
174        set size2 [r dbsize]
175        r mget key1 key2 key3
176        set size3 [r dbsize]
177        r debug set-active-expire 1
178        list $size1 $size2 $size3
179    } {3 3 0}
180
181    test {EXPIRE should not resurrect keys (issue #1026)} {
182        r debug set-active-expire 0
183        r set foo bar
184        r pexpire foo 500
185        after 1000
186        r expire foo 10
187        r debug set-active-expire 1
188        r exists foo
189    } {0}
190
191    test {5 keys in, 5 keys out} {
192        r flushdb
193        r set a c
194        r expire a 5
195        r set t c
196        r set e c
197        r set s c
198        r set foo b
199        lsort [r keys *]
200    } {a e foo s t}
201
202    test {EXPIRE with empty string as TTL should report an error} {
203        r set foo bar
204        catch {r expire foo ""} e
205        set e
206    } {*not an integer*}
207}
208