gvsig-scripting / org.gvsig.scripting / trunk / org.gvsig.scripting / org.gvsig.scripting.app / org.gvsig.scripting.app.mainplugin / src / main / resources-plugin / scripting / lib / dulwich / contrib / test_swift.py @ 959
History | View | Annotate | Download (24.1 KB)
1 | 959 | jjdelcerro | # test_swift.py -- Unittests for the Swift backend.
|
---|---|---|---|
2 | # Copyright (C) 2013 eNovance SAS <licensing@enovance.com>
|
||
3 | #
|
||
4 | # Author: Fabien Boucher <fabien.boucher@enovance.com>
|
||
5 | #
|
||
6 | # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
|
||
7 | # General Public License as public by the Free Software Foundation; version 2.0
|
||
8 | # or (at your option) any later version. You can redistribute it and/or
|
||
9 | # modify it under the terms of either of these two licenses.
|
||
10 | #
|
||
11 | # Unless required by applicable law or agreed to in writing, software
|
||
12 | # distributed under the License is distributed on an "AS IS" BASIS,
|
||
13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
14 | # See the License for the specific language governing permissions and
|
||
15 | # limitations under the License.
|
||
16 | #
|
||
17 | # You should have received a copy of the licenses; if not, see
|
||
18 | # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
|
||
19 | # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
|
||
20 | # License, Version 2.0.
|
||
21 | #
|
||
22 | |||
23 | """Tests for dulwich.contrib.swift."""
|
||
24 | |||
25 | import posixpath |
||
26 | |||
27 | from time import time |
||
28 | from io import BytesIO |
||
29 | try:
|
||
30 | from StringIO import StringIO |
||
31 | except ImportError: |
||
32 | from io import StringIO |
||
33 | |||
34 | import sys |
||
35 | from unittest import skipIf |
||
36 | |||
37 | from dulwich.tests import ( |
||
38 | TestCase, |
||
39 | ) |
||
40 | from dulwich.tests.test_object_store import ( |
||
41 | ObjectStoreTests, |
||
42 | ) |
||
43 | from dulwich.tests.utils import ( |
||
44 | build_pack, |
||
45 | ) |
||
46 | from dulwich.objects import ( |
||
47 | Blob, |
||
48 | Commit, |
||
49 | Tree, |
||
50 | Tag, |
||
51 | parse_timezone, |
||
52 | ) |
||
53 | from dulwich.pack import ( |
||
54 | REF_DELTA, |
||
55 | write_pack_index_v2, |
||
56 | PackData, |
||
57 | load_pack_index_file, |
||
58 | ) |
||
59 | |||
60 | try:
|
||
61 | from simplejson import dumps as json_dumps |
||
62 | except ImportError: |
||
63 | from json import dumps as json_dumps |
||
64 | |||
65 | missing_libs = [] |
||
66 | |||
67 | try:
|
||
68 | import gevent |
||
69 | except ImportError: |
||
70 | missing_libs.append("gevent")
|
||
71 | |||
72 | try:
|
||
73 | import geventhttpclient |
||
74 | except ImportError: |
||
75 | missing_libs.append("geventhttpclient")
|
||
76 | |||
77 | try:
|
||
78 | from mock import patch |
||
79 | except ImportError: |
||
80 | missing_libs.append("mock")
|
||
81 | |||
82 | skipmsg = "Required libraries are not installed (%r)" % missing_libs
|
||
83 | |||
84 | skipIfPY3 = skipIf(sys.version_info[0] == 3, "SWIFT module not yet ported to python3.") |
||
85 | |||
86 | if not missing_libs: |
||
87 | from dulwich.contrib import swift |
||
88 | |||
89 | config_file = """[swift]
|
||
90 | auth_url = http://127.0.0.1:8080/auth/%(version_str)s
|
||
91 | auth_ver = %(version_int)s
|
||
92 | username = test;tester
|
||
93 | password = testing
|
||
94 | region_name = %(region_name)s
|
||
95 | endpoint_type = %(endpoint_type)s
|
||
96 | concurrency = %(concurrency)s
|
||
97 | chunk_length = %(chunk_length)s
|
||
98 | cache_length = %(cache_length)s
|
||
99 | http_pool_length = %(http_pool_length)s
|
||
100 | http_timeout = %(http_timeout)s
|
||
101 | """
|
||
102 | |||
103 | def_config_file = {'version_str': 'v1.0', |
||
104 | 'version_int': 1, |
||
105 | 'concurrency': 1, |
||
106 | 'chunk_length': 12228, |
||
107 | 'cache_length': 1, |
||
108 | 'region_name': 'test', |
||
109 | 'endpoint_type': 'internalURL', |
||
110 | 'http_pool_length': 1, |
||
111 | 'http_timeout': 1} |
||
112 | |||
113 | |||
114 | def create_swift_connector(store={}): |
||
115 | return lambda root, conf: FakeSwiftConnector(root, |
||
116 | conf=conf, |
||
117 | store=store) |
||
118 | |||
119 | |||
120 | class Response(object): |
||
121 | |||
122 | def __init__(self, headers={}, status=200, content=None): |
||
123 | self.headers = headers
|
||
124 | self.status_code = status
|
||
125 | self.content = content
|
||
126 | |||
127 | def __getitem__(self, key): |
||
128 | return self.headers[key] |
||
129 | |||
130 | def items(self): |
||
131 | return self.headers.items() |
||
132 | |||
133 | def read(self): |
||
134 | return self.content |
||
135 | |||
136 | |||
137 | def fake_auth_request_v1(*args, **kwargs): |
||
138 | ret = Response({'X-Storage-Url':
|
||
139 | 'http://127.0.0.1:8080/v1.0/AUTH_fakeuser',
|
||
140 | 'X-Auth-Token': '12' * 10}, |
||
141 | 200)
|
||
142 | return ret
|
||
143 | |||
144 | |||
145 | def fake_auth_request_v1_error(*args, **kwargs): |
||
146 | ret = Response({}, |
||
147 | 401)
|
||
148 | return ret
|
||
149 | |||
150 | |||
151 | def fake_auth_request_v2(*args, **kwargs): |
||
152 | s_url = 'http://127.0.0.1:8080/v1.0/AUTH_fakeuser'
|
||
153 | resp = {'access': {'token': {'id': '12' * 10}, |
||
154 | 'serviceCatalog':
|
||
155 | [ |
||
156 | {'type': 'object-store', |
||
157 | 'endpoints': [{'region': 'test', |
||
158 | 'internalURL': s_url,
|
||
159 | }, |
||
160 | ] |
||
161 | }, |
||
162 | ] |
||
163 | } |
||
164 | } |
||
165 | ret = Response(status=200, content=json_dumps(resp))
|
||
166 | return ret
|
||
167 | |||
168 | |||
169 | def create_commit(data, marker=b'Default', blob=None): |
||
170 | if not blob: |
||
171 | blob = Blob.from_string(b'The blob content ' + marker)
|
||
172 | tree = Tree() |
||
173 | tree.add(b"thefile_" + marker, 0o100644, blob.id) |
||
174 | cmt = Commit() |
||
175 | if data:
|
||
176 | assert isinstance(data[-1], Commit) |
||
177 | cmt.parents = [data[-1].id]
|
||
178 | cmt.tree = tree.id |
||
179 | author = b"John Doe " + marker + b" <john@doe.net>" |
||
180 | cmt.author = cmt.committer = author |
||
181 | tz = parse_timezone(b'-0200')[0] |
||
182 | cmt.commit_time = cmt.author_time = int(time())
|
||
183 | cmt.commit_timezone = cmt.author_timezone = tz |
||
184 | cmt.encoding = b"UTF-8"
|
||
185 | cmt.message = b"The commit message " + marker
|
||
186 | tag = Tag() |
||
187 | tag.tagger = b"john@doe.net"
|
||
188 | tag.message = b"Annotated tag"
|
||
189 | tag.tag_timezone = parse_timezone(b'-0200')[0] |
||
190 | tag.tag_time = cmt.author_time |
||
191 | tag.object = (Commit, cmt.id) |
||
192 | tag.name = b"v_" + marker + b"_0.1" |
||
193 | return blob, tree, tag, cmt
|
||
194 | |||
195 | |||
196 | def create_commits(length=1, marker=b'Default'): |
||
197 | data = [] |
||
198 | for i in range(0, length): |
||
199 | _marker = ("%s_%s" % (marker, i)).encode()
|
||
200 | blob, tree, tag, cmt = create_commit(data, _marker) |
||
201 | data.extend([blob, tree, tag, cmt]) |
||
202 | return data
|
||
203 | |||
204 | @skipIf(missing_libs, skipmsg)
|
||
205 | class FakeSwiftConnector(object): |
||
206 | |||
207 | def __init__(self, root, conf, store=None): |
||
208 | if store:
|
||
209 | self.store = store
|
||
210 | else:
|
||
211 | self.store = {}
|
||
212 | self.conf = conf
|
||
213 | self.root = root
|
||
214 | self.concurrency = 1 |
||
215 | self.chunk_length = 12228 |
||
216 | self.cache_length = 1 |
||
217 | |||
218 | def put_object(self, name, content): |
||
219 | name = posixpath.join(self.root, name)
|
||
220 | if hasattr(content, 'seek'): |
||
221 | content.seek(0)
|
||
222 | content = content.read() |
||
223 | self.store[name] = content
|
||
224 | |||
225 | def get_object(self, name, range=None): |
||
226 | name = posixpath.join(self.root, name)
|
||
227 | if not range: |
||
228 | try:
|
||
229 | return BytesIO(self.store[name]) |
||
230 | except KeyError: |
||
231 | return None |
||
232 | else:
|
||
233 | l, r = range.split('-') |
||
234 | try:
|
||
235 | if not l: |
||
236 | r = -int(r)
|
||
237 | return self.store[name][r:] |
||
238 | else:
|
||
239 | return self.store[name][int(l):int(r)] |
||
240 | except KeyError: |
||
241 | return None |
||
242 | |||
243 | def get_container_objects(self): |
||
244 | return [{'name': k.replace(self.root + '/', '')} |
||
245 | for k in self.store] |
||
246 | |||
247 | def create_root(self): |
||
248 | if self.root in self.store.keys(): |
||
249 | pass
|
||
250 | else:
|
||
251 | self.store[self.root] = '' |
||
252 | |||
253 | def get_object_stat(self, name): |
||
254 | name = posixpath.join(self.root, name)
|
||
255 | if not name in self.store: |
||
256 | return None |
||
257 | return {'content-length': len(self.store[name])} |
||
258 | |||
259 | |||
260 | @skipIf(missing_libs, skipmsg)
|
||
261 | @skipIfPY3
|
||
262 | class TestSwiftObjectStore(TestCase): |
||
263 | |||
264 | def setUp(self): |
||
265 | super(TestSwiftObjectStore, self).setUp() |
||
266 | self.conf = swift.load_conf(file=StringIO(config_file %
|
||
267 | def_config_file)) |
||
268 | self.fsc = FakeSwiftConnector('fakerepo', conf=self.conf) |
||
269 | |||
270 | def _put_pack(self, sos, commit_amount=1, marker='Default'): |
||
271 | odata = create_commits(length=commit_amount, marker=marker) |
||
272 | data = [(d.type_num, d.as_raw_string()) for d in odata] |
||
273 | f = BytesIO() |
||
274 | build_pack(f, data, store=sos) |
||
275 | sos.add_thin_pack(f.read, None)
|
||
276 | return odata
|
||
277 | |||
278 | def test_load_packs(self): |
||
279 | store = {'fakerepo/objects/pack/pack-'+'1'*40+'.idx': '', |
||
280 | 'fakerepo/objects/pack/pack-'+'1'*40+'.pack': '', |
||
281 | 'fakerepo/objects/pack/pack-'+'1'*40+'.info': '', |
||
282 | 'fakerepo/objects/pack/pack-'+'2'*40+'.idx': '', |
||
283 | 'fakerepo/objects/pack/pack-'+'2'*40+'.pack': '', |
||
284 | 'fakerepo/objects/pack/pack-'+'2'*40+'.info': ''} |
||
285 | fsc = FakeSwiftConnector('fakerepo', conf=self.conf, store=store) |
||
286 | sos = swift.SwiftObjectStore(fsc) |
||
287 | packs = sos._load_packs() |
||
288 | self.assertEqual(len(packs), 2) |
||
289 | for pack in packs: |
||
290 | self.assertTrue(isinstance(pack, swift.SwiftPack)) |
||
291 | |||
292 | def test_add_thin_pack(self): |
||
293 | sos = swift.SwiftObjectStore(self.fsc)
|
||
294 | self._put_pack(sos, 1, 'Default') |
||
295 | self.assertEqual(len(self.fsc.store), 3) |
||
296 | |||
297 | def test_find_missing_objects(self): |
||
298 | commit_amount = 3
|
||
299 | sos = swift.SwiftObjectStore(self.fsc)
|
||
300 | odata = self._put_pack(sos, commit_amount, 'Default') |
||
301 | head = odata[-1].id
|
||
302 | i = sos.iter_shas(sos.find_missing_objects([], |
||
303 | [head, ], |
||
304 | progress=None,
|
||
305 | get_tagged=None))
|
||
306 | self.assertEqual(len(i), commit_amount * 3) |
||
307 | shas = [d.id for d in odata] |
||
308 | for sha, path in i: |
||
309 | self.assertIn(sha.id, shas)
|
||
310 | |||
311 | def test_find_missing_objects_with_tag(self): |
||
312 | commit_amount = 3
|
||
313 | sos = swift.SwiftObjectStore(self.fsc)
|
||
314 | odata = self._put_pack(sos, commit_amount, 'Default') |
||
315 | head = odata[-1].id
|
||
316 | peeled_sha = dict([(sha.object[1], sha.id) |
||
317 | for sha in odata if isinstance(sha, Tag)]) |
||
318 | get_tagged = lambda: peeled_sha
|
||
319 | i = sos.iter_shas(sos.find_missing_objects([], |
||
320 | [head, ], |
||
321 | progress=None,
|
||
322 | get_tagged=get_tagged)) |
||
323 | self.assertEqual(len(i), commit_amount * 4) |
||
324 | shas = [d.id for d in odata] |
||
325 | for sha, path in i: |
||
326 | self.assertIn(sha.id, shas)
|
||
327 | |||
328 | def test_find_missing_objects_with_common(self): |
||
329 | commit_amount = 3
|
||
330 | sos = swift.SwiftObjectStore(self.fsc)
|
||
331 | odata = self._put_pack(sos, commit_amount, 'Default') |
||
332 | head = odata[-1].id
|
||
333 | have = odata[7].id
|
||
334 | i = sos.iter_shas(sos.find_missing_objects([have, ], |
||
335 | [head, ], |
||
336 | progress=None,
|
||
337 | get_tagged=None))
|
||
338 | self.assertEqual(len(i), 3) |
||
339 | |||
340 | def test_find_missing_objects_multiple_packs(self): |
||
341 | sos = swift.SwiftObjectStore(self.fsc)
|
||
342 | commit_amount_a = 3
|
||
343 | odataa = self._put_pack(sos, commit_amount_a, 'Default1') |
||
344 | heada = odataa[-1].id
|
||
345 | commit_amount_b = 2
|
||
346 | odatab = self._put_pack(sos, commit_amount_b, 'Default2') |
||
347 | headb = odatab[-1].id
|
||
348 | i = sos.iter_shas(sos.find_missing_objects([], |
||
349 | [heada, headb], |
||
350 | progress=None,
|
||
351 | get_tagged=None))
|
||
352 | self.assertEqual(len(self.fsc.store), 6) |
||
353 | self.assertEqual(len(i), |
||
354 | commit_amount_a * 3 +
|
||
355 | commit_amount_b * 3)
|
||
356 | shas = [d.id for d in odataa] |
||
357 | shas.extend([d.id for d in odatab]) |
||
358 | for sha, path in i: |
||
359 | self.assertIn(sha.id, shas)
|
||
360 | |||
361 | def test_add_thin_pack_ext_ref(self): |
||
362 | sos = swift.SwiftObjectStore(self.fsc)
|
||
363 | odata = self._put_pack(sos, 1, 'Default1') |
||
364 | ref_blob_content = odata[0].as_raw_string()
|
||
365 | ref_blob_id = odata[0].id
|
||
366 | new_blob = Blob.from_string(ref_blob_content.replace('blob',
|
||
367 | 'yummy blob'))
|
||
368 | blob, tree, tag, cmt = \ |
||
369 | create_commit([], marker='Default2', blob=new_blob)
|
||
370 | data = [(REF_DELTA, (ref_blob_id, blob.as_raw_string())), |
||
371 | (tree.type_num, tree.as_raw_string()), |
||
372 | (cmt.type_num, cmt.as_raw_string()), |
||
373 | (tag.type_num, tag.as_raw_string())] |
||
374 | f = BytesIO() |
||
375 | build_pack(f, data, store=sos) |
||
376 | sos.add_thin_pack(f.read, None)
|
||
377 | self.assertEqual(len(self.fsc.store), 6) |
||
378 | |||
379 | |||
380 | @skipIf(missing_libs, skipmsg)
|
||
381 | class TestSwiftRepo(TestCase): |
||
382 | |||
383 | def setUp(self): |
||
384 | super(TestSwiftRepo, self).setUp() |
||
385 | self.conf = swift.load_conf(file=StringIO(config_file %
|
||
386 | def_config_file)) |
||
387 | |||
388 | def test_init(self): |
||
389 | store = {'fakerepo/objects/pack': ''} |
||
390 | with patch('dulwich.contrib.swift.SwiftConnector', |
||
391 | new_callable=create_swift_connector, |
||
392 | store=store): |
||
393 | swift.SwiftRepo('fakerepo', conf=self.conf) |
||
394 | |||
395 | def test_init_no_data(self): |
||
396 | with patch('dulwich.contrib.swift.SwiftConnector', |
||
397 | new_callable=create_swift_connector): |
||
398 | self.assertRaises(Exception, swift.SwiftRepo, |
||
399 | 'fakerepo', self.conf) |
||
400 | |||
401 | def test_init_bad_data(self): |
||
402 | store = {'fakerepo/.git/objects/pack': ''} |
||
403 | with patch('dulwich.contrib.swift.SwiftConnector', |
||
404 | new_callable=create_swift_connector, |
||
405 | store=store): |
||
406 | self.assertRaises(Exception, swift.SwiftRepo, |
||
407 | 'fakerepo', self.conf) |
||
408 | |||
409 | def test_put_named_file(self): |
||
410 | store = {'fakerepo/objects/pack': ''} |
||
411 | with patch('dulwich.contrib.swift.SwiftConnector', |
||
412 | new_callable=create_swift_connector, |
||
413 | store=store): |
||
414 | repo = swift.SwiftRepo('fakerepo', conf=self.conf) |
||
415 | desc = b'Fake repo'
|
||
416 | repo._put_named_file('description', desc)
|
||
417 | self.assertEqual(repo.scon.store['fakerepo/description'], |
||
418 | desc) |
||
419 | |||
420 | def test_init_bare(self): |
||
421 | fsc = FakeSwiftConnector('fakeroot', conf=self.conf) |
||
422 | with patch('dulwich.contrib.swift.SwiftConnector', |
||
423 | new_callable=create_swift_connector, |
||
424 | store=fsc.store): |
||
425 | swift.SwiftRepo.init_bare(fsc, conf=self.conf)
|
||
426 | self.assertIn('fakeroot/objects/pack', fsc.store) |
||
427 | self.assertIn('fakeroot/info/refs', fsc.store) |
||
428 | self.assertIn('fakeroot/description', fsc.store) |
||
429 | |||
430 | |||
431 | @skipIf(missing_libs, skipmsg)
|
||
432 | @skipIfPY3
|
||
433 | class TestPackInfoLoadDump(TestCase): |
||
434 | |||
435 | def setUp(self): |
||
436 | super(TestPackInfoLoadDump, self).setUp() |
||
437 | conf = swift.load_conf(file=StringIO(config_file % |
||
438 | def_config_file)) |
||
439 | sos = swift.SwiftObjectStore( |
||
440 | FakeSwiftConnector('fakerepo', conf=conf))
|
||
441 | commit_amount = 10
|
||
442 | self.commits = create_commits(length=commit_amount, marker="m") |
||
443 | data = [(d.type_num, d.as_raw_string()) for d in self.commits] |
||
444 | f = BytesIO() |
||
445 | fi = BytesIO() |
||
446 | expected = build_pack(f, data, store=sos) |
||
447 | entries = [(sha, ofs, checksum) for
|
||
448 | ofs, _, _, sha, checksum in expected]
|
||
449 | self.pack_data = PackData.from_file(file=f, size=None) |
||
450 | write_pack_index_v2( |
||
451 | fi, entries, self.pack_data.calculate_checksum())
|
||
452 | fi.seek(0)
|
||
453 | self.pack_index = load_pack_index_file('', fi) |
||
454 | |||
455 | # def test_pack_info_perf(self):
|
||
456 | # dump_time = []
|
||
457 | # load_time = []
|
||
458 | # for i in range(0, 100):
|
||
459 | # start = time()
|
||
460 | # dumps = swift.pack_info_create(self.pack_data, self.pack_index)
|
||
461 | # dump_time.append(time() - start)
|
||
462 | # for i in range(0, 100):
|
||
463 | # start = time()
|
||
464 | # pack_infos = swift.load_pack_info('', file=BytesIO(dumps))
|
||
465 | # load_time.append(time() - start)
|
||
466 | # print sum(dump_time) / float(len(dump_time))
|
||
467 | # print sum(load_time) / float(len(load_time))
|
||
468 | |||
469 | def test_pack_info(self): |
||
470 | dumps = swift.pack_info_create(self.pack_data, self.pack_index) |
||
471 | pack_infos = swift.load_pack_info('', file=BytesIO(dumps))
|
||
472 | for obj in self.commits: |
||
473 | self.assertIn(obj.id, pack_infos)
|
||
474 | |||
475 | |||
476 | @skipIf(missing_libs, skipmsg)
|
||
477 | class TestSwiftInfoRefsContainer(TestCase): |
||
478 | |||
479 | def setUp(self): |
||
480 | super(TestSwiftInfoRefsContainer, self).setUp() |
||
481 | content = \ |
||
482 | b"22effb216e3a82f97da599b8885a6cadb488b4c5\trefs/heads/master\n" + \
|
||
483 | b"cca703b0e1399008b53a1a236d6b4584737649e4\trefs/heads/dev"
|
||
484 | self.store = {'fakerepo/info/refs': content} |
||
485 | self.conf = swift.load_conf(file=StringIO(config_file %
|
||
486 | def_config_file)) |
||
487 | self.fsc = FakeSwiftConnector('fakerepo', conf=self.conf) |
||
488 | self.object_store = {}
|
||
489 | |||
490 | def test_init(self): |
||
491 | """info/refs does not exists"""
|
||
492 | irc = swift.SwiftInfoRefsContainer(self.fsc, self.object_store) |
||
493 | self.assertEqual(len(irc._refs), 0) |
||
494 | self.fsc.store = self.store |
||
495 | irc = swift.SwiftInfoRefsContainer(self.fsc, self.object_store) |
||
496 | self.assertIn(b'refs/heads/dev', irc.allkeys()) |
||
497 | self.assertIn(b'refs/heads/master', irc.allkeys()) |
||
498 | |||
499 | def test_set_if_equals(self): |
||
500 | self.fsc.store = self.store |
||
501 | irc = swift.SwiftInfoRefsContainer(self.fsc, self.object_store) |
||
502 | irc.set_if_equals(b'refs/heads/dev',
|
||
503 | b"cca703b0e1399008b53a1a236d6b4584737649e4", b'1'*40) |
||
504 | self.assertEqual(irc[b'refs/heads/dev'], b'1'*40) |
||
505 | |||
506 | def test_remove_if_equals(self): |
||
507 | self.fsc.store = self.store |
||
508 | irc = swift.SwiftInfoRefsContainer(self.fsc, self.object_store) |
||
509 | irc.remove_if_equals(b'refs/heads/dev',
|
||
510 | b"cca703b0e1399008b53a1a236d6b4584737649e4")
|
||
511 | self.assertNotIn(b'refs/heads/dev', irc.allkeys()) |
||
512 | |||
513 | |||
514 | @skipIf(missing_libs, skipmsg)
|
||
515 | class TestSwiftConnector(TestCase): |
||
516 | |||
517 | def setUp(self): |
||
518 | super(TestSwiftConnector, self).setUp() |
||
519 | self.conf = swift.load_conf(file=StringIO(config_file %
|
||
520 | def_config_file)) |
||
521 | with patch('geventhttpclient.HTTPClient.request', |
||
522 | fake_auth_request_v1): |
||
523 | self.conn = swift.SwiftConnector('fakerepo', conf=self.conf) |
||
524 | |||
525 | def test_init_connector(self): |
||
526 | self.assertEqual(self.conn.auth_ver, '1') |
||
527 | self.assertEqual(self.conn.auth_url, |
||
528 | 'http://127.0.0.1:8080/auth/v1.0')
|
||
529 | self.assertEqual(self.conn.user, 'test:tester') |
||
530 | self.assertEqual(self.conn.password, 'testing') |
||
531 | self.assertEqual(self.conn.root, 'fakerepo') |
||
532 | self.assertEqual(self.conn.storage_url, |
||
533 | 'http://127.0.0.1:8080/v1.0/AUTH_fakeuser')
|
||
534 | self.assertEqual(self.conn.token, '12' * 10) |
||
535 | self.assertEqual(self.conn.http_timeout, 1) |
||
536 | self.assertEqual(self.conn.http_pool_length, 1) |
||
537 | self.assertEqual(self.conn.concurrency, 1) |
||
538 | self.conf.set('swift', 'auth_ver', '2') |
||
539 | self.conf.set('swift', 'auth_url', 'http://127.0.0.1:8080/auth/v2.0') |
||
540 | with patch('geventhttpclient.HTTPClient.request', |
||
541 | fake_auth_request_v2): |
||
542 | conn = swift.SwiftConnector('fakerepo', conf=self.conf) |
||
543 | self.assertEqual(conn.user, 'tester') |
||
544 | self.assertEqual(conn.tenant, 'test') |
||
545 | self.conf.set('swift', 'auth_ver', '1') |
||
546 | self.conf.set('swift', 'auth_url', 'http://127.0.0.1:8080/auth/v1.0') |
||
547 | with patch('geventhttpclient.HTTPClient.request', |
||
548 | fake_auth_request_v1_error): |
||
549 | self.assertRaises(swift.SwiftException,
|
||
550 | lambda: swift.SwiftConnector('fakerepo', |
||
551 | conf=self.conf))
|
||
552 | |||
553 | def test_root_exists(self): |
||
554 | with patch('geventhttpclient.HTTPClient.request', |
||
555 | lambda *args: Response()):
|
||
556 | self.assertEqual(self.conn.test_root_exists(), True) |
||
557 | |||
558 | def test_root_not_exists(self): |
||
559 | with patch('geventhttpclient.HTTPClient.request', |
||
560 | lambda *args: Response(status=404)): |
||
561 | self.assertEqual(self.conn.test_root_exists(), None) |
||
562 | |||
563 | def test_create_root(self): |
||
564 | with patch('dulwich.contrib.swift.SwiftConnector.test_root_exists', |
||
565 | lambda *args: None): |
||
566 | with patch('geventhttpclient.HTTPClient.request', |
||
567 | lambda *args: Response()):
|
||
568 | self.assertEqual(self.conn.create_root(), None) |
||
569 | |||
570 | def test_create_root_fails(self): |
||
571 | with patch('dulwich.contrib.swift.SwiftConnector.test_root_exists', |
||
572 | lambda *args: None): |
||
573 | with patch('geventhttpclient.HTTPClient.request', |
||
574 | lambda *args: Response(status=404)): |
||
575 | self.assertRaises(swift.SwiftException,
|
||
576 | lambda: self.conn.create_root()) |
||
577 | |||
578 | def test_get_container_objects(self): |
||
579 | with patch('geventhttpclient.HTTPClient.request', |
||
580 | lambda *args: Response(content=json_dumps(
|
||
581 | (({'name': 'a'}, {'name': 'b'}))))): |
||
582 | self.assertEqual(len(self.conn.get_container_objects()), 2) |
||
583 | |||
584 | def test_get_container_objects_fails(self): |
||
585 | with patch('geventhttpclient.HTTPClient.request', |
||
586 | lambda *args: Response(status=404)): |
||
587 | self.assertEqual(self.conn.get_container_objects(), None) |
||
588 | |||
589 | def test_get_object_stat(self): |
||
590 | with patch('geventhttpclient.HTTPClient.request', |
||
591 | lambda *args: Response(headers={'content-length': '10'})): |
||
592 | self.assertEqual(self.conn.get_object_stat('a')['content-length'], |
||
593 | '10')
|
||
594 | |||
595 | def test_get_object_stat_fails(self): |
||
596 | with patch('geventhttpclient.HTTPClient.request', |
||
597 | lambda *args: Response(status=404)): |
||
598 | self.assertEqual(self.conn.get_object_stat('a'), None) |
||
599 | |||
600 | def test_put_object(self): |
||
601 | with patch('geventhttpclient.HTTPClient.request', |
||
602 | lambda *args, **kwargs: Response()):
|
||
603 | self.assertEqual(self.conn.put_object('a', BytesIO(b'content')), |
||
604 | None)
|
||
605 | |||
606 | def test_put_object_fails(self): |
||
607 | with patch('geventhttpclient.HTTPClient.request', |
||
608 | lambda *args, **kwargs: Response(status=400)): |
||
609 | self.assertRaises(swift.SwiftException,
|
||
610 | lambda: self.conn.put_object( |
||
611 | 'a', BytesIO(b'content'))) |
||
612 | |||
613 | def test_get_object(self): |
||
614 | with patch('geventhttpclient.HTTPClient.request', |
||
615 | lambda *args, **kwargs: Response(content=b'content')): |
||
616 | self.assertEqual(self.conn.get_object('a').read(), b'content') |
||
617 | with patch('geventhttpclient.HTTPClient.request', |
||
618 | lambda *args, **kwargs: Response(content=b'content')): |
||
619 | self.assertEqual(self.conn.get_object('a', range='0-6'), b'content') |
||
620 | |||
621 | def test_get_object_fails(self): |
||
622 | with patch('geventhttpclient.HTTPClient.request', |
||
623 | lambda *args, **kwargs: Response(status=404)): |
||
624 | self.assertEqual(self.conn.get_object('a'), None) |
||
625 | |||
626 | def test_del_object(self): |
||
627 | with patch('geventhttpclient.HTTPClient.request', |
||
628 | lambda *args: Response()):
|
||
629 | self.assertEqual(self.conn.del_object('a'), None) |
||
630 | |||
631 | def test_del_root(self): |
||
632 | with patch('dulwich.contrib.swift.SwiftConnector.del_object', |
||
633 | lambda *args: None): |
||
634 | with patch('dulwich.contrib.swift.SwiftConnector.' |
||
635 | 'get_container_objects',
|
||
636 | lambda *args: ({'name': 'a'}, {'name': 'b'})): |
||
637 | with patch('geventhttpclient.HTTPClient.request', |
||
638 | lambda *args: Response()):
|
||
639 | self.assertEqual(self.conn.del_root(), None) |
||
640 | |||
641 | |||
642 | @skipIf(missing_libs, skipmsg)
|
||
643 | class SwiftObjectStoreTests(ObjectStoreTests, TestCase): |
||
644 | |||
645 | def setUp(self): |
||
646 | TestCase.setUp(self)
|
||
647 | conf = swift.load_conf(file=StringIO(config_file % |
||
648 | def_config_file)) |
||
649 | fsc = FakeSwiftConnector('fakerepo', conf=conf)
|
||
650 | self.store = swift.SwiftObjectStore(fsc) |