code.grnet.gr Git - kamaki/blob - kamaki/clients/tests.py

   1 # Copyright 2011 GRNET S.A. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or
   4 # without modification, are permitted provided that the following
   5 # conditions are met:
   6 #
   7 #   1. Redistributions of source code must retain the above
   8 #         copyright notice, this list of conditions and the following
   9 #         disclaimer.
  10 #
  11 #   2. Redistributions in binary form must reproduce the above
  12 #         copyright notice, this list of conditions and the following
  13 #         disclaimer in the documentation and/or other materials
  14 #         provided with the distribution.
  15 #
  16 # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  17 # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  20 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  23 # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  24 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  26 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 # POSSIBILITY OF SUCH DAMAGE.
  28 #
  29 # The views and conclusions contained in the software and
  30 # documentation are those of the authors and should not be
  31 # interpreted as representing official policies, either expressed
  32 # or implied, of GRNET S.A.
  33
  34 import gevent.monkey #Monkey-patch everything for gevent early on
  35 gevent.monkey.patch_all()
  36
  37 from argparse import ArgumentParser
  38 import unittest
  39 import time, datetime, os, sys
  40 from shutil import copyfile
  41
  42 from kamaki.clients import ClientError
  43 from kamaki.clients.pithos import PithosClient as pithos
  44 from kamaki.clients.cyclades import CycladesClient as cyclades
  45 from kamaki.clients.image import ImageClient as image
  46 from kamaki.clients.astakos import AstakosClient as astakos
  47
  48 TEST_ALL = False
  49
  50 class testAstakos(unittest.TestCase):
  51         def setUp(self):
  52                 url='https://accounts.okeanos.grnet.gr'
  53                 token = 'Kn+G9dfmlPLR2WFnhfBOow=='
  54                 self.client = astakos(url, token)
  55         def tearDown(self):
  56                 pass
  57         def test_authenticate(self):
  58                 r = self.client.authenticate()
  59                 for term in ('username',
  60                         'auth_token_expires',
  61                         'auth_token',
  62                         'auth_token_created',
  63                         'groups',
  64                         'uniq',
  65                         'has_credits',
  66                         'has_signed_terms'):
  67                         self.assertTrue(r.has_key(term))
  68
  69 class testImage(unittest.TestCase):
  70         def setUp(self):
  71                 url = 'https://cyclades.okeanos.grnet.gr/plankton'
  72                 token = 'Kn+G9dfmlPLR2WFnhfBOow=='
  73                 self.imgid = 'b2dffe52-64a4-48c3-8a4c-8214cc3165cf'
  74                 self.client = image(url, token)
  75
  76         def tearDown(self):
  77                 pass
  78
  79         def assert_dicts_are_deeply_equal(self, d1, d2):
  80                 for k,v in d1.items():
  81                         self.assertTrue(d2.has_key(k))
  82                         if isinstance(v, dict):
  83                                 self.assert_dicts_are_deeply_equal(v, d2[k])
  84                         else:
  85                                 self.assertEqual(unicode(v), unicode(d2[k]))
  86
  87         def test_list_public(self):
  88                 """Test list_public"""
  89                 r = self.client.list_public()
  90                 r0 = self.client.list_public(order='-')
  91                 self.assertTrue(len(r)>0)
  92                 for img in r:
  93                         for term in ('status',
  94                                 'name',
  95                                 'container_format',
  96                                 'disk_format',
  97                                 'id',
  98                                 'size'):
  99                                 self.assertTrue(img.has_key(term))
 100                 self.assertTrue(len(r), len(r0))
 101                 r0.reverse()
 102                 for i, img in enumerate(r):
 103                         self.assert_dicts_are_deeply_equal(img, r0[i])
 104                 r1 = self.client.list_public(detail=True)
 105                 for img in r1:
 106                         for term in ('status',
 107                                 'name',
 108                                 'checksum',
 109                                 'created_at',
 110                                 'disk_format',
 111                                 'updated_at',
 112                                 'id',
 113                                 'location',
 114                                 'container_format',
 115                                 'owner',
 116                                 'is_public',
 117                                 'deleted_at',
 118                                 'properties',
 119                                 'size'):
 120                                 self.assertTrue(img.has_key(term))
 121                                 for interm in ('kernel',
 122                                         'osfamily',
 123                                         'users',
 124                                         'gui',
 125                                         'sortorder',
 126                                         'os',
 127                                         'root_partition',
 128                                         'description'):
 129                                         self.assertTrue(img['properties'].has_key(interm))
 130                 size_max = 1000000000
 131                 r2 = self.client.list_public(filters=dict(size_max=size_max))
 132                 self.assertTrue(len(r2) <= len(r))
 133                 for img in r2:
 134                         self.assertTrue(int(img['size'])<=size_max)
 135
 136         def test_get_meta(self):
 137                 """Test get_meta"""
 138                 r= self.client.get_meta(self.imgid)
 139                 self.assertEqual(r['id'], self.imgid)
 140                 for term in ('status',
 141                         'name',
 142                         'checksum',
 143                         'updated-at',
 144                         'created-at',
 145                         'deleted-at',
 146                         'location',
 147                         'is-public',
 148                         'owner',
 149                         'disk-format',
 150                         'size',
 151                         'container-format'):
 152                         self.assertTrue(r.has_key(term))
 153                         for interm in ('kernel',
 154                                 'osfamily',
 155                                 'users',
 156                                 'partition-table',
 157                                 'gui', 'sortorder',
 158                                 'root-partition',
 159                                 'os',
 160                                 'description'):
 161                                 self.assertTrue(r['properties'].has_key(interm))
 162
 163 class testCyclades(unittest.TestCase):
 164         """Set up a Cyclades thorough test"""
 165         def setUp(self):
 166                 """okeanos"""
 167                 url='https://cyclades.okeanos.grnet.gr/api/v1.1'
 168                 token='MI6PT0yrXJ9Ji/x8l9Wmig=='
 169                 token='Kn+G9dfmlPLR2WFnhfBOow=='
 170                 #account='saxtouri@gmail.com'
 171                 account='saxtouri@grnet.gr'
 172                 self.img = 'b2dffe52-64a4-48c3-8a4c-8214cc3165cf'
 173                 self.img_details= {
 174                         u'status': u'ACTIVE',
 175                         u'updated': u'2012-10-16T09:04:17+00:00',
 176                         u'name': u'Debian Base',
 177                         u'created': u'2012-10-16T09:03:12+00:00',
 178                         u'progress': 100,
 179                         u'id': 'b2dffe52-64a4-48c3-8a4c-8214cc3165cf',
 180                         u'metadata': {
 181                                 u'values': {
 182                                         u'kernel': u'2.6.32',
 183                                         u'osfamily': u'linux',
 184                                         u'users': u'root',
 185                                         u'gui': u'No GUI',
 186                                         u'sortorder': u'1',
 187                                         u'os': u'debian',
 188                                         u'root_partition': u'1',
 189                                         u'description': u'Debian 6.0.6 (Squeeze) Base System',
 190                                         u'partition_table': u'msdos'}
 191                                 }
 192                         }
 193                 self.flavor_details =  {u'name': u'C1R1024D20',
 194                         u'ram': 1024,
 195                         u'id': 1,
 196                         u'SNF:disk_template': u'drbd',
 197                         u'disk': 20,
 198                         u'cpu': 1}
 199                 self.PROFILES=('ENABLED', 'DISABLED', 'PROTECTED')
 200
 201                 """okeanos.io"""
 202                 #url = 'https://cyclades.okeanos.io/api/v1.1'
 203                 #token='0TpoyAXqJSPxLdDuZHiLOA=='
 204                 #account='saxtouri@admin.grnet.gr'
 205                 #self.img = '43cc8497-61c3-4c46-ae8d-3e33861f8527'
 206                 #self.img_details= {
 207                 #       u'status': u'ACTIVE',
 208                 #       u'updated': u'2012-08-21T12:57:39+00:00',
 209                 #       u'name': u'Debian Base',
 210                 #       u'created': u'2012-08-21T12:56:53+00:00',
 211                 #       u'progress': 100,
 212                 #       u'id': u'43cc8497-61c3-4c46-ae8d-3e33861f8527',
 213                 #       u'metadata': {
 214                 #               u'values': {
 215                 #                       u'kernel': u'2.6.32',
 216                 #                       u'osfamily': u'linux',
 217                 #                       u'users': u'root',
 218                 #                       u'gui': u'No GUI',
 219                 #                       u'sortorder': u'1',
 220                 #                       u'os': u'debian',
 221                 #                       u'root_partition':
 222                 #                       u'1', u'description':
 223                 #                       u'Debian Squeeze Base System'}
 224                 #               }
 225                 #       }
 226                 #flavorid = 1
 227
 228                 self.servers = {}
 229                 self.now = time.mktime(time.gmtime())
 230                 self.servname1 = 'serv'+unicode(self.now)
 231                 self.servname2 = self.servname1+'_v2'
 232                 self.flavorid = 1
 233                 #servers have to be created at the begining...
 234                 self.networks={}
 235                 self.netname1 = 'net'+unicode(self.now)
 236                 self.netname2 = 'net'+unicode(self.now)+'_v2'
 237
 238                 self.client = cyclades(url, token)
 239                 pass
 240
 241         def tearDown(self):
 242                 """Destoy servers used in testing"""
 243                 print
 244                 for netid in self.networks.keys():
 245                         self._delete_network(netid)
 246                 if 0 >= len(self.servers):
 247                         return
 248                 there_are_servers_running = True
 249                 deleted_servers = {}
 250                 waitime = 0
 251                 print('-> Found %s servers to delete'%len(self.servers))
 252                 while there_are_servers_running:
 253                         there_are_servers_running = False
 254                         if waitime > 0:
 255                                 c = ['|','/','-','\\']
 256                                 suffix = ''
 257                                 sys.stdout.write('\t. . . wait %s seconds: '%waitime)
 258                                 for i in range(4*waitime):
 259                                         oldlen = len(suffix)
 260                                         suffix = '%ss %s'%(i/4, c[i%4])
 261                                         sys.stdout.write(oldlen*'\b'+suffix)
 262                                         sys.stdout.flush()
 263                                         time.sleep(0.25)
 264                                 oldlen = len(': '+suffix)
 265                                 print(oldlen*'\b'+oldlen*' ')
 266                                 sys.stdout.flush()
 267                         waitime += 3
 268                         dservers = self.client.list_servers(detail=True)
 269                         for server in dservers:
 270                                 if server['name'] in self.servers.keys():
 271                                         there_are_servers_running = True
 272                                         sys.stdout.write('\t%s status:%s '%(server['name'], server['status']))
 273                                         if server['status'] == 'BUILD':
 274                                                 print('\twait...')
 275                                         else:
 276                                                 print('\tDELETE %s'%server['name'])
 277                                                 self._delete_server(server['id'])
 278                                                 self.servers.pop(server['name'])
 279                                                 deleted_servers[server['name']] = 0
 280                                                 waitime =0
 281                                 elif server['name'] in deleted_servers.keys():
 282                                         there_are_servers_running = True
 283                                         sys.stdout.write('\t%s status:%s '%(server['name'], server['status']))
 284                                         retries = deleted_servers[server['name']]
 285                                         if retries > 10:
 286                                                 print('\tretry DELETE %s'%server['name'])
 287                                                 self._delete_server(server['id'])
 288                                                 retries = 0
 289                                                 waitime = 0
 290                                         else:
 291                                                 print('\tnot deleted yet ...')
 292                                         deleted_servers[server['name']] = retries + 1
 293
 294         def _create_server(self, servername, flavorid, imageid, personality=None):
 295                 server = self.client.create_server(servername, flavorid, imageid, personality)
 296                 self.servers[servername] = server
 297                 return server
 298
 299         def _delete_server(self, servid):
 300                 self.client.delete_server(servid)
 301
 302         def _create_network(self, netname, **kwargs):
 303                 net = self.client.create_network(netname, **kwargs)
 304                 self.networks[net['id']] = net
 305                 return net
 306
 307         def _delete_network(self, netid):
 308                 sys.stdout.write('\tDelete network %s '%netid)
 309                 self.client.disconnect_network_nics(netid)
 310                 wait = 3
 311                 while True:
 312                         try:
 313                                 self.client.delete_network(netid)
 314                                 print('\n\tSUCCESFULL COMMIT delete network %s'%netid)
 315                                 break
 316                         except ClientError as err:
 317                                 self.assertEqual(err.status, 421)
 318                                 r = self.client.get_network_details(netid)
 319                                 time.sleep(wait)
 320                                 wait += 3
 321                                 sys.stdout.write('.')
 322
 323         def if_not_all(foo):
 324                 global TEST_ALL
 325                 if TEST_ALL:
 326                         return None
 327                 return foo
 328
 329         def assert_dicts_are_deeply_equal(self, d1, d2):
 330                 for k,v in d1.items():
 331                         self.assertTrue(d2.has_key(k))
 332                         if isinstance(v, dict):
 333                                 self.assert_dicts_are_deeply_equal(v, d2[k])
 334                         else:
 335                                 self.assertEqual(unicode(v), unicode(d2[k]))
 336
 337         def test_000(self):
 338                 "Prepare a full Cyclades test scenario"
 339                 global TEST_ALL
 340                 TEST_ALL = True
 341
 342                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 343                 self.server2 = self._create_server(self.servname2, self.flavorid+2, self.img)
 344
 345                 print('testing')
 346                 sys.stdout.write(' test create server')
 347                 self._test_create_server()
 348                 print('...ok')
 349
 350                 sys.stdout.write(' test list servers')
 351                 self._test_list_servers()
 352                 print('...ok')
 353
 354                 print('- wait for test servers to build')
 355                 self._wait_for_status(self.server1['id'], 'BUILD')
 356                 self._wait_for_status(self.server2['id'], 'BUILD')
 357                 print('- ok')
 358
 359                 sys.stdout.write(' test get server details')
 360                 self._test_get_server_details()
 361                 print('...ok')
 362
 363                 sys.stdout.write(' test get image details')
 364                 self._test_get_image_details()
 365                 print('...ok')
 366
 367                 sys.stdout.write(' test update_server_name')
 368                 self._test_update_server_name()
 369                 print('...ok')
 370
 371
 372                 sys.stdout.write(' test reboot_server')
 373                 self._test_reboot_server()
 374                 print('...ok')
 375
 376                 print('- wait for test servers to boot')
 377                 self._wait_for_status(self.server1['id'], 'REBOOT')
 378                 self._wait_for_status(self.server2['id'], 'REBOOT')
 379                 print('- ok')
 380
 381                 sys.stdout.write(' test create_server_metadata')
 382                 self._test_create_server_metadata()
 383                 print('...ok')
 384
 385                 sys.stdout.write(' test get_server_metadata')
 386                 self._test_get_server_metadata()
 387                 print('...ok')
 388
 389                 sys.stdout.write(' test update_server_metadata')
 390                 self._test_update_server_metadata()
 391                 print('...ok')
 392
 393                 sys.stdout.write(' test delete_server_metadata')
 394                 self._test_delete_server_metadata()
 395                 print('...ok')
 396
 397                 sys.stdout.write(' test list_flavors')
 398                 self._test_list_flavors()
 399                 print('...ok')
 400
 401                 sys.stdout.write(' test get_flavor_details')
 402                 self._test_get_flavor_details()
 403                 print('...ok')
 404
 405                 sys.stdout.write(' test list_images')
 406                 self._test_list_images()
 407                 print('...ok')
 408
 409                 sys.stdout.write(' test get_image_details')
 410                 self._test_get_image_details()
 411                 print('...ok')
 412
 413                 sys.stdout.write(' test get_image_metadata')
 414                 self._test_get_image_metadata()
 415                 print('...ok')
 416
 417                 sys.stdout.write(' test shutdown_server')
 418                 self._test_shutdown_server()
 419                 print('...ok')
 420
 421                 sys.stdout.write(' test start_server')
 422                 self._test_start_server()
 423                 print('...ok')
 424
 425                 sys.stdout.write(' test get_server_console')
 426                 self._test_get_server_console()
 427                 print('...ok')
 428
 429                 sys.stdout.write(' test get_firewall_profile')
 430                 self._test_get_firewall_profile()
 431                 print('...ok')
 432
 433                 sys.stdout.write(' test set_firewall_profile')
 434                 self._test_set_firewall_profile()
 435                 print('...ok')
 436
 437                 sys.stdout.write(' test get_server_stats')
 438                 self._test_get_server_stats()
 439                 print('...ok')
 440
 441                 self.network1 = self._create_network(self.netname1)
 442
 443                 sys.stdout.write(' test create_network')
 444                 self._test_create_network()
 445                 print('...ok')
 446
 447                 print('- wait for netowork to be activated')
 448                 self._wait_for_network(self.network1['id'], 'ACTIVE')
 449                 print('- ok')
 450
 451                 sys.stdout.write(' test connect_server')
 452                 self._test_connect_server()
 453                 print('...ok')
 454
 455                 sys.stdout.write(' test disconnect_server')
 456                 self._test_disconnect_server()
 457                 print('...ok')
 458
 459                 self.network2 = self._create_network(self.netname2)
 460                 print('- wait for netowork to be activated')
 461                 self._wait_for_network(self.network2['id'], 'ACTIVE')
 462                 print('- ok')
 463
 464                 sys.stdout.write(' test list_server_nics')
 465                 self._test_list_server_nics()
 466                 print('...ok')
 467
 468                 sys.stdout.write(' test list_networks')
 469                 self._test_list_networks()
 470                 print('...ok')
 471
 472                 sys.stdout.write(' test get_network_details')
 473                 self._test_get_network_details()
 474                 print('...ok')
 475
 476                 sys.stdout.write(' test update_network_name')
 477                 self._test_update_network_name()
 478                 print('...ok')
 479
 480                 """Don't have auth for these:
 481                 sys.stdout.write(' test delete_image')
 482                 self._test_delete_image()
 483                 print('...ok')
 484                 sys.stdout.write(' test create_image_metadata')
 485                 self._test_create_image_metadata()
 486                 print('...ok')
 487                 sys.stdout.write(' test update_image_metadata')
 488                 self._test_update_image_metadata()
 489                 print('...ok')
 490                 sys.stdout.write(' test delete_image_metadata')
 491                 self._test_delete_image_metadata()
 492                 print('...ok')
 493                 """
 494
 495         def _wait_for_network(self, netid, status):
 496                 wait = 3
 497                 limit = 50
 498                 c=['|','/','-','\\']
 499                 sys.stdout.write('\t- make net %s %s  '%(netid, status))
 500                 while wait < limit:
 501                         r = self.client.get_network_details(netid)
 502                         if r['status'] == status:
 503                                 print('\tOK')
 504                                 return True
 505                         sys.stdout.write('\tit is now %s, wait %ss  '%(r['status'], wait))
 506                         for i in range(wait*4):
 507                                 sys.stdout.write('\b%s'%c[i%4])
 508                                 sys.stdout.flush()
 509                                 time.sleep(0.25)
 510                         print('\b ')
 511                         wait += 3
 512                 return False
 513
 514         def _wait_for_nic(self, netid, servid, in_creation=True):
 515                 self._wait_for_network(netid, 'ACTIVE')
 516                 c=['|','/','-','\\']
 517                 limit = 50
 518                 wait=3
 519                 largetry = 0
 520                 while wait < limit:
 521                         nics = self.client.list_server_nics(servid)
 522                         for net in nics:
 523                                 found_nic = net['network_id'] == netid
 524                                 if (in_creation and found_nic) or not (in_creation or found_nic):
 525                                         return True
 526                         dis = '' if in_creation else 'dis'
 527                         sys.stdout.write('\twait nic %s to %sconnect to %s: %ss  '%(netid, dis, servid, wait))
 528                         for i in range(wait*4):
 529                                 sys.stdout.write('\b%s'%c[i%4])
 530                                 sys.stdout.flush()
 531                                 time.sleep(0.25)
 532                         print('\b ')
 533                         wait += 3
 534                         if wait >= limit and largetry < 3:
 535                                 wait = 3
 536                                 largetry += 1
 537                 return False
 538
 539         def _has_status(self, servid, status):
 540                 r = self.client.get_server_details(servid)
 541                 return r['status'] == status
 542         def _wait_for_status(self, servid, status):
 543                 wait = 0
 544                 c=['|','/','-','\\']
 545                 while self._has_status(servid, status):
 546                         if wait:
 547                                 sys.stdout.write('\tServer %s in %s. Wait %ss  '%(servid, status, wait))
 548                                 for i in range(4*wait):
 549                                         sys.stdout.write('\b%s'%c[i%4])
 550                                         sys.stdout.flush()
 551                                         time.sleep(0.25)
 552                                 print('\b ')
 553                         wait = (wait + 3) if wait<60 else 0
 554
 555         @if_not_all
 556         def test_list_servers(self):
 557                 """Test list servers"""
 558                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 559                 self.server2 = self._create_server(self.servname2, self.flavorid+1, self.img)
 560                 self._test_list_servers()
 561
 562         def _test_list_servers(self):
 563                 servers = self.client.list_servers()
 564                 dservers = self.client.list_servers(detail=True)
 565
 566                 """detailed and simple are same size"""
 567                 self.assertEqual(len(dservers), len(servers))
 568                 for i in range(len(servers)):
 569                         for field in ['created', 'flavorRef', 'hostId', 'imageRef', 'progress',
 570                                 'status', 'updated']:
 571                                 self.assertFalse(servers[i].has_key(field))
 572                                 self.assertTrue(dservers[i].has_key(field))
 573
 574                 """detailed and simple contain same names"""
 575                 names = sorted(map(lambda x: x["name"], servers))
 576                 dnames = sorted(map(lambda x: x["name"], dservers))
 577                 self.assertEqual(names, dnames)
 578
 579         @if_not_all
 580         def test_create_server(self):
 581                 """Test create_server"""
 582                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 583                 self._wait_for_status(self.server1['id'], 'BUILD')
 584                 self._test_create_server()
 585
 586         def _test_create_server(self):
 587                 self.assertEqual(self.server1["name"], self.servname1)
 588                 self.assertEqual(self.server1["flavorRef"], self.flavorid)
 589                 self.assertEqual(self.server1["imageRef"], self.img)
 590                 self.assertEqual(self.server1["status"], "BUILD")
 591
 592         @if_not_all
 593         def test_get_server_details(self):
 594                 """Test get_server_details"""
 595                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 596                 self._wait_for_status(self.server1['id'], 'BUILD')
 597                 self._test_get_server_details()
 598
 599         def _test_get_server_details(self):
 600                 r = self.client.get_server_details(self.server1['id'])
 601                 self.assertEqual(r["name"], self.servname1)
 602                 self.assertEqual(r["flavorRef"], self.flavorid)
 603                 self.assertEqual(r["imageRef"], self.img)
 604                 self.assertEqual(r["status"], "ACTIVE")
 605
 606         @if_not_all
 607         def test_get_image_details(self):
 608                 """Test get_image_details"""
 609                 self._test_get_image_details()
 610
 611         def _test_get_image_details(self):
 612                 r = self.client.get_image_details(self.img)
 613                 d = self.img_details
 614                 self.assert_dicts_are_deeply_equal(r, d)
 615
 616         @if_not_all
 617         def test_update_server_name(self):
 618                 """Test update_server_name"""
 619                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 620                 self._test_update_server_name()
 621
 622         def _test_update_server_name(self):
 623                 new_name = self.servname1+'_new_name'
 624                 self.client.update_server_name(self.server1['id'], new_name)
 625                 r = self.client.get_server_details(self.server1['id'], success=(200, 400))
 626                 self.assertEqual(r['name'], new_name)
 627                 changed = self.servers.pop(self.servname1)
 628                 changed['name'] = new_name
 629                 self.servers[new_name] = changed
 630
 631         @if_not_all
 632         def test_reboot_server(self):
 633                 """Test reboot server"""
 634                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 635                 self._wait_for_status(self.server1['id'], 'BUILD')
 636                 self.server2 = self._create_server(self.servname2, self.flavorid+1, self.img)
 637                 self._wait_for_status(self.server2['id'], 'BUILD')
 638                 self._test_reboot_server()
 639                 self._wait_for_status(self.server1['id'], 'REBOOT')
 640                 self._wait_for_status(self.server2['id'], 'REBOOT')
 641
 642         def _test_reboot_server(self):
 643                 self.client.reboot_server(self.server1['id'])
 644                 self.assertTrue(self._has_status(self.server1['id'], 'REBOOT'))
 645                 self.client.reboot_server(self.server2['id'], hard=True)
 646                 self.assertTrue(self._has_status(self.server2['id'], 'REBOOT'))
 647
 648         @if_not_all
 649         def test_get_server_metadata(self):
 650                 """Test get server_metadata"""
 651                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 652                 self._test_get_server_metadata()
 653         def _test_get_server_metadata(self):
 654                 self.client.create_server_metadata(self.server1['id'], 'mymeta_0', 'val_0')
 655                 r = self.client.get_server_metadata(self.server1['id'], 'mymeta_0')
 656                 self.assertEqual(r['mymeta_0'], 'val_0')
 657
 658         @if_not_all
 659         def test_create_server_metadata(self):
 660                 """Test create_server_metadata"""
 661                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 662                 self._test_create_server_metadata()
 663
 664         def _test_create_server_metadata(self):
 665                 r1 = self.client.create_server_metadata(self.server1['id'], 'mymeta', 'mymeta val')
 666                 self.assertTrue(r1.has_key('mymeta'))
 667                 r2 = self.client.get_server_metadata(self.server1['id'], 'mymeta')
 668                 self.assert_dicts_are_deeply_equal(r1, r2)
 669
 670         @if_not_all
 671         def test_update_server_metadata(self):
 672                 """Test update_server_metadata"""
 673                 self.server1=self._create_server(self.servname1, self.flavorid, self.img)
 674                 self._test_update_server_metadata()
 675
 676         def _test_update_server_metadata(self):
 677                 r1 = self.client.create_server_metadata(self.server1['id'], 'mymeta3', 'val2')
 678                 self.assertTrue(r1.has_key('mymeta3'))
 679                 r2 = self.client.update_server_metadata(self.server1['id'], mymeta3='val3')
 680                 self.assertTrue(r2['mymeta3'], 'val3')
 681
 682         @if_not_all
 683         def test_delete_server_metadata(self):
 684                 """Test delete_server_metadata"""
 685                 self.server1=self._create_server(self.servname1, self.flavorid, self.img)
 686                 self._test_delete_server_metadata()
 687
 688         def _test_delete_server_metadata(self):
 689                 r1 = self.client.create_server_metadata(self.server1['id'], 'mymeta', 'val')
 690                 self.assertTrue(r1.has_key('mymeta'))
 691                 self.client.delete_server_metadata(self.server1['id'], 'mymeta')
 692                 try:
 693                         r2 = self.client.get_server_metadata(self.server1['id'], 'mymeta')
 694                         raise ClientError('Wrong Error', status=100)
 695                 except ClientError as err:
 696                         self.assertEqual(err.status, 404)
 697
 698         @if_not_all
 699         def test_list_flavors(self):
 700                 """Test flavors_get"""
 701                 self._test_list_flavors()
 702
 703         def _test_list_flavors(self):
 704                 r = self.client.list_flavors()
 705                 self.assertTrue(len(r) > 1)
 706                 r = self.client.list_flavors(detail=True)
 707                 self.assertTrue(r[0].has_key('SNF:disk_template'))
 708
 709         @if_not_all
 710         def test_get_flavor_details(self):
 711                 """Test test_get_flavor_details"""
 712                 self._test_get_flavor_details()
 713
 714         def _test_get_flavor_details(self):
 715                 r = self.client.get_flavor_details(self.flavorid)
 716                 self.assert_dicts_are_deeply_equal(self.flavor_details, r)
 717
 718         @if_not_all
 719         def test_list_images(self):
 720                 """Test list_images"""
 721                 self._test_list_images()
 722
 723         def _test_list_images(self):
 724                 r = self.client.list_images()
 725                 self.assertTrue(len(r) > 1)
 726                 r = self.client.list_images(detail=True)
 727                 for detailed_img in r:
 728                         if detailed_img['id'] == self.img:
 729                                 break
 730                 self.assert_dicts_are_deeply_equal(r[1], self.img_details)
 731
 732         @if_not_all
 733         def test_image_details(self):
 734                 """Test image_details"""
 735                 self._test_get_image_details
 736
 737         def _test_get_image_details(self):
 738                 r = self.client.get_image_details(self.img)
 739                 self.assert_dicts_are_deeply_equal(r, self.img_details)
 740
 741         @if_not_all
 742         def test_get_image_metadata(self):
 743                 """Test get_image_metadata"""
 744                 self._test_get_image_metadata()
 745
 746         def _test_get_image_metadata(self):
 747                 r = self.client.get_image_metadata(self.img)
 748                 self.assert_dicts_are_deeply_equal(self.img_details['metadata']['values'], r)
 749                 for key,val in self.img_details['metadata']['values'].items():
 750                         r = self.client.get_image_metadata(self.img, key)
 751                         self.assertEqual(r[key], val)
 752
 753         @if_not_all
 754         def test_start_server(self):
 755                 """Test start_server"""
 756                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 757                 self._wait_for_status(self.server1['id'], 'BUILD')
 758                 self.client.shutdown_server(self.server1['id'])
 759                 self._wait_for_status(self.server1['id'], 'ACTIVE')
 760                 self._test_start_server()
 761
 762         def _test_start_server(self):
 763                 self.client.start_server(self.server1['id'])
 764                 self._wait_for_status(self.server1['id'], 'STOPPED')
 765                 r = self.client.get_server_details(self.server1['id'])
 766                 self.assertEqual(r['status'], 'ACTIVE')
 767
 768         @if_not_all
 769         def test_shutdown_server(self):
 770                 """Test shutdown_server"""
 771                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 772                 self._wait_for_status(self.server1['id'], 'BUILD')
 773                 self._test_shutdown_server()
 774
 775         def _test_shutdown_server(self):
 776                 self.client.shutdown_server(self.server1['id'])
 777                 self._wait_for_status(self.server1['id'], 'ACTIVE')
 778                 r = self.client.get_server_details(self.server1['id'])
 779                 self.assertEqual(r['status'], 'STOPPED')
 780
 781         @if_not_all
 782         def test_get_server_console(self):
 783                 """Test get_server_console"""
 784                 self.server2 = self._create_server(self.servname2, self.flavorid+1, self.img)
 785                 self._test_get_server_console()
 786
 787         def _test_get_server_console(self):
 788                 self._wait_for_status(self.server2['id'], 'BUILD')
 789                 r = self.client.get_server_console(self.server2['id'])
 790                 self.assertTrue(r.has_key('host'))
 791                 self.assertTrue(r.has_key('password'))
 792                 self.assertTrue(r.has_key('port'))
 793                 self.assertTrue(r.has_key('type'))
 794
 795         @if_not_all
 796         def test_get_firewall_profile(self):
 797                 """Test get_firewall_profile"""
 798                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 799                 self._test_get_firewall_profile()
 800
 801         def _test_get_firewall_profile(self):
 802                 self._wait_for_status(self.server1['id'], 'BUILD')
 803                 fprofile = self.client.get_firewall_profile(self.server1['id'])
 804                 self.assertTrue(fprofile in self.PROFILES)
 805
 806         @if_not_all
 807         def test_set_firewall_profile(self):
 808                 """Test set_firewall_profile"""
 809                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 810                 self._test_set_firewall_profile()
 811
 812         def _test_set_firewall_profile(self):
 813
 814                 self._wait_for_status(self.server1['id'], 'BUILD')
 815                 PROFILES=['DISABLED', 'ENABLED', 'DISABLED', 'PROTECTED']
 816                 fprofile = self.client.get_firewall_profile(self.server1['id'])
 817                 print('')
 818                 for counter, fprofile in enumerate(PROFILES):
 819                         start=fprofile
 820                         npos = counter + 1
 821                         nprofile = PROFILES[npos] if npos<len(PROFILES) else PROFILES[0]
 822                         print('\tprofile swap %s: %s -> %s'%(npos, fprofile, nprofile))
 823                         self.client.set_firewall_profile(self.server1['id'], nprofile)
 824                         wait = 3
 825                         c=['|','/','-','\\']
 826                         while fprofile != nprofile:
 827                                 if wait%10 == 0:
 828                                         self.client.set_firewall_profile(self.server1['id'], nprofile)
 829                                 self.assertEqual(fprofile, start)
 830                                 sys.stdout.write('\t   profile is %s, wait %ss  '%(fprofile, wait))
 831                                 for i in range(4*wait):
 832                                         sys.stdout.write('\b%s'%c[i%4])
 833                                         sys.stdout.flush()
 834                                         time.sleep(0.25)
 835                                 wait += 3
 836                                 print('\b ')
 837                                 fprofile = self.client.get_firewall_profile(self.server1['id'])
 838
 839         @if_not_all
 840         def test_get_server_stats(self):
 841                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 842                 self._test_get_server_stats()
 843
 844         def _test_get_server_stats(self):
 845                 r = self.client.get_server_stats(self.server1['id'])
 846                 for term in ('cpuBar', 'cpuTimeSeries', 'netBar', 'netTimeSeries', 'refresh'):
 847                         self.assertTrue(r.has_key(term))
 848
 849         @if_not_all
 850         def test_list_networks(self):
 851                 """Test list_network"""
 852                 self.network1 = self._create_network(self.netname1)
 853                 self._wait_for_network(self.network1['id'], 'ACTIVE')
 854                 self._test_list_networks()
 855
 856         def _test_list_networks(self):
 857                 r = self.client.list_networks()
 858                 self.assertTrue(len(r)>1)
 859                 ids = [net['id'] for net in r]
 860                 names = [net['name'] for net in r]
 861                 self.assertTrue('1' in ids)
 862                 self.assertTrue('public' in names)
 863                 self.assertTrue(self.network1['id'] in ids)
 864                 self.assertTrue(self.network1['name'] in names)
 865
 866                 r = self.client.list_networks(detail=True)
 867                 ids = [net['id'] for net in r]
 868                 names = [net['name'] for net in r]
 869                 for net in r:
 870                         self.assertTrue(net['id'] in ids)
 871                         self.assertTrue(net['name'] in names)
 872                         for term in ('status', 'updated', 'created'):
 873                                 self.assertTrue(term in net.keys())
 874
 875         @if_not_all
 876         def test_create_network(self):
 877                 """Test create_network"""
 878                 self.network1 = self._create_network(self.netname1)
 879                 self._test_create_network()
 880
 881         def _test_create_network(self):
 882                 nets = self.client.list_networks(self.network1['id'])
 883                 chosen = [net for net in nets if net['id'] == self.network1['id']][0]
 884                 chosen.pop('updated')
 885                 net1 = dict(self.network1)
 886                 net1.pop('updated')
 887                 self.assert_dicts_are_deeply_equal(chosen, net1)
 888
 889         @if_not_all
 890         def test_connect_server(self):
 891                 """Test connect_server"""
 892                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 893                 self.network1 = self._create_network(self.netname1)
 894                 self._wait_for_status(self.server1['id'], 'BUILD')
 895                 self._wait_for_network(self.network1['id'], 'ACTIVE')
 896                 self._test_connect_server()
 897
 898         def _test_connect_server(self):
 899                 self.client.connect_server(self.server1['id'], self.network1['id'])
 900                 self.assertTrue(self._wait_for_nic(self.network1['id'], self.server1['id']))
 901
 902         @if_not_all
 903         def test_disconnect_server(self):
 904                 """Test disconnect_server"""
 905                 self.test_connect_server()
 906                 self._test_disconnect_server()
 907
 908         def _test_disconnect_server(self):
 909                 self.client.disconnect_server(self.server1['id'], self.network1['id'])
 910                 self.assertTrue(self._wait_for_nic(self.network1['id'], self.server1['id'],
 911                         in_creation=False))
 912
 913
 914         @if_not_all
 915         def test_list_server_nics(self):
 916                 """Test list_server_nics"""
 917                 self.server1 = self._create_server(self.servname1, self.flavorid, self.img)
 918                 self.network2 = self._create_network(self.netname2)
 919                 self._wait_for_status(self.server1['id'], 'BUILD')
 920                 self._wait_for_network(self.network2['id'], 'ACTIVE')
 921                 self._test_list_server_nics()
 922
 923         def _test_list_server_nics(self):
 924                 r = self.client.list_server_nics(self.server1['id'])
 925                 len0 = len(r)
 926                 self.assertTrue(len0>0)
 927                 self.assertTrue('1' in [net['network_id'] for net in r])
 928
 929                 self.client.connect_server(self.server1['id'], self.network2['id'])
 930                 self.assertTrue(self._wait_for_nic(self.network2['id'], self.server1['id']))
 931                 r = self.client.list_server_nics(self.server1['id'])
 932                 self.assertTrue(len(r)>len0)
 933
 934         @if_not_all
 935         def test_get_network_details(self):
 936                 """Test get_network_details"""
 937                 self.network1 = self._create_network(self.netname1)
 938                 self._test_get_network_details()
 939
 940         def _test_get_network_details(self):
 941                 r = self.client.get_network_details(self.network1['id'])
 942                 net1 = dict(self.network1)
 943                 net1.pop('status')
 944                 net1.pop('updated', None)
 945                 net1.pop('attachments')
 946                 r.pop('status')
 947                 r.pop('updated', None)
 948                 r.pop('attachments')
 949                 self.assert_dicts_are_deeply_equal(net1, r)
 950
 951         @if_not_all
 952         def test_update_network_name(self):
 953                 self.network2 = self._create_network(self.netname2)
 954                 self._test_update_network_name()
 955
 956         def _test_update_network_name(self):
 957                 updated_name = self.netname2+'_upd'
 958                 self.client.update_network_name(self.network2['id'], updated_name)
 959                 wait = 3
 960                 c=['|','/','-','\\']
 961                 r = self.client.get_network_details(self.network2['id'])
 962                 while wait < 50:
 963                         if r['name'] == updated_name:
 964                                 break
 965                         sys.stdout.write('\twait for %s renaming (%s->%s) %ss  '%(self.network2['id'],
 966                                 self.network2['name'], updated_name, wait))
 967                         for i in range(4*wait):
 968                                 sys.stdout.write('\b%s'%c[i%4])
 969                                 sys.stdout.flush()
 970                                 time.sleep(0.25)
 971                         print('')
 972                         wait += 3
 973                         r = self.client.get_network_details(self.network2['id'])
 974                 self.assertEqual(r['name'], updated_name)
 975
 976         """ Don't have auth to test this
 977         @if_not_all
 978         def test_delete_image(self):
 979                 ""Test delete_image""
 980                 self._test_delete_image()
 981         def _test_delete_image(self):
 982                 images = self.client.list_images()
 983                 self.client.delete_image(images[2]['id'])
 984                 try:
 985                         r = self.client.get_image_details(images[2]['id'], success=(400))
 986                 except ClientError as err:
 987                         self.assertEqual(err.status, 404)
 988
 989         @if_not_all
 990         def test_create_image_metadata(self):
 991                 ""Test create_image_metadata""
 992                 self._test_create_image_metadata()
 993         def _test_create_image_metadata(self):
 994                 r = self.client.create_image_metadata(self.img, 'mykey', 'myval')
 995                 self.assertEqual(r['mykey'], 'myval')
 996
 997         @if_not_all
 998         def test_update_image_metadata(self):
 999                 ""Test update_image_metadata""
1000                 self._test_update_image_metadata()
1001         def _test_update_image_metadata(self):
1002                 r = self.client.create_image_metadata(self.img, 'mykey0', 'myval')
1003                 r = self.client.update_image_metadata(self.img, 'mykey0', 'myval0')
1004                 self.assertEqual(r['mykey0'], 'myval0')
1005
1006         @if_not_all
1007         def test_delete_image_metadata(self):
1008                 ""Test delete_image_metadata""
1009                 self._test_delete_image_metadata()
1010         def _test_delete_image_metadata(self):
1011                 self.client.create_image_metadata(self.img, 'mykey1', 'myval1')
1012                 self.client.delete_image_metadata(self.img, 'mykey1')
1013                 r = self.client.get_image_metadata(self.img)
1014                 self.assertNotEqual(r.has_key('mykey1'))
1015         """
1016
1017 class testPithos(unittest.TestCase):
1018         """Set up a Pithos+ thorough test"""
1019         def setUp(self):
1020                 """
1021                 url = 'http://127.0.0.1:8000/v1'
1022                 token = 'C/yBXmz3XjTFBnujc2biAg=='
1023                 token = 'ac0yH8cQMEZu3M3Mp1MWGA=='
1024                 account = 'admin@adminland.com'
1025                 """
1026
1027                 url='https://pithos.okeanos.grnet.gr/v1'
1028
1029                 token='Kn+G9dfmlPLR2WFnhfBOow=='
1030                 account='saxtouri@grnet.gr'
1031
1032                 """
1033                 url='https://pithos.okeanos.io/v1'
1034                 token='0TpoyAXqJSPxLdDuZHiLOA=='
1035                 account='saxtouri@admin.grnet.gr'
1036                 """
1037
1038                 """
1039                 def add_handler(name, level, prefix=''):
1040                         h = logging.StreamHandler()
1041                         fmt = logging.Formatter(prefix + '%(message)s')
1042                         h.setFormatter(fmt)
1043                         logger = logging.getLogger(name)
1044                         logger.addHandler(h)
1045                         logger.setLevel(level)
1046                 import logging
1047                 sendlog = logging.getLogger('clients.send')
1048                 recvlog = logging.getLogger('clients.recv')
1049                 add_handler('requests', logging.INFO, prefix='* ')
1050                 add_handler('clients.send', logging.INFO, prefix='> ')
1051                 add_handler('clients.recv', logging.INFO, prefix='< ')
1052                 """
1053
1054                 self.fname = None
1055                 container=None
1056                 self.client = pithos(url, token, account, container)
1057                 self.now = time.mktime(time.gmtime())
1058                 self.c1 = 'c1_'+unicode(self.now)
1059                 self.c2 = 'c2_'+unicode(self.now)
1060                 self.c3 = 'c3_'+unicode(self.now)
1061
1062
1063                 self.client.create_container(self.c1)
1064                 self.client.create_container(self.c2)
1065                 self.client.create_container(self.c3)
1066                 self.makeNewObject(self.c1, 'test')
1067                 self.makeNewObject(self.c2, 'test')
1068                 self.now_unformated = datetime.datetime.utcnow()
1069                 self.makeNewObject(self.c1, 'test1')
1070                 self.makeNewObject(self.c2, 'test1')
1071                 """Prepare an object to be shared - also its container"""
1072                 self.client.container = self.c1
1073                 r = self.client.object_post('test', update=True, permitions={'read':'someUser'})
1074
1075                 self.makeNewObject(self.c1, 'another.test')
1076
1077         def makeNewObject(self, container, obj):
1078                 self.client.container = container
1079                 r = self.client.object_put(obj, content_type='application/octet-stream',
1080                         data= 'file '+obj+' that lives in '+container,
1081                         metadata={'incontainer':container})
1082
1083         def forceDeleteContainer(self, container):
1084                 self.client.container = container
1085                 try:
1086                         r = self.client.list_objects()
1087                 except ClientError:
1088                         return
1089                 for obj in r:
1090                         name = obj['name']
1091                         self.client.del_object(name)
1092                 r = self.client.container_delete()
1093                 self.container = ''
1094
1095         def tearDown(self):
1096                 """Destroy test cases"""
1097                 if self.fname is not None:
1098                         try:
1099                                 os.remove(self.fname)
1100                         except OSError:
1101                                 pass
1102                         self.fname = None
1103                 self.forceDeleteContainer(self.c1)
1104                 self.forceDeleteContainer(self.c2)
1105                 try:
1106                         self.forceDeleteContainer(self.c3)
1107                 except ClientError:
1108                         pass
1109                 self.client.container=''
1110
1111         def test_000(self):
1112                 """Perform a full Pithos+ kamaki support test"""
1113
1114         def test_account_head(self):
1115                 """Test account_HEAD"""
1116                 r = self.client.account_head()
1117                 self.assertEqual(r.status_code, 204)
1118
1119                 r = self.client.account_head(until='1000000000')
1120                 self.assertEqual(r.status_code, 204)
1121
1122                 r = self.client.get_account_info(until='1000000000')
1123                 datestring = unicode(r['x-account-until-timestamp'])
1124                 self.assertEqual(u'Sun, 09 Sep 2001 01:46:40 GMT', datestring)
1125
1126                 r = self.client.get_account_quota()
1127                 self.assertTrue(r.has_key('x-account-policy-quota'))
1128
1129                 r = self.client.get_account_versioning()
1130                 self.assertTrue(r.has_key('x-account-policy-versioning'))
1131
1132                 """Check if(un)modified_since"""
1133                 for format in self.client.DATE_FORMATS:
1134                         now_formated = self.now_unformated.strftime(format)
1135                         r1 = self.client.account_head(if_modified_since=now_formated, success=(204, 304, 412))
1136                         sc1 = r1.status_code
1137                         r1.release()
1138                         r2 = self.client.account_head(if_unmodified_since=now_formated, success=(204, 304, 412))
1139                         sc2 = r2.status_code
1140                         r2.release()
1141                         self.assertNotEqual(sc1, sc2)
1142
1143         def test_account_get(self):
1144                 """Test account_GET"""
1145                 #r = self.client.account_get()
1146                 #self.assertEqual(r.status_code, 200)
1147                 r = self.client.list_containers()
1148                 fullLen = len(r)
1149                 self.assertTrue(fullLen > 2)
1150
1151                 r = self.client.account_get(limit=1)
1152                 self.assertEqual(len(r.json), 1)
1153
1154
1155                 r = self.client.account_get(marker='c2_')
1156                 temp_c0 = r.json[0]['name']
1157                 temp_c2 = r.json[2]['name']
1158
1159                 r = self.client.account_get(limit=2, marker='c2_')
1160                 conames = [container['name'] for container in r.json \
1161                         if container['name'].lower().startswith('c2_')]
1162                 self.assertTrue(temp_c0 in conames)
1163                 self.assertFalse(temp_c2 in conames)
1164
1165
1166                 r = self.client.account_get(show_only_shared=True)
1167                 self.assertTrue(self.c1 in [c['name'] for c in r.json])
1168
1169                 r = self.client.account_get(until=1342609206)
1170                 self.assertTrue(len(r.json) <= fullLen)
1171
1172                 """Check if(un)modified_since"""
1173                 for format in self.client.DATE_FORMATS:
1174                         now_formated = self.now_unformated.strftime(format)
1175                         r1 = self.client.account_get(if_modified_since=now_formated, success=(200, 304, 412))
1176                         sc1 = r1.status_code
1177                         r1.release()
1178                         r2 = self.client.account_get(if_unmodified_since=now_formated, success=(200, 304, 412))
1179                         sc2 = r2.status_code
1180                         r2.release()
1181                         self.assertNotEqual(sc1, sc2)
1182
1183                 """Check sharing_accounts"""
1184                 r = self.client.get_sharing_accounts()
1185                 self.assertTrue(len(r)>0)
1186
1187         def test_account_post(self):
1188                 """Test account_POST"""
1189                 r = self.client.account_post()
1190                 self.assertEqual(r.status_code, 202)
1191                 grpName = 'grp'+unicode(self.now)
1192
1193
1194                 """Method set/del_account_meta and set_account_groupcall use account_post internally
1195                 """
1196                 self.client.set_account_group(grpName, ['u1', 'u2'])
1197                 r = self.client.get_account_group()
1198                 self.assertEqual(r['x-account-group-'+grpName], 'u1,u2')
1199                 self.client.del_account_group(grpName)
1200                 r = self.client.get_account_group()
1201                 self.assertTrue(not r.has_key('x-account-group-'+grpName))
1202
1203                 mprefix = 'meta'+unicode(self.now)
1204                 self.client.set_account_meta({mprefix+'1':'v1', mprefix+'2':'v2'})
1205                 r = self.client.get_account_meta()
1206                 self.assertEqual(r['x-account-meta-'+mprefix+'1'], 'v1')
1207                 self.assertEqual(r['x-account-meta-'+mprefix+'2'], 'v2')
1208
1209                 self.client.del_account_meta(mprefix+'1')
1210                 r = self.client.get_account_meta()
1211                 self.assertTrue(not r.has_key('x-account-meta-'+mprefix+'1'))
1212
1213                 self.client.del_account_meta(mprefix+'2')
1214                 r = self.client.get_account_meta()
1215                 self.assertTrue(not r.has_key('x-account-meta-'+mprefix+'2'))
1216
1217                 """Missing testing for quota, versioning, because normally
1218                 you don't have permitions to modify those at account level
1219                 """
1220
1221                 newquota=1000000
1222                 self.client.set_account_quota(newquota)
1223                 #r = self.client.get_account_info()
1224                 #print(unicode(r))
1225                 #r = self.client.get_account_quota()
1226                 #self.assertEqual(r['x-account-policy-quota'], newquota)
1227                 self.client.set_account_versioning('auto')
1228
1229         def test_container_head(self):
1230                 """Test container_HEAD"""
1231                 self.client.container = self.c1
1232
1233                 r = self.client.container_head()
1234                 self.assertEqual(r.status_code, 204)
1235
1236                 """Check until"""
1237                 r = self.client.container_head(until=1000000, success=(204, 404))
1238                 self.assertEqual(r.status_code, 404)
1239
1240                 """Check and if(un)modified_since"""
1241                 for format in self.client.DATE_FORMATS:
1242                         now_formated = self.now_unformated.strftime(format)
1243                         r1 = self.client.container_head(if_modified_since=now_formated, success=(204, 304, 412))
1244                         sc1=r1.status_code
1245                         r1.release()
1246                         r2 = self.client.container_head(if_unmodified_since=now_formated, success=(204, 304, 412))
1247                         sc2=r2.status_code
1248                         r2.release()
1249                         self.assertNotEqual(sc1, sc2)
1250
1251                 """Check container object meta"""
1252                 r = self.client.get_container_object_meta()
1253                 self.assertEqual(r['x-container-object-meta'], 'Incontainer')
1254
1255         def test_container_get(self):
1256                 """Test container_GET"""
1257                 self.client.container = self.c1
1258
1259                 r = self.client.container_get()
1260                 self.assertEqual(r.status_code, 200)
1261                 fullLen = len(r.json)
1262
1263
1264                 r = self.client.container_get(prefix='test')
1265                 lalobjects = [obj for obj in r.json if obj['name'].startswith('test')]
1266                 self.assertTrue(len(r.json) > 1)
1267                 self.assertEqual(len(r.json), len(lalobjects))
1268
1269
1270                 r = self.client.container_get(limit=1)
1271                 self.assertEqual(len(r.json), 1)
1272
1273
1274                 r = self.client.container_get(marker='another')
1275                 self.assertTrue(len(r.json) > 1)
1276                 neobjects = [obj for obj in r.json if obj['name'] > 'another']
1277                 self.assertEqual(len(r.json), len(neobjects))
1278
1279
1280                 r = self.client.container_get(prefix='another.test', delimiter='.')
1281                 self.assertTrue(fullLen > len(r.json))
1282
1283
1284                 r = self.client.container_get(path='/')
1285                 self.assertEqual(fullLen, len(r.json))
1286
1287
1288                 r = self.client.container_get(format='xml')
1289                 self.assertEqual(r.text.split()[4], 'name="'+self.c1+'">')
1290
1291
1292                 r = self.client.container_get(meta=['incontainer'])
1293                 self.assertTrue(len(r.json) > 0)
1294
1295
1296                 r = self.client.container_get(show_only_shared=True)
1297                 self.assertTrue(len(r.json) < fullLen)
1298
1299
1300                 try:
1301                         r = self.client.container_get(until=1000000000)
1302                         datestring = unicode(r.headers['x-account-until-timestamp'])
1303                         self.assertEqual(u'Sun, 09 Sep 2001 01:46:40 GMT', datestring)
1304
1305                 except ClientError:
1306
1307                         pass
1308
1309                 """Check and if un/modified_since"""
1310                 for format in self.client.DATE_FORMATS:
1311                         now_formated = self.now_unformated.strftime(format)
1312                         r1 = self.client.container_get(if_modified_since=now_formated, success=(200, 304, 412))
1313                         sc1 = r1.status_code
1314                         r1.release()
1315                         r2 = self.client.container_get(if_unmodified_since=now_formated, success=(200, 304, 412))
1316                         sc2 = r2.status_code
1317                         r2.release()
1318                         self.assertNotEqual(sc1, sc2)
1319
1320         def test_container_put(self):
1321                 """Test container_PUT"""
1322                 self.client.container = self.c2
1323
1324                 r = self.client.container_put()
1325                 self.assertEqual(r.status_code, 202)
1326
1327
1328                 r = self.client.get_container_quota(self.client.container)
1329                 cquota = r.values()[0]
1330                 newquota = 2*int(cquota)
1331
1332                 r = self.client.container_put(quota=newquota)
1333                 self.assertEqual(r.status_code, 202)
1334
1335                 r = self.client.get_container_quota(self.client.container)
1336                 xquota = int(r.values()[0])
1337                 self.assertEqual(newquota, xquota)
1338
1339                 r = self.client.container_put(versioning='auto')
1340                 self.assertEqual(r.status_code, 202)
1341
1342                 r = self.client.get_container_versioning(self.client.container)
1343                 nvers = r.values()[0]
1344                 self.assertEqual('auto', nvers)
1345
1346                 r = self.client.container_put(versioning='none')
1347                 self.assertEqual(r.status_code, 202)
1348
1349                 r = self.client.get_container_versioning(self.client.container)
1350                 nvers = r.values()[0]
1351                 self.assertEqual('none', nvers)
1352
1353                 r = self.client.container_put(metadata={'m1':'v1', 'm2':'v2'})
1354                 self.assertEqual(r.status_code, 202)
1355
1356                 r = self.client.get_container_meta(self.client.container)
1357                 self.assertTrue(r.has_key('x-container-meta-m1'))
1358                 self.assertEqual(r['x-container-meta-m1'], 'v1')
1359                 self.assertTrue(r.has_key('x-container-meta-m2'))
1360                 self.assertEqual(r['x-container-meta-m2'], 'v2')
1361
1362                 r = self.client.container_put(metadata={'m1':'', 'm2':'v2a'})
1363                 self.assertEqual(r.status_code, 202)
1364
1365                 r = self.client.get_container_meta(self.client.container)
1366                 self.assertTrue(not r.has_key('x-container-meta-m1'))
1367                 self.assertTrue(r.has_key('x-container-meta-m2'))
1368                 self.assertEqual(r['x-container-meta-m2'], 'v2a')
1369
1370                 self.client.del_container_meta(self.client.container)
1371
1372         def test_container_post(self):
1373                 """Test container_POST"""
1374                 self.client.container = self.c2
1375
1376                 """Simple post"""
1377                 r = self.client.container_post()
1378                 self.assertEqual(r.status_code, 202)
1379
1380
1381                 """post meta"""
1382                 self.client.set_container_meta({'m1':'v1', 'm2':'v2'})
1383                 r = self.client.get_container_meta(self.client.container)
1384                 self.assertTrue(r.has_key('x-container-meta-m1'))
1385                 self.assertEqual(r['x-container-meta-m1'], 'v1')
1386                 self.assertTrue(r.has_key('x-container-meta-m2'))
1387                 self.assertEqual(r['x-container-meta-m2'], 'v2')
1388
1389                 """post/2del meta"""
1390                 r = self.client.del_container_meta('m1')
1391                 r = self.client.set_container_meta({'m2':'v2a'})
1392                 r = self.client.get_container_meta(self.client.container)
1393                 self.assertTrue(not r.has_key('x-container-meta-m1'))
1394                 self.assertTrue(r.has_key('x-container-meta-m2'))
1395                 self.assertEqual(r['x-container-meta-m2'], 'v2a')
1396
1397                 """check quota"""
1398                 r = self.client.get_container_quota(self.client.container)
1399                 cquota = r.values()[0]
1400                 newquota = 2*int(cquota)
1401                 r = self.client.set_container_quota(newquota)
1402                 r = self.client.get_container_quota(self.client.container)
1403                 xquota = int(r.values()[0])
1404                 self.assertEqual(newquota, xquota)
1405                 r = self.client.set_container_quota(cquota)
1406                 r = self.client.get_container_quota(self.client.container)
1407                 xquota = r.values()[0]
1408                 self.assertEqual(cquota, xquota)
1409
1410                 """Check versioning"""
1411                 self.client.set_container_versioning('auto')
1412                 r = self.client.get_container_versioning(self.client.container)
1413                 nvers = r.values()[0]
1414                 self.assertEqual('auto', nvers)
1415                 self.client.set_container_versioning('none')
1416                 r = self.client.get_container_versioning(self.client.container)
1417                 nvers = r.values()[0]
1418                 self.assertEqual('none', nvers)
1419
1420                 """put_block uses content_type and content_length to
1421                 post blocks of data 2 container. All that in upload_object"""
1422                 """Change a file at fs"""
1423                 self.create_large_file(1024*1024*100, 'l100M.'+unicode(self.now))
1424                 """Upload it at a directory in container"""
1425                 self.client.create_directory('dir')
1426                 newf = open(self.fname, 'r')
1427                 self.client.upload_object('/dir/sample.file', newf)
1428                 newf.close()
1429                 """Check if file has been uploaded"""
1430                 r = self.client.get_object_info('/dir/sample.file')
1431                 self.assertTrue(int(r['content-length']) > 100000000)
1432
1433                 """WTF is tranfer_encoding? What should I check about th** s**t? """
1434                 #TODO
1435
1436                 """Check update=False"""
1437                 r = self.client.object_post('test', update=False, metadata={'newmeta':'newval'})
1438
1439                 r = self.client.get_object_info('test')
1440                 self.assertTrue(r.has_key('x-object-meta-newmeta'))
1441                 self.assertFalse(r.has_key('x-object-meta-incontainer'))
1442
1443                 r = self.client.del_container_meta('m2')
1444
1445         def test_container_delete(self):
1446                 """Test container_DELETE"""
1447
1448                 """Fail to delete a non-empty container"""
1449                 self.client.container = self.c2
1450                 r = self.client.container_delete(success=409)
1451                 self.assertEqual(r.status_code, 409)
1452
1453
1454                 """Fail to delete c3 (empty) container"""
1455                 self.client.container = self.c3
1456                 r = self.client.container_delete(until='1000000000')
1457                 self.assertEqual(r.status_code, 204)
1458
1459
1460                 """Delete c3 (empty) container"""
1461                 r = self.client.container_delete()
1462                 self.assertEqual(r.status_code, 204)
1463
1464                 """Purge container(empty a container), check versionlist"""
1465                 self.client.container = self.c1
1466                 r = self.client.object_head('test', success=(200, 404))
1467                 self.assertEqual(r.status_code, 200)
1468                 self.client.del_container(delimiter='/')
1469                 r = self.client.object_head('test', success=(200, 404))
1470                 self.assertEqual(r.status_code, 404)
1471                 r = self.client.get_object_versionlist('test')
1472                 self.assertTrue(len(r) > 0)
1473                 self.assertTrue(len(r[0])>1)
1474                 self.client.purge_container()
1475                 self.assertRaises(ClientError, self.client.get_object_versionlist, 'test')
1476
1477         def test_object_head(self):
1478                 """Test object_HEAD"""
1479                 self.client.container = self.c2
1480                 obj = 'test'
1481
1482                 r = self.client.object_head(obj)
1483                 self.assertEqual(r.status_code, 200)
1484                 etag = r.headers['etag']
1485
1486
1487                 r = self.client.object_head(obj, version=40)
1488                 self.assertEqual(r.headers['x-object-version'], '40')
1489
1490
1491                 r = self.client.object_head(obj, if_etag_match=etag)
1492                 self.assertEqual(r.status_code, 200)
1493
1494                 r = self.client.object_head(obj, if_etag_not_match=etag, success=(200, 412, 304))
1495                 self.assertNotEqual(r.status_code, 200)
1496
1497
1498                 r = self.client.object_head(obj, version=40, if_etag_match=etag, success=412)
1499                 self.assertEqual(r.status_code, 412)
1500
1501
1502                 """Check and if(un)modified_since"""
1503                 for format in self.client.DATE_FORMATS:
1504                         now_formated = self.now_unformated.strftime(format)
1505                         r1 = self.client.object_head(obj, if_modified_since=now_formated,
1506                                 success=(200, 304, 412))
1507                         sc1 = r1.status_code
1508                         r1.release()
1509                         r2 = self.client.object_head(obj, if_unmodified_since=now_formated,
1510                                 success=(200, 304, 412))
1511                         sc2 = r2.status_code
1512                         r2.release()
1513                         self.assertNotEqual(sc1, sc2)
1514
1515         def test_object_get(self):
1516                 """Test object_GET"""
1517                 self.client.container = self.c1
1518                 obj = 'test'
1519
1520                 r = self.client.object_get(obj)
1521                 self.assertEqual(r.status_code, 200)
1522
1523                 osize = int(r.headers['content-length'])
1524                 etag = r.headers['etag']
1525
1526
1527                 r = self.client.object_get(obj, hashmap=True)
1528                 self.assertTrue(r.json.has_key('hashes') \
1529                         and r.json.has_key('block_hash') \
1530                         and r.json.has_key('block_size') \
1531                         and r.json.has_key('bytes'))
1532
1533
1534                 r = self.client.object_get(obj, format='xml', hashmap=True)
1535                 self.assertEqual(len(r.text.split('hash>')), 3)
1536
1537
1538                 rangestr = 'bytes=%s-%s'%(osize/3, osize/2)
1539                 r = self.client.object_get(obj, data_range=rangestr, success=(200, 206))
1540                 partsize = int(r.headers['content-length'])
1541                 self.assertTrue(0 < partsize and partsize <= 1+osize/3)
1542
1543
1544                 rangestr = 'bytes=%s-%s'%(osize/3, osize/2)
1545                 r = self.client.object_get(obj, data_range=rangestr, if_range=True, success=(200, 206))
1546                 partsize = int(r.headers['content-length'])
1547                 self.assertTrue(0 < partsize and partsize <= 1+osize/3)
1548
1549
1550                 r = self.client.object_get(obj, if_etag_match=etag)
1551                 self.assertEqual(r.status_code, 200)
1552
1553
1554                 r = self.client.object_get(obj, if_etag_not_match=etag+'LALALA')
1555                 self.assertEqual(r.status_code, 200)
1556
1557
1558                 """Check and if(un)modified_since"""
1559                 for format in self.client.DATE_FORMATS:
1560                         now_formated = self.now_unformated.strftime(format)
1561                         r1 = self.client.object_get(obj, if_modified_since=now_formated,
1562                                 success=(200, 304, 412))
1563                         sc1 = r1.status_code
1564                         r1.release()
1565                         r2 = self.client.object_get(obj, if_unmodified_since=now_formated, success=(200, 304, 412))
1566                         sc2 = r2.status_code
1567                         r2.release()
1568                         self.assertNotEqual(sc1, sc2)
1569
1570         def test_object_put(self):
1571                 """Test object_PUT"""
1572
1573                 self.client.container = self.c2
1574                 obj='another.test'
1575
1576                 """create the object"""
1577                 r = self.client.object_put(obj, data='a', content_type='application/octer-stream',
1578                         permitions={'read':['accX:groupA', 'u1', 'u2'], 'write':['u2', 'u3']},
1579                         metadata={'key1':'val1', 'key2':'val2'}, content_encoding='UTF-8',
1580                         content_disposition='attachment; filename="fname.ext"')
1581                 self.assertEqual(r.status_code, 201)
1582                 etag = r.headers['etag']
1583
1584                 """Check content-disposition"""
1585                 r = self.client.get_object_info(obj)
1586                 self.assertTrue(r.has_key('content-disposition'))
1587
1588                 """Check permitions"""
1589                 r = self.client.get_object_sharing(obj)
1590                 self.assertTrue('accx:groupa' in r['read'])
1591                 self.assertTrue('u1' in r['read'])
1592                 self.assertTrue('u2' in r['write'])
1593                 self.assertTrue('u3' in r['write'])
1594
1595                 """Check metadata"""
1596                 r = self.client.get_object_meta(obj)
1597                 self.assertEqual(r['x-object-meta-key1'], 'val1')
1598                 self.assertEqual(r['x-object-meta-key2'], 'val2')
1599
1600                 """Check public and if_etag_match"""
1601                 r = self.client.object_put(obj, if_etag_match=etag, data='b',
1602                         content_type='application/octet-stream', public=True)
1603
1604                 r = self.client.object_get(obj)
1605                 self.assertTrue(r.headers.has_key('x-object-public'))
1606                 vers2 = int(r.headers['x-object-version'])
1607                 etag = r.headers['etag']
1608                 self.assertEqual(r.text, 'b')
1609
1610                 """Check if_etag_not_match"""
1611                 r = self.client.object_put(obj, if_etag_not_match=etag, data='c',
1612                         content_type='application/octet-stream', success=(201, 412))
1613                 self.assertEqual(r.status_code, 412)
1614
1615
1616                 """Check content_type and content_length"""
1617                 tmpdir = 'dir'+unicode(self.now)
1618                 r = self.client.object_put(tmpdir, content_type='application/directory',
1619                         content_length=0)
1620
1621                 r = self.client.get_object_info(tmpdir)
1622                 self.assertEqual(r['content-type'], 'application/directory')
1623
1624                 """Check copy_from, content_encoding"""
1625                 r = self.client.object_put('%s/%s'%(tmpdir, obj), format=None,
1626                         copy_from='/%s/%s'%(self.client.container, obj),
1627                         content_encoding='application/octet-stream',
1628                         source_account=self.client.account,
1629                         content_length=0, success=201)
1630                 self.assertEqual(r.status_code, 201)
1631
1632                 """Test copy_object for cross-conctainer copy"""
1633                 self.client.copy_object(src_container=self.c2, src_object='%s/%s'%(tmpdir, obj),
1634                         dst_container=self.c1, dst_object=obj)
1635                 self.client.container = self.c1
1636                 r1 = self.client.get_object_info(obj)
1637                 self.client.container = self.c2
1638                 r2 = self.client.get_object_info('%s/%s'%(tmpdir, obj))
1639                 self.assertEqual(r1['x-object-hash'],r2['x-object-hash'])
1640
1641                 """Check cross-container copy_from, content_encoding"""
1642                 self.client.container = self.c1
1643                 fromstr = '/'+self.c2+'/'+tmpdir+'/'+obj
1644                 r = self.client.object_put(obj, format=None, copy_from=fromstr,
1645                         content_encoding='application/octet-stream',
1646                         source_account=self.client.account,
1647                         content_length=0, success=201)
1648
1649                 self.assertEqual(r.status_code, 201)
1650                 r = self.client.get_object_info(obj)
1651                 self.assertEqual(r['etag'], etag)
1652
1653                 """Check source_account"""
1654                 self.client.container = self.c2
1655                 fromstr = '/'+self.c1+'/'+obj
1656                 r = self.client.object_put(obj+'v2', format=None, move_from=fromstr,
1657                         content_encoding='application/octet-stream',
1658                         source_account='nonExistendAddress@NeverLand.com',
1659                         content_length=0, success=(201, 403))
1660                 self.assertEqual(r.status_code, 403)
1661
1662                 """Check cross-container move_from"""
1663                 self.client.container = self.c1
1664                 r1 = self.client.get_object_info(obj)
1665                 self.client.container = self.c2
1666                 self.client.move_object(src_container=self.c1, src_object=obj, dst_container=self.c2,
1667                 dst_object=obj+'v0')
1668                 r0 = self.client.get_object_info(obj+'v0')
1669                 self.assertEqual(r1['x-object-hash'], r0['x-object-hash'])
1670
1671                 """Check move_from"""
1672                 r = self.client.object_put(obj+'v1', format=None,
1673                         move_from='/'+self.c2+'/'+obj,
1674                         source_version = vers2,
1675                         content_encoding='application/octet-stream',
1676                         content_length=0, success=201)
1677
1678                 """Check manifest"""
1679                 mobj = 'manifest.test'
1680                 txt = ''
1681                 for i in range(10):
1682                         txt += '%s'%i
1683                         r = self.client.object_put('%s/%s'%(mobj, i), data='%s'%i, content_length=1, success=201,
1684                                 content_type='application/octet-stream', content_encoding='application/octet-stream')
1685
1686                 r = self.client.object_put(mobj, content_length=0, content_type='application/octet-stream',
1687                         manifest='%s/%s'%(self.client.container, mobj))
1688
1689                 r = self.client.object_get(mobj)
1690                 self.assertEqual(r.text, txt)
1691
1692                 """Upload a local file with one request"""
1693                 self.create_large_file(1024*10, 'l10K.'+unicode(self.now))
1694                 newf = open(self.fname, 'r')
1695                 self.client.upload_object('sample.file', newf)
1696                 newf.close()
1697                 """Check if file has been uploaded"""
1698                 r = self.client.get_object_info('sample.file')
1699                 self.assertEqual(int(r['content-length']), 10260)
1700
1701                 """Some problems with transfer-encoding?"""
1702
1703         def test_object_copy(self):
1704                 """Test object_COPY"""
1705                 self.client.container=self.c2
1706                 obj = 'test2'
1707
1708                 data= '{"key1":"val1", "key2":"val2"}'
1709                 r = self.client.object_put(obj+'orig', content_type='application/octet-stream',
1710                         data= data, metadata={'mkey1':'mval1', 'mkey2':'mval2'},
1711                         permitions={
1712                                 'read':['accX:groupA', 'u1', 'u2'],
1713                                 'write':['u2', 'u3']},
1714                         content_disposition='attachment; filename="fname.ext"')
1715
1716                 r = self.client.object_copy(obj+'orig',
1717                         destination = '/'+self.client.container+'/'+obj,
1718                         ignore_content_type=False, content_type='application/json',
1719                         metadata={'mkey2':'mval2a', 'mkey3':'mval3'},
1720                         permitions={'write':['u5', 'accX:groupB']})
1721                 self.assertEqual(r.status_code, 201)
1722
1723                 """Check content-disposition"""
1724                 r = self.client.get_object_info(obj)
1725                 self.assertTrue(r.has_key('content-disposition'))
1726
1727                 """Check Metadata"""
1728                 r = self.client.get_object_meta(obj)
1729                 self.assertEqual(r['x-object-meta-mkey1'], 'mval1')
1730                 self.assertEqual(r['x-object-meta-mkey2'], 'mval2a')
1731                 self.assertEqual(r['x-object-meta-mkey3'], 'mval3')
1732
1733                 """Check permitions"""
1734                 r = self.client.get_object_sharing(obj)
1735                 self.assertFalse(r.has_key('read') or 'u2' in r['write'])
1736                 self.assertTrue('accx:groupb' in r['write'])
1737
1738                 """Check destination account"""
1739                 r = self.client.object_copy(obj, destination='/%s/%s'%(self.c1,obj), content_encoding='utf8',
1740                         content_type='application/json', destination_account='nonExistendAddress@NeverLand.com',
1741                         success=(201, 403))
1742                 self.assertEqual(r.status_code, 403)
1743
1744
1745                 """Check destination being another container
1746                 and also content_type and content encoding"""
1747                 r = self.client.object_copy(obj, destination='/%s/%s'%(self.c1,obj),
1748                         content_encoding='utf8', content_type='application/json')
1749                 self.assertEqual(r.status_code, 201)
1750                 self.assertEqual(r.headers['content-type'], 'application/json; charset=UTF-8')
1751
1752
1753                 """Check ignore_content_type and content_type"""
1754                 r = self.client.object_get(obj)
1755                 etag = r.headers['etag']
1756                 ctype = r.headers['content-type']
1757                 self.assertEqual(ctype, 'application/json')
1758
1759                 r = self.client.object_copy(obj+'orig',
1760                         destination = '/'+self.client.container+'/'+obj+'0',
1761                         ignore_content_type=True, content_type='application/json')
1762                 self.assertEqual(r.status_code, 201)
1763                 self.assertNotEqual(r.headers['content-type'], 'application/json')
1764
1765
1766                 """Check if_etag_(not_)match"""
1767                 r = self.client.object_copy(obj,
1768                         destination='/'+self.client.container+'/'+obj+'1', if_etag_match=etag)
1769                 self.assertEqual(r.status_code, 201)
1770
1771                 r = self.client.object_copy(obj,
1772                         destination='/'+self.client.container+'/'+obj+'2', if_etag_not_match='lalala')
1773                 self.assertEqual(r.status_code, 201)
1774                 vers2 = r.headers['x-object-version']
1775
1776
1777                 """Check source_version, public and format """
1778                 r = self.client.object_copy(obj+'2', destination='/'+self.client.container+'/'+obj+'3', source_version=vers2, format='xml', public=True)
1779                 self.assertEqual(r.status_code, 201)
1780                 self.assertTrue(r.headers['content-type'].index('xml') > 0)
1781
1782                 r = self.client.get_object_info(obj+'3')
1783                 self.assertTrue(r.has_key('x-object-public'))
1784
1785         def test_object_move(self):
1786                 """Test object_MOVE"""
1787                 self.client.container= self.c2
1788                 obj = 'test2'
1789
1790                 data= '{"key1":"val1", "key2":"val2"}'
1791                 r = self.client.object_put(obj+'orig', content_type='application/octet-stream',
1792                         data= data, metadata={'mkey1':'mval1', 'mkey2':'mval2'},
1793                         permitions={'read':['accX:groupA', 'u1', 'u2'], 'write':['u2', 'u3']})
1794
1795                 r = self.client.object_move(obj+'orig', destination = '/'+self.client.container+'/'+obj,
1796                         ignore_content_type=False, content_type='application/json',
1797                         metadata={'mkey2':'mval2a', 'mkey3':'mval3'},
1798                         permitions={'write':['u5', 'accX:groupB']})
1799                 self.assertEqual(r.status_code, 201)
1800
1801
1802                 """Check Metadata"""
1803                 r = self.client.get_object_meta(obj)
1804                 self.assertEqual(r['x-object-meta-mkey1'], 'mval1')
1805                 self.assertEqual(r['x-object-meta-mkey2'], 'mval2a')
1806                 self.assertEqual(r['x-object-meta-mkey3'], 'mval3')
1807
1808                 """Check permitions"""
1809                 r = self.client.get_object_sharing(obj)
1810                 self.assertFalse(r.has_key('read'))
1811                 self.assertTrue('u5' in r['write'])
1812                 self.assertTrue('accx:groupb' in r['write'])
1813
1814                 """Check destination account"""
1815                 r = self.client.object_move(obj, destination='/%s/%s'%(self.c1,obj), content_encoding='utf8',
1816                         content_type='application/json', destination_account='nonExistendAddress@NeverLand.com',
1817                         success=(201, 403))
1818                 self.assertEqual(r.status_code, 403)
1819
1820
1821                 """Check destination being another container and also
1822                 content_type, content_disposition and content encoding"""
1823                 r = self.client.object_move(obj, destination='/%s/%s'%(self.c1,obj),
1824                         content_encoding='utf8', content_type='application/json',
1825                         content_disposition='attachment; filename="fname.ext"')
1826                 self.assertEqual(r.status_code, 201)
1827                 self.assertEqual(r.headers['content-type'], 'application/json; charset=UTF-8')
1828                 self.client.container=self.c1
1829                 r = self.client.get_object_info(obj)
1830                 self.assertTrue(r.has_key('content-disposition') and 'fname.ext' in r['content-disposition'])
1831                 etag = r['etag']
1832                 ctype = r['content-type']
1833                 self.assertEqual(ctype, 'application/json')
1834
1835                 """Check ignore_content_type and content_type"""
1836                 r = self.client.object_move(obj, destination = '/%s/%s'%(self.c2,obj),
1837                         ignore_content_type=True, content_type='application/json')
1838                 self.assertEqual(r.status_code, 201)
1839                 self.assertNotEqual(r.headers['content-type'], 'application/json')
1840
1841
1842                 """Check if_etag_(not_)match"""
1843                 self.client.container=self.c2
1844                 r = self.client.object_move(obj, destination='/'+self.client.container+'/'+obj+'0',
1845                         if_etag_match=etag)
1846                 self.assertEqual(r.status_code, 201)
1847
1848                 r = self.client.object_move(obj+'0', destination='/'+self.client.container+'/'+obj+'1',
1849                         if_etag_not_match='lalala')
1850                 self.assertEqual(r.status_code, 201)
1851
1852
1853                 """Check public and format """
1854                 r = self.client.object_move(obj+'1', destination='/'+self.client.container+'/'+obj+'2',
1855                         format='xml', public=True)
1856                 self.assertEqual(r.status_code, 201)
1857                 self.assertTrue(r.headers['content-type'].index('xml') > 0)
1858
1859                 r = self.client.get_object_info(obj+'2')
1860                 self.assertTrue(r.has_key('x-object-public'))
1861
1862         def test_object_post(self):
1863                 """Test object_POST"""
1864                 self.client.container=self.c2
1865                 obj = 'test2'
1866                 """create a filesystem file"""
1867                 self.fname = obj
1868                 newf = open(self.fname, 'w')
1869                 newf.writelines(['ello!\n','This is a test line\n','inside a test file\n'])
1870                 newf.close()
1871                 """create a file on container"""
1872                 r = self.client.object_put(obj, content_type='application/octet-stream',
1873                         data= 'H', metadata={'mkey1':'mval1', 'mkey2':'mval2'},
1874                         permitions={'read':['accX:groupA', 'u1', 'u2'], 'write':['u2', 'u3']})
1875
1876
1877                 """Append tests update, content_range, content_type, content_length"""
1878                 newf = open(obj, 'r')
1879                 self.client.append_object(obj, newf)
1880                 r = self.client.object_get(obj)
1881                 self.assertTrue(r.text.startswith('Hello!'))
1882
1883
1884                 """Overwrite tests update, content_type, content_length, content_range"""
1885                 newf.seek(0)
1886                 r = self.client.overwrite_object(obj, 0, 10, newf)
1887                 r = self.client.object_get(obj)
1888                 self.assertTrue(r.text.startswith('ello!'))
1889                 newf.close()
1890
1891
1892                 """Truncate tests update, content_range, content_type,
1893                 object_bytes and source_object"""
1894                 r = self.client.truncate_object(obj, 5)
1895                 r = self.client.object_get(obj)
1896                 self.assertEqual(r.text, 'ello!')
1897
1898
1899                 """Check metadata"""
1900                 self.client.set_object_meta(obj, {'mkey2':'mval2a', 'mkey3':'mval3'})
1901                 r = self.client.get_object_meta(obj)
1902                 self.assertEqual(r['x-object-meta-mkey1'], 'mval1')
1903                 self.assertEqual(r['x-object-meta-mkey2'], 'mval2a')
1904                 self.assertEqual(r['x-object-meta-mkey3'], 'mval3')
1905                 self.client.del_object_meta('mkey1', obj)
1906                 r = self.client.get_object_meta(obj)
1907                 self.assertFalse(r.has_key('x-object-meta-mkey1'))
1908
1909                 """Check permitions"""
1910                 self.client.set_object_sharing(obj,
1911                         read_permition=['u4', 'u5'], write_permition=['u4'])
1912                 r = self.client.get_object_sharing(obj)
1913                 self.assertTrue(r.has_key('read'))
1914                 self.assertTrue('u5' in r['read'])
1915                 self.assertTrue(r.has_key('write'))
1916                 self.assertTrue('u4' in r['write'])
1917                 self.client.del_object_sharing(obj)
1918                 r = self.client.get_object_sharing(obj)
1919                 self.assertTrue(len(r) == 0)
1920
1921                 """Check publish"""
1922                 self.client.publish_object(obj)
1923                 r = self.client.get_object_info(obj)
1924                 self.assertTrue(r.has_key('x-object-public'))
1925                 self.client.unpublish_object(obj)
1926                 r = self.client.get_object_info(obj)
1927                 self.assertFalse(r.has_key('x-object-public'))
1928
1929                 """Check if_etag_(not)match"""
1930                 etag = r['etag']
1931                 #r = self.client.object_post(obj, update=True, public=True,
1932                 #       if_etag_not_match=etag, success=(412,202,204))
1933                 #self.assertEqual(r.status_code, 412)
1934
1935                 r = self.client.object_post(obj, update=True, public=True,
1936                         if_etag_match=etag, content_encoding='application/json')
1937
1938                 r = self.client.get_object_info(obj)
1939                 helloVersion = r['x-object-version']
1940                 self.assertTrue(r.has_key('x-object-public'))
1941                 self.assertEqual(r['content-encoding'], 'application/json')
1942
1943                 """Check source_version and source_account and content_disposition"""
1944                 r = self.client.object_post(obj, update=True, content_type='application/octet-srteam',
1945                         content_length=5, content_range='bytes 1-5/*', source_object='/%s/%s'%(self.c2,obj),
1946                         source_account='thisAccountWillNeverExist@adminland.com',
1947                         source_version=helloVersion, data='12345', success=(403, 202, 204))
1948                 self.assertEqual(r.status_code, 403)
1949
1950                 r = self.client.object_post(obj, update=True, content_type='application/octet-srteam',
1951                         content_length=5, content_range='bytes 1-5/*', source_object='/%s/%s'%(self.c2,obj),
1952                         source_account=self.client.account, source_version=helloVersion, data='12345',
1953                         content_disposition='attachment; filename="fname.ext"')
1954
1955                 r = self.client.object_get(obj)
1956                 self.assertEqual(r.text, 'eello!')
1957                 self.assertTrue(r.headers.has_key('content-disposition')
1958                         and 'fname.ext' in r.headers['content-disposition'])
1959
1960
1961                 """Check manifest"""
1962                 mobj = 'manifest.test'
1963                 txt = ''
1964                 for i in range(10):
1965                         txt += '%s'%i
1966                         r = self.client.object_put('%s/%s'%(mobj, i), data='%s'%i, content_length=1, success=201,
1967                                 content_encoding='application/octet-stream', content_type='application/octet-stream')
1968
1969                 #r = self.client.object_put(mobj, content_length=0, content_type='application/octet-stream')
1970                 self.client.create_object_by_manifestation(mobj, content_type='application/octet-stream')
1971
1972                 r = self.client.object_post(mobj, manifest='%s/%s'%(self.client.container, mobj))
1973
1974                 r = self.client.object_get(mobj)
1975                 self.assertEqual(r.text, txt)
1976
1977
1978                 """We need to check transfer_encoding """
1979
1980         def test_object_delete(self):
1981                 """Test object_DELETE"""
1982                 self.client.container=self.c2
1983                 obj = 'test2'
1984                 """create a file on container"""
1985                 r = self.client.object_put(obj, content_type='application/octet-stream',
1986                         data= 'H', metadata={'mkey1':'mval1', 'mkey2':'mval2'},
1987                         permitions={'read':['accX:groupA', 'u1', 'u2'], 'write':['u2', 'u3']})
1988
1989
1990                 """Check with false until"""
1991                 r = self.client.object_delete(obj, until=1000000)
1992
1993                 r = self.client.object_get(obj, success=(200, 404))
1994                 self.assertEqual(r.status_code, 200)
1995
1996
1997                 """Check normal case"""
1998                 r = self.client.object_delete(obj)
1999                 self.assertEqual(r.status_code, 204)
2000
2001                 r = self.client.object_get(obj, success=(200, 404))
2002                 self.assertEqual(r.status_code, 404)
2003
2004
2005         def create_large_file(self, size, name):
2006                 """Create a large file at fs"""
2007                 self.fname = name
2008                 import random
2009                 random.seed(self.now)
2010                 f = open(self.fname, 'w')
2011                 sys.stdout.write(' create random file %s of size %s'%(name, size)+' 0%')
2012                 for hobyte_id in range(size/8):
2013                         sss = 'hobt%s'%random.randint(1000, 9999)
2014                         f.write(sss)
2015                         if 0 == (hobyte_id*800)%size:
2016                                 f.write('\n')
2017                                 sys.stdout.write('\b\b')
2018                                 prs = (hobyte_id*800)//size
2019                                 if prs > 10:
2020                                         sys.stdout.write('\b')
2021                                 sys.stdout.write('%s'%prs+'%')
2022                                 sys.stdout.flush()
2023                 print('\b\b\b100%')
2024                 f.close()
2025                 """"""
2026
2027 def init_parser():
2028         parser = ArgumentParser(add_help=False)
2029         parser.add_argument('-h', '--help', dest='help', action='store_true', default=False,
2030                 help="Show this help message and exit")
2031         return parser
2032
2033 if __name__ == '__main__':
2034         parser = init_parser()
2035         args, argv = parser.parse_known_args()
2036
2037         if len(argv) > 2 or getattr(args,'help') or len(argv) < 1:
2038                 raise Exception('\tusage: tests.py <group> [command]')
2039         suiteFew = unittest.TestSuite()
2040
2041         if len(argv) == 0 or argv[0] == 'pithos':
2042                 if len(argv) == 1:
2043                         suiteFew.addTest(unittest.makeSuite(testPithos))
2044                 else:
2045                         suiteFew.addTest(testPithos('test_'+argv[1]))
2046         if len(argv) == 0 or argv[0] == 'cyclades':
2047                 if len(argv) == 1:
2048                         #suiteFew.addTest(unittest.makeSuite(testCyclades))
2049                         suiteFew.addTest(testCyclades('test_000'))
2050                 else:
2051                         suiteFew.addTest(testCyclades('test_'+argv[1]))
2052         if len(argv) == 0 or argv[0] == 'image':
2053                 if len(argv) == 1:
2054                         suiteFew.addTest(unittest.makeSuite(testImage))
2055                 else:
2056                         suiteFew.addTest(testImage('test_'+argv[1]))
2057         if len(argv) == 0 or argv[0] == 'astakos':
2058                 if len(argv) == 1:
2059                         suiteFew.addTest(unittest.makeSuite(testAstakos))
2060                 else:
2061                         suiteFew.addTest(testAstakos('test_'+argv[1]))
2062
2063         unittest.TextTestRunner(verbosity = 2).run(suiteFew)