| 198 |
198 |
self.info('Container meta exists')
|
| 199 |
199 |
|
| 200 |
200 |
self.obj_metakey = 'metakey%s' % random.randint(1000, 9999)
|
| 201 |
|
obj = 'object%s' % random.randint(1000, 9999)
|
|
201 |
obj = 'object_with_meta'
|
| 202 |
202 |
pithos.create_object(obj)
|
| 203 |
203 |
pithos.set_object_meta(obj, {self.obj_metakey: 'our value'})
|
| 204 |
204 |
r = pithos.get_container_object_meta()
|
| ... | ... | |
| 268 |
268 |
except ClientError:
|
| 269 |
269 |
pass
|
| 270 |
270 |
|
| 271 |
|
# def test_050_stop_test(self):
|
| 272 |
|
# """STOP TESTING ALREADY"""
|
| 273 |
|
# self.assertTrue(False)
|
|
271 |
def test_030_container_put(self):
|
|
272 |
"""Test container PUT"""
|
|
273 |
pithos = self.clients.pithos
|
|
274 |
pithos.container = 'cont%s%s' % (
|
|
275 |
self.run_id or 0, random.randint(1000, 9999))
|
|
276 |
self.temp_containers.append(pithos.container)
|
|
277 |
|
|
278 |
r = pithos.create_container()
|
|
279 |
self.assertTrue(isinstance(r, dict))
|
|
280 |
|
|
281 |
r = pithos.get_container_limit(pithos.container)
|
|
282 |
cquota = r.values()[0]
|
|
283 |
newquota = 2 * int(cquota)
|
|
284 |
self.info('Limit is OK')
|
|
285 |
pithos.del_container()
|
|
286 |
|
|
287 |
r = pithos.create_container(sizelimit=newquota)
|
|
288 |
self.assertTrue(isinstance(r, dict))
|
|
289 |
|
|
290 |
r = pithos.get_container_limit(pithos.container)
|
|
291 |
xquota = int(r.values()[0])
|
|
292 |
self.assertEqual(newquota, xquota)
|
|
293 |
self.info('Can set container limit')
|
|
294 |
pithos.del_container()
|
|
295 |
|
|
296 |
r = pithos.create_container(versioning='auto')
|
|
297 |
self.assertTrue(isinstance(r, dict))
|
|
298 |
|
|
299 |
r = pithos.get_container_versioning(pithos.container)
|
|
300 |
nvers = r.values()[0]
|
|
301 |
self.assertEqual('auto', nvers)
|
|
302 |
self.info('Versioning=auto is OK')
|
|
303 |
pithos.del_container()
|
|
304 |
|
|
305 |
r = pithos.container_put(versioning='none')
|
|
306 |
self.assertEqual(r.status_code, 201)
|
|
307 |
|
|
308 |
r = pithos.get_container_versioning(pithos.container)
|
|
309 |
nvers = r.values()[0]
|
|
310 |
self.assertEqual('none', nvers)
|
|
311 |
self.info('Versioning=none is OK')
|
|
312 |
pithos.del_container()
|
|
313 |
|
|
314 |
r = pithos.create_container(metadata={'m1': 'v1', 'm2': 'v2'})
|
|
315 |
self.assertTrue(isinstance(r, dict))
|
|
316 |
|
|
317 |
r = pithos.get_container_meta(pithos.container)
|
|
318 |
self.assertTrue('x-container-meta-m1' in r)
|
|
319 |
self.assertEqual(r['x-container-meta-m1'], 'v1')
|
|
320 |
self.assertTrue('x-container-meta-m2' in r)
|
|
321 |
self.assertEqual(r['x-container-meta-m2'], 'v2')
|
|
322 |
|
|
323 |
r = pithos.container_put(metadata={'m1': '', 'm2': 'v2a'})
|
|
324 |
self.assertEqual(r.status_code, 202)
|
|
325 |
|
|
326 |
r = pithos.get_container_meta(pithos.container)
|
|
327 |
self.assertTrue('x-container-meta-m1' not in r)
|
|
328 |
self.assertTrue('x-container-meta-m2' in r)
|
|
329 |
self.assertEqual(r['x-container-meta-m2'], 'v2a')
|
|
330 |
self.info('Container meta is OK')
|
|
331 |
|
|
332 |
pithos.del_container_meta(pithos.container)
|
|
333 |
|
|
334 |
def test_035_container_post(self):
|
|
335 |
"""Test container POST"""
|
|
336 |
pithos = self.clients.pithos
|
|
337 |
|
|
338 |
r = pithos.container_post()
|
|
339 |
self.assertEqual(r.status_code, 202)
|
|
340 |
self.info('Status is OK')
|
|
341 |
|
|
342 |
pithos.set_container_meta({'m1': 'v1', 'm2': 'v2'})
|
|
343 |
r = pithos.get_container_meta(pithos.container)
|
|
344 |
self.assertTrue('x-container-meta-m1' in r)
|
|
345 |
self.assertEqual(r['x-container-meta-m1'], 'v1')
|
|
346 |
self.assertTrue('x-container-meta-m2' in r)
|
|
347 |
self.assertEqual(r['x-container-meta-m2'], 'v2')
|
|
348 |
self.info('Set metadata works')
|
|
349 |
|
|
350 |
r = pithos.del_container_meta('m1')
|
|
351 |
r = pithos.set_container_meta({'m2': 'v2a'})
|
|
352 |
r = pithos.get_container_meta(pithos.container)
|
|
353 |
self.assertTrue('x-container-meta-m1' not in r)
|
|
354 |
self.assertTrue('x-container-meta-m2' in r)
|
|
355 |
self.assertEqual(r['x-container-meta-m2'], 'v2a')
|
|
356 |
self.info('Delete metadata works')
|
|
357 |
|
|
358 |
r = pithos.get_container_limit(pithos.container)
|
|
359 |
cquota = r.values()[0]
|
|
360 |
newquota = 2 * int(cquota)
|
|
361 |
r = pithos.set_container_limit(newquota)
|
|
362 |
r = pithos.get_container_limit(pithos.container)
|
|
363 |
xquota = int(r.values()[0])
|
|
364 |
self.assertEqual(newquota, xquota)
|
|
365 |
self.info('Set quota works')
|
|
366 |
|
|
367 |
pithos.set_container_versioning('auto')
|
|
368 |
r = pithos.get_container_versioning(pithos.container)
|
|
369 |
nvers = r.values()[0]
|
|
370 |
self.assertEqual('auto', nvers)
|
|
371 |
pithos.set_container_versioning('none')
|
|
372 |
r = pithos.get_container_versioning(pithos.container)
|
|
373 |
nvers = r.values()[0]
|
|
374 |
self.assertEqual('none', nvers)
|
|
375 |
self.info('Set versioning works')
|
|
376 |
|
|
377 |
f = self._create_large_file(1024 * 1024 * 100)
|
|
378 |
self.info('Created file %s of 100 MB' % f.name)
|
|
379 |
|
|
380 |
pithos.create_directory('dir')
|
|
381 |
r = pithos.upload_object('/dir/sample.file', f)
|
|
382 |
for term in ('content-length', 'content-type', 'x-object-version'):
|
|
383 |
self.assertTrue(term in r)
|
|
384 |
r = pithos.get_object_info('/dir/sample.file')
|
|
385 |
self.assertTrue(int(r['content-length']) > 100000000)
|
|
386 |
self.info('Made remote directory /dir and object /dir/sample.file')
|
|
387 |
|
|
388 |
"""What is tranfer_encoding? What should I check about it? """
|
|
389 |
#TODO
|
|
390 |
|
|
391 |
obj = 'object_with_meta'
|
|
392 |
pithos.container = self.temp_containers[-2]
|
|
393 |
r = pithos.object_post(
|
|
394 |
obj, update='False', metadata={'newmeta': 'newval'})
|
|
395 |
|
|
396 |
r = pithos.get_object_info(obj)
|
|
397 |
self.assertTrue('x-object-meta-newmeta' in r)
|
|
398 |
self.assertFalse('x-object-meta-%s' % self.obj_metakey not in r)
|
|
399 |
self.info('Metadata with update=False works')
|
|
400 |
|
|
401 |
def test_050_stop_test(self):
|
|
402 |
"""STOP TESTING ALREADY"""
|
|
403 |
self.assertTrue(False)
|
| 274 |
404 |
|
| 275 |
405 |
def test_051_list_containers(self):
|
| 276 |
406 |
"""Test container list actually returns containers"""
|
| ... | ... | |
| 284 |
414 |
names = sorted(names)
|
| 285 |
415 |
self.assertEqual(sorted(list(set(names))), names)
|
| 286 |
416 |
|
| 287 |
|
def test_053_create_container(self):
|
| 288 |
|
"""Test creating a new container"""
|
| 289 |
|
names = [n['name'] for n in self.containers]
|
| 290 |
|
while True:
|
| 291 |
|
rand_num = random.randint(1000, 9999)
|
| 292 |
|
rand_name = "%s%s" % (self.run_id or 0, rand_num)
|
| 293 |
|
self.info("Trying container name %s", rand_name)
|
| 294 |
|
if rand_name not in names:
|
| 295 |
|
break
|
| 296 |
|
self.info("Container name %s already exists", rand_name)
|
| 297 |
|
# Create container
|
| 298 |
|
self._create_pithos_container(rand_name)
|
| 299 |
|
# Verify that container is created
|
| 300 |
|
containers = self._get_list_of_containers()
|
| 301 |
|
self.info("Verify that container %s is created", rand_name)
|
| 302 |
|
names = [n['name'] for n in containers]
|
| 303 |
|
self.assertIn(rand_name, names)
|
| 304 |
|
# Keep the name of the container so we can remove it
|
| 305 |
|
# at cleanup phase, if something goes wrong.
|
| 306 |
|
self.created_container = rand_name
|
| 307 |
|
|
| 308 |
417 |
def test_054_upload_file(self):
|
| 309 |
418 |
"""Test uploading a txt file to Pithos"""
|
| 310 |
419 |
# Create a tmp file
|