1 files changed, 0 insertions, 176 deletions
diff --git a/examples/redis-unstable/tests/unit/moduleapi/stream.tcl b/examples/redis-unstable/tests/unit/moduleapi/stream.tcl
deleted file mode 100644
index cc235f8..0000000
--- a/examples/redis-unstable/tests/unit/moduleapi/stream.tcl
+++ /dev/null
@@ -1,176 +0,0 @@
-set testmodule [file normalize tests/modules/stream.so]
-start_server {tags {"modules external:skip"}} {
-    r module load $testmodule
-    test {Module stream add and delete} {
-        r del mystream
-        # add to empty key
-        set streamid1 [r stream.add mystream item 1 value a]
-        # add to existing stream
-        set streamid2 [r stream.add mystream item 2 value b]
-        # check result
-        assert { [string match "*-*" $streamid1] }
-        set items [r XRANGE mystream - +]
-        assert_equal $items \
-            "{$streamid1 {item 1 value a}} {$streamid2 {item 2 value b}}"
-        # delete one of them and try deleting non-existing ID
-        assert_equal OK [r stream.delete mystream $streamid1]
-        assert_error "ERR StreamDelete*" {r stream.delete mystream 123-456}
-        assert_error "Invalid stream ID*" {r stream.delete mystream foo}
-        assert_equal "{$streamid2 {item 2 value b}}" [r XRANGE mystream - +]
-        # check error condition: wrong type
-        r del mystream
-        r set mystream mystring
-        assert_error "ERR StreamAdd*" {r stream.add mystream item 1 value a}
-        assert_error "ERR StreamDelete*" {r stream.delete mystream 123-456}
-    }
-    test {Module stream add unblocks blocking xread} {
-        r del mystream
-        # Blocking XREAD on an empty key
-        set rd1 [redis_deferring_client]
-        $rd1 XREAD BLOCK 3000 STREAMS mystream $
-        # wait until client is actually blocked
-        wait_for_condition 50 100 {
-            [s 0 blocked_clients] eq {1}
-        } else {
-            fail "Client is not blocked"
-        }
-        set id [r stream.add mystream field 1 value a]
-        assert_equal "{mystream {{$id {field 1 value a}}}}" [$rd1 read]
-        # Blocking XREAD on an existing stream
-        set rd2 [redis_deferring_client]
-        $rd2 XREAD BLOCK 3000 STREAMS mystream $
-        # wait until client is actually blocked
-        wait_for_condition 50 100 {
-            [s 0 blocked_clients] eq {1}
-        } else {
-            fail "Client is not blocked"
-        }
-        set id [r stream.add mystream field 2 value b]
-        assert_equal "{mystream {{$id {field 2 value b}}}}" [$rd2 read]
-    }
-    test {Module stream add benchmark (1M stream add)} {
-        set n 1000000
-        r del mystream
-        set result [r stream.addn mystream $n field value]
-        assert_equal $result $n
-    }
-    test {Module stream XADD big fields doesn't create empty key} {
-        set original_proto [config_get_set proto-max-bulk-len 2147483647] ;#2gb
-        set original_query [config_get_set client-query-buffer-limit 2147483647] ;#2gb
-        r del mystream
-        r write "*4\r\n\$10\r\nstream.add\r\n\$8\r\nmystream\r\n\$5\r\nfield\r\n"
-        catch {
-            write_big_bulk 1073741824 ;#1gb
-        } err
-        assert {$err eq "ERR StreamAdd failed"}
-        assert_equal 0 [r exists mystream]
-        # restore defaults
-        r config set proto-max-bulk-len $original_proto
-        r config set client-query-buffer-limit $original_query
-    } {OK} {large-memory}
-    test {Module stream iterator} {
-        r del mystream
-        set streamid1 [r xadd mystream * item 1 value a]
-        set streamid2 [r xadd mystream * item 2 value b]
-        # range result
-        set result1 [r stream.range mystream "-" "+"]
-        set expect1 [r xrange mystream "-" "+"]
-        assert_equal $result1 $expect1
-        # reverse range
-        set result_rev [r stream.range mystream "+" "-"]
-        set expect_rev [r xrevrange mystream "+" "-"]
-        assert_equal $result_rev $expect_rev
-        # only one item: range with startid = endid
-        set result2 [r stream.range mystream "-" $streamid1]
-        assert_equal $result2 "{$streamid1 {item 1 value a}}"
-        assert_equal $result2 [list [list $streamid1 {item 1 value a}]]
-        # only one item: range with startid = endid
-        set result3 [r stream.range mystream $streamid2 $streamid2]
-        assert_equal $result3 "{$streamid2 {item 2 value b}}"
-        assert_equal $result3 [list [list $streamid2 {item 2 value b}]]
-    }
-    test {Module stream iterator delete} {
-        r del mystream
-        set id1 [r xadd mystream * normal item]
-        set id2 [r xadd mystream * selfdestruct yes]
-        set id3 [r xadd mystream * another item]
-        # stream.range deletes the "selfdestruct" item after returning it
-        assert_equal \
-            "{$id1 {normal item}} {$id2 {selfdestruct yes}} {$id3 {another item}}" \
-            [r stream.range mystream - +]
-        # now, the "selfdestruct" item is gone
-        assert_equal \
-            "{$id1 {normal item}} {$id3 {another item}}" \
-            [r stream.range mystream - +]
-    }
-    test {Module stream trim by length} {
-        r del mystream
-        # exact maxlen
-        r xadd mystream * item 1 value a
-        r xadd mystream * item 2 value b
-        r xadd mystream * item 3 value c
-        assert_equal 3 [r xlen mystream]
-        assert_equal 0 [r stream.trim mystream maxlen = 5]
-        assert_equal 3 [r xlen mystream]
-        assert_equal 2 [r stream.trim mystream maxlen = 1]
-        assert_equal 1 [r xlen mystream]
-        assert_equal 1 [r stream.trim mystream maxlen = 0]
-        # check that there is no limit for exact maxlen
-        r stream.addn mystream 20000 item x value y
-        assert_equal 20000 [r stream.trim mystream maxlen = 0]
-        # approx maxlen (100 items per node implies default limit 10K items)
-        r stream.addn mystream 20000 item x value y
-        assert_equal 20000 [r xlen mystream]
-        assert_equal 10000 [r stream.trim mystream maxlen ~ 2]
-        assert_equal 9900  [r stream.trim mystream maxlen ~ 2]
-        assert_equal 0     [r stream.trim mystream maxlen ~ 2]
-        assert_equal 100   [r xlen mystream]
-        assert_equal 100   [r stream.trim mystream maxlen ~ 0]
-        assert_equal 0     [r xlen mystream]
-    }
-    test {Module stream trim by ID} {
-        r del mystream
-        # exact minid
-        r xadd mystream * item 1 value a
-        r xadd mystream * item 2 value b
-        set minid [r xadd mystream * item 3 value c]
-        assert_equal 3 [r xlen mystream]
-        assert_equal 0 [r stream.trim mystream minid = -]
-        assert_equal 3 [r xlen mystream]
-        assert_equal 2 [r stream.trim mystream minid = $minid]
-        assert_equal 1 [r xlen mystream]
-        assert_equal 1 [r stream.trim mystream minid = +]
-        # check that there is no limit for exact minid
-        r stream.addn mystream 20000 item x value y
-        assert_equal 20000 [r stream.trim mystream minid = +]
-        # approx minid (100 items per node implies default limit 10K items)
-        r stream.addn mystream 19980 item x value y
-        set minid [r xadd mystream * item x value y]
-        r stream.addn mystream 19 item x value y
-        assert_equal 20000 [r xlen mystream]
-        assert_equal 10000 [r stream.trim mystream minid ~ $minid]
-        assert_equal 9900  [r stream.trim mystream minid ~ $minid]
-        assert_equal 0     [r stream.trim mystream minid ~ $minid]
-        assert_equal 100   [r xlen mystream]
-        assert_equal 100   [r stream.trim mystream minid ~ +]
-        assert_equal 0     [r xlen mystream]
-    }
-    test "Unload the module - stream" {
-        assert_equal {OK} [r module unload stream]
-    }
-}

