Changesets can be listed by changeset number.
The Git repository is here.
- Revision:
- 193
- Log:
First stage commit of Typo 4.1, modified for the ROOL site.
Includes all local modifications but a final pass needs to be
made to delete any files left over from earlier Typo versions
that shouldn't be here anymore. See the 'tags' section of the
repository for a clean Typo 4.1 tree.Note that symlinks to shared files in the RISC OS Open theme
directory have been deliberately included this time around; I
decided that on balance it was better to leave them in as
placeholders, since unlike symlinks in app/views/shared, the
Typo theme structure is not a standard Rails concept.
- Author:
- rool
- Date:
- Wed Apr 04 18:51:02 +0100 2007
- Size:
- 6734 Bytes
1 | require 'stringio' |
2 | require 'test/unit' |
3 | |
4 | $TESTING = true |
5 | |
6 | require 'memcache' |
7 | |
8 | class MemCache |
9 | |
10 | attr_reader :servers |
11 | attr_writer :namespace |
12 | |
13 | end |
14 | |
15 | class FakeSocket |
16 | |
17 | attr_reader :written, :data |
18 | |
19 | def initialize |
20 | @written = StringIO.new |
21 | @data = StringIO.new |
22 | end |
23 | |
24 | def write(data) |
25 | @written.write data |
26 | end |
27 | |
28 | def gets |
29 | @data.gets |
30 | end |
31 | |
32 | def read(arg) |
33 | @data.read arg |
34 | end |
35 | |
36 | end |
37 | |
38 | class FakeServer |
39 | |
40 | attr_reader :socket |
41 | |
42 | def initialize(socket = nil) |
43 | @socket = socket || FakeSocket.new |
44 | end |
45 | |
46 | def close |
47 | end |
48 | |
49 | end |
50 | |
51 | class TestMemCache < Test::Unit::TestCase |
52 | |
53 | def setup |
54 | @cache = MemCache.new 'localhost:1', :namespace => 'my_namespace' |
55 | end |
56 | |
57 | def test_cache_get |
58 | server = util_setup_fake_server |
59 | |
60 | assert_equal "\004\b\"\0170123456789", |
61 | @cache.cache_get(server, 'my_namespace:key') |
62 | |
63 | assert_equal "get my_namespace:key\r\n", |
64 | server.socket.written.string |
65 | end |
66 | |
67 | def test_cache_get_miss |
68 | socket = FakeSocket.new |
69 | socket.data.write "END\r\n" |
70 | socket.data.rewind |
71 | server = FakeServer.new socket |
72 | |
73 | assert_equal nil, @cache.cache_get(server, 'my_namespace:key') |
74 | |
75 | assert_equal "get my_namespace:key\r\n", |
76 | socket.written.string |
77 | end |
78 | |
79 | def test_crc32_ITU_T |
80 | assert_equal 0, ''.crc32_ITU_T |
81 | assert_equal 1260851911, 'my_namespace:key'.crc32_ITU_T |
82 | end |
83 | |
84 | def test_initialize |
85 | cache = MemCache.new :namespace => 'my_namespace', :readonly => true |
86 | |
87 | assert_equal 'my_namespace', cache.namespace |
88 | assert_equal true, cache.readonly? |
89 | assert_equal true, cache.servers.empty? |
90 | end |
91 | |
92 | def test_initialize_compatible |
93 | cache = MemCache.new ['localhost:11211', 'localhost:11212'], |
94 | :namespace => 'my_namespace', :readonly => true |
95 | |
96 | assert_equal 'my_namespace', cache.namespace |
97 | assert_equal true, cache.readonly? |
98 | assert_equal false, cache.servers.empty? |
99 | end |
100 | |
101 | def test_initialize_compatible_no_hash |
102 | cache = MemCache.new ['localhost:11211', 'localhost:11212'] |
103 | |
104 | assert_equal nil, cache.namespace |
105 | assert_equal false, cache.readonly? |
106 | assert_equal false, cache.servers.empty? |
107 | end |
108 | |
109 | def test_initialize_compatible_one_server |
110 | cache = MemCache.new 'localhost:11211' |
111 | |
112 | assert_equal nil, cache.namespace |
113 | assert_equal false, cache.readonly? |
114 | assert_equal false, cache.servers.empty? |
115 | end |
116 | |
117 | def test_initialize_compatible_bad_arg |
118 | e = assert_raise ArgumentError do |
119 | cache = MemCache.new Object.new |
120 | end |
121 | |
122 | assert_equal 'first argument must be Array, Hash or String', e.message |
123 | end |
124 | |
125 | def test_initialize_too_many_args |
126 | assert_raises ArgumentError do |
127 | MemCache.new 1, 2, 3 |
128 | end |
129 | end |
130 | |
131 | def test_get |
132 | util_setup_fake_server |
133 | |
134 | value = @cache.get 'key' |
135 | |
136 | assert_equal "get my_namespace:key\r\n", |
137 | @cache.servers.first.socket.written.string |
138 | |
139 | assert_equal '0123456789', value |
140 | end |
141 | |
142 | def test_get_cache_get_IOError |
143 | socket = Object.new |
144 | def socket.write(arg) raise IOError, 'some io error'; end |
145 | server = FakeServer.new socket |
146 | |
147 | @cache.servers = [] |
148 | @cache.servers << server |
149 | |
150 | e = assert_raise MemCache::MemCacheError do |
151 | @cache.get 'my_namespace:key' |
152 | end |
153 | |
154 | assert_equal 'some io error', e.message |
155 | end |
156 | |
157 | def test_get_cache_get_SystemCallError |
158 | socket = Object.new |
159 | def socket.write(arg) raise SystemCallError, 'some syscall error'; end |
160 | server = FakeServer.new socket |
161 | |
162 | @cache.servers = [] |
163 | @cache.servers << server |
164 | |
165 | e = assert_raise MemCache::MemCacheError do |
166 | @cache.get 'my_namespace:key' |
167 | end |
168 | |
169 | assert_equal 'unknown error - some syscall error', e.message |
170 | end |
171 | |
172 | def test_get_no_connection |
173 | @cache.servers = 'localhost:1' |
174 | e = assert_raise MemCache::MemCacheError do |
175 | @cache.get 'key' |
176 | end |
177 | |
178 | assert_equal 'No connection to server', e.message |
179 | end |
180 | |
181 | def test_get_no_servers |
182 | @cache.servers = [] |
183 | e = assert_raise MemCache::MemCacheError do |
184 | @cache.get 'key' |
185 | end |
186 | |
187 | assert_equal 'No active servers', e.message |
188 | end |
189 | |
190 | def test_get_multi |
191 | util_setup_fake_server |
192 | |
193 | values = @cache.get_multi 'keya', 'keyb' |
194 | |
195 | assert_equal "get my_namespace:keya\r\nget my_namespace:keyb\r\n", |
196 | @cache.servers.first.socket.written.string |
197 | |
198 | expected = { 'keya' => '0123456789', 'keyb' => nil } |
199 | assert_equal expected, values |
200 | end |
201 | |
202 | def test_get_server_for_key |
203 | server = @cache.get_server_for_key 'key' |
204 | assert_equal 'localhost', server.host |
205 | assert_equal 1, server.port |
206 | end |
207 | |
208 | def test_get_server_for_key_multiple |
209 | s1 = util_setup_server @cache, 'one.example.com', '' |
210 | s2 = util_setup_server @cache, 'two.example.com', '' |
211 | @cache.instance_variable_set :@servers, [s1, s2] |
212 | @cache.instance_variable_set :@buckets, [s1, s2] |
213 | |
214 | server = @cache.get_server_for_key 'keya' |
215 | assert_equal 'two.example.com', server.host |
216 | server = @cache.get_server_for_key 'keyb' |
217 | assert_equal 'one.example.com', server.host |
218 | end |
219 | |
220 | def test_get_server_for_key_no_servers |
221 | @cache.servers = [] |
222 | |
223 | e = assert_raise MemCache::MemCacheError do |
224 | @cache.get_server_for_key 'key' |
225 | end |
226 | |
227 | assert_equal 'No servers available', e.message |
228 | end |
229 | |
230 | def test_make_cache_key |
231 | assert_equal 'my_namespace:key', @cache.make_cache_key('key') |
232 | @cache.namespace = nil |
233 | assert_equal 'key', @cache.make_cache_key('key') |
234 | end |
235 | |
236 | def test_basic_threaded_operations_should_work |
237 | cache = MemCache.new :multithread => true, |
238 | :namespace => 'my_namespace', |
239 | :readonly => false |
240 | server = util_setup_server cache, 'example.com', "OK\r\n" |
241 | cache.instance_variable_set :@servers, [server] |
242 | |
243 | assert_nothing_raised do |
244 | cache.set "test", "test value" |
245 | end |
246 | end |
247 | |
248 | def test_basic_unthreaded_operations_should_work |
249 | cache = MemCache.new :multithread => false, |
250 | :namespace => 'my_namespace', |
251 | :readonly => false |
252 | server = util_setup_server cache, 'example.com', "OK\r\n" |
253 | cache.instance_variable_set :@servers, [server] |
254 | |
255 | assert_nothing_raised do |
256 | cache.set "test", "test value" |
257 | end |
258 | end |
259 | |
260 | def util_setup_fake_server |
261 | server = FakeServer.new |
262 | server.socket.data.write "VALUE my_namepsace:key 0 14\r\n" |
263 | server.socket.data.write "\004\b\"\0170123456789\r\n" |
264 | server.socket.data.write "END\r\n" |
265 | server.socket.data.rewind |
266 | |
267 | @cache.servers = [] |
268 | @cache.servers << server |
269 | |
270 | return server |
271 | end |
272 | |
273 | def util_setup_server(memcache, host, responses) |
274 | server = MemCache::Server.new memcache, host |
275 | server.instance_variable_set :@sock, StringIO.new(responses) |
276 | |
277 | @cache.servers = [] |
278 | @cache.servers << server |
279 | |
280 | return server |
281 | end |
282 | |
283 | end |
284 |