diff --git a/examples/redis-unstable/tests/unit/moduleapi/stream.tcl b/examples/redis-unstable/tests/unit/moduleapi/stream.tcl deleted file mode 100644 index cc235f8..0000000 --- a/examples/redis-unstable/tests/unit/moduleapi/stream.tcl +++ /dev/null
@@ -1,176 +0,0 @@
1	set testmodule [file normalize tests/modules/stream.so]
2
3	start_server {tags {"modules external:skip"}} {
4	r module load $testmodule
5
6	test {Module stream add and delete} {
7	r del mystream
8	# add to empty key
9	set streamid1 [r stream.add mystream item 1 value a]
10	# add to existing stream
11	set streamid2 [r stream.add mystream item 2 value b]
12	# check result
13	assert { [string match "-" $streamid1] }
14	set items [r XRANGE mystream - +]
15	assert_equal $items \
16	"{$streamid1 {item 1 value a}} {$streamid2 {item 2 value b}}"
17	# delete one of them and try deleting non-existing ID
18	assert_equal OK [r stream.delete mystream $streamid1]
19	assert_error "ERR StreamDelete*" {r stream.delete mystream 123-456}
20	assert_error "Invalid stream ID*" {r stream.delete mystream foo}
21	assert_equal "{$streamid2 {item 2 value b}}" [r XRANGE mystream - +]
22	# check error condition: wrong type
23	r del mystream
24	r set mystream mystring
25	assert_error "ERR StreamAdd*" {r stream.add mystream item 1 value a}
26	assert_error "ERR StreamDelete*" {r stream.delete mystream 123-456}
27	}
28
29	test {Module stream add unblocks blocking xread} {
30	r del mystream
31
32	# Blocking XREAD on an empty key
33	set rd1 [redis_deferring_client]
34	$rd1 XREAD BLOCK 3000 STREAMS mystream $
35	# wait until client is actually blocked
36	wait_for_condition 50 100 {
37	[s 0 blocked_clients] eq {1}
38	} else {
39	fail "Client is not blocked"
40	}
41	set id [r stream.add mystream field 1 value a]
42	assert_equal "{mystream {{$id {field 1 value a}}}}" [$rd1 read]
43
44	# Blocking XREAD on an existing stream
45	set rd2 [redis_deferring_client]
46	$rd2 XREAD BLOCK 3000 STREAMS mystream $
47	# wait until client is actually blocked
48	wait_for_condition 50 100 {
49	[s 0 blocked_clients] eq {1}
50	} else {
51	fail "Client is not blocked"
52	}
53	set id [r stream.add mystream field 2 value b]
54	assert_equal "{mystream {{$id {field 2 value b}}}}" [$rd2 read]
55	}
56
57	test {Module stream add benchmark (1M stream add)} {
58	set n 1000000
59	r del mystream
60	set result [r stream.addn mystream $n field value]
61	assert_equal $result $n
62	}
63
64	test {Module stream XADD big fields doesn't create empty key} {
65	set original_proto [config_get_set proto-max-bulk-len 2147483647] ;#2gb
66	set original_query [config_get_set client-query-buffer-limit 2147483647] ;#2gb
67
68	r del mystream
69	r write "*4\r\n\$10\r\nstream.add\r\n\$8\r\nmystream\r\n\$5\r\nfield\r\n"
70	catch {
71	write_big_bulk 1073741824 ;#1gb
72	} err
73	assert {$err eq "ERR StreamAdd failed"}
74	assert_equal 0 [r exists mystream]
75
76	# restore defaults
77	r config set proto-max-bulk-len $original_proto
78	r config set client-query-buffer-limit $original_query
79	} {OK} {large-memory}
80
81	test {Module stream iterator} {
82	r del mystream
83	set streamid1 [r xadd mystream * item 1 value a]
84	set streamid2 [r xadd mystream * item 2 value b]
85	# range result
86	set result1 [r stream.range mystream "-" "+"]
87	set expect1 [r xrange mystream "-" "+"]
88	assert_equal $result1 $expect1
89	# reverse range
90	set result_rev [r stream.range mystream "+" "-"]
91	set expect_rev [r xrevrange mystream "+" "-"]
92	assert_equal $result_rev $expect_rev
93
94	# only one item: range with startid = endid
95	set result2 [r stream.range mystream "-" $streamid1]
96	assert_equal $result2 "{$streamid1 {item 1 value a}}"
97	assert_equal $result2 [list [list $streamid1 {item 1 value a}]]
98	# only one item: range with startid = endid
99	set result3 [r stream.range mystream $streamid2 $streamid2]
100	assert_equal $result3 "{$streamid2 {item 2 value b}}"
101	assert_equal $result3 [list [list $streamid2 {item 2 value b}]]
102	}
103
104	test {Module stream iterator delete} {
105	r del mystream
106	set id1 [r xadd mystream * normal item]
107	set id2 [r xadd mystream * selfdestruct yes]
108	set id3 [r xadd mystream * another item]
109	# stream.range deletes the "selfdestruct" item after returning it
110	assert_equal \
111	"{$id1 {normal item}} {$id2 {selfdestruct yes}} {$id3 {another item}}" \
112	[r stream.range mystream - +]
113	# now, the "selfdestruct" item is gone
114	assert_equal \
115	"{$id1 {normal item}} {$id3 {another item}}" \
116	[r stream.range mystream - +]
117	}
118
119	test {Module stream trim by length} {
120	r del mystream
121	# exact maxlen
122	r xadd mystream * item 1 value a
123	r xadd mystream * item 2 value b
124	r xadd mystream * item 3 value c
125	assert_equal 3 [r xlen mystream]
126	assert_equal 0 [r stream.trim mystream maxlen = 5]
127	assert_equal 3 [r xlen mystream]
128	assert_equal 2 [r stream.trim mystream maxlen = 1]
129	assert_equal 1 [r xlen mystream]
130	assert_equal 1 [r stream.trim mystream maxlen = 0]
131	# check that there is no limit for exact maxlen
132	r stream.addn mystream 20000 item x value y
133	assert_equal 20000 [r stream.trim mystream maxlen = 0]
134	# approx maxlen (100 items per node implies default limit 10K items)
135	r stream.addn mystream 20000 item x value y
136	assert_equal 20000 [r xlen mystream]
137	assert_equal 10000 [r stream.trim mystream maxlen ~ 2]
138	assert_equal 9900 [r stream.trim mystream maxlen ~ 2]
139	assert_equal 0 [r stream.trim mystream maxlen ~ 2]
140	assert_equal 100 [r xlen mystream]
141	assert_equal 100 [r stream.trim mystream maxlen ~ 0]
142	assert_equal 0 [r xlen mystream]
143	}
144
145	test {Module stream trim by ID} {
146	r del mystream
147	# exact minid
148	r xadd mystream * item 1 value a
149	r xadd mystream * item 2 value b
150	set minid [r xadd mystream * item 3 value c]
151	assert_equal 3 [r xlen mystream]
152	assert_equal 0 [r stream.trim mystream minid = -]
153	assert_equal 3 [r xlen mystream]
154	assert_equal 2 [r stream.trim mystream minid = $minid]
155	assert_equal 1 [r xlen mystream]
156	assert_equal 1 [r stream.trim mystream minid = +]
157	# check that there is no limit for exact minid
158	r stream.addn mystream 20000 item x value y
159	assert_equal 20000 [r stream.trim mystream minid = +]
160	# approx minid (100 items per node implies default limit 10K items)
161	r stream.addn mystream 19980 item x value y
162	set minid [r xadd mystream * item x value y]
163	r stream.addn mystream 19 item x value y
164	assert_equal 20000 [r xlen mystream]
165	assert_equal 10000 [r stream.trim mystream minid ~ $minid]
166	assert_equal 9900 [r stream.trim mystream minid ~ $minid]
167	assert_equal 0 [r stream.trim mystream minid ~ $minid]
168	assert_equal 100 [r xlen mystream]
169	assert_equal 100 [r stream.trim mystream minid ~ +]
170	assert_equal 0 [r xlen mystream]
171	}
172
173	test "Unload the module - stream" {
174	assert_equal {OK} [r module unload stream]
175	}
176	}