Revision d1f78278

b/kamaki/cli/commands/errors.py
227 227 
            try:
228 228 
                return foo(self, *args, **kwargs)
229 229 
            except ClientError as ce:
230 
                if network_id or ce.status == 421:
230 
                if network_id and ce.status == 400:
231 
                    raiseCLIError(ce,
232 
                        'Network with id %s does not exist' % network_id,
233 
                        details=self.about_network_id)
234 
                elif network_id or ce.status == 421:
231 235 
                    raiseCLIError(ce,
232 236 
                        'Network with id %s is in use' % network_id,
233 237 
                        details=[
b/kamaki/cli/commands/test_cli.py
45 45 
class _test_init(_command_init):
46 46 

  		





  47
  47
  
    
    def main(self, client, method=None):


  		





  48
  
  
    
        tests.cnf = self.config


  		





  49
  48
  
    
        if method:


  		





  50
  
  
    
            tests.main([client, method])


  		





  
  49
  
    
            tests.main([client, method], config=self.config)


  		





  51
  50
  
    
        else:


  		





  52
  
  
    
            tests.main([client])


  		





  
  51
  
    
            tests.main([client], config=self.config)


  		





  53
  52
  
    

  		





  54
  53
  
    

  		





  55
  54
  
    
@command(test_cmds)


  		












  

    
      b/kamaki/clients/tests/__init__.py
    
  






  45
  45
  
    
        return foo(self, value)


  		





  46
  46
  
    
    return wrap


  		





  47
  47
  
    

  		





  48
  
  
    

  		





  49
  48
  
    
class Generic(TestCase):


  		





  50
  49
  
    

  		





  51
  50
  
    
    _waits = []


  		





  ......




  53
  52
  
    
    _grp = None


  		





  54
  53
  
    
    _fetched = {}


  		





  55
  54
  
    

  		





  56
  
  
    
    def __init__(self, specific=None, config_file=None, group=None):


  		





  
  55
  
    
    def __init__(self, specific=None, config=None, group=None):


  		





  57
  56
  
    
        super(Generic, self).__init__(specific)


  		





  58
  
  
    
        self._cnf = Config(config_file)


  		





  
  57
  
    
        self._cnf = config or Config()


  		





  59
  58
  
    
        self._grp = group


  		





  60
  59
  
    
        self._waits.append(0.71828)


  		





  61
  60
  
    
        for i in range(10):


  		





  ......




  111
  110
  
    
            return


  		





  112
  111
  
    
        (action_bar, action_cb) = self._safe_progress_bar(msg)


  		





  113
  112
  
    
        action_gen = action_cb(len(items))


  		





  
  113
  
    
        try:


  		





  
  114
  
    
            action_gen.next()


  		





  
  115
  
    
        except Exception:


  		





  
  116
  
    
            pass


  		





  114
  117
  
    
        for item in items:


  		





  115
  118
  
    
            action(item)


  		





  116
  119
  
    
            action_gen.next()


  		





  ......




  154
  157
  
    

  		





  155
  158
  
    

  		





  156
  159
  
    
def main(argv):


  		





  
  160
  
    
    _main(argv, config=None)


  		





  
  161
  
    

  		





  157
  162
  
    

  		





  
  163
  
    
def _main(argv, config=None):


  		





  158
  164
  
    
    suiteFew = TestSuite()


  		





  159
  165
  
    
    """


  		





  160
  166
  
    
    if len(argv) == 0 or argv[0] == 'pithos':


  		





  ......




  166
  172
  
    
    if len(argv) == 0 or argv[0] == 'cyclades':


  		





  167
  173
  
    
        from kamaki.clients.tests.cyclades import Cyclades


  		





  168
  174
  
    
        test_method = 'test_%s' % (argv[1] if len(argv) > 1 else '000')


  		





  169
  
  
    
        suiteFew.addTest(Cyclades(test_method))


  		





  
  175
  
    
        suiteFew.addTest(Cyclades(test_method, config))


  		





  170
  176
  
    
    if len(argv) == 0 or argv[0] == 'image':


  		





  171
  177
  
    
        from kamaki.clients.tests.image import Image


  		





  172
  178
  
    
        test_method = 'test_%s' % (argv[1] if len(argv) > 1 else '000')


  		





  173
  
  
    
        suiteFew.addTest(Image(test_method))


  		





  
  179
  
    
        suiteFew.addTest(Image(test_method, config))


  		





  174
  180
  
    
    if len(argv) == 0 or argv[0] == 'astakos':


  		





  175
  181
  
    
        from kamaki.clients.tests.astakos import Astakos


  		





  176
  182
  
    
        if len(argv) == 1:


  		





  177
  
  
    
            suiteFew.addTest(makeSuite(Astakos))


  		





  
  183
  
    
            suiteFew.addTest(makeSuite(Astakos, config))


  		





  178
  184
  
    
        else:


  		





  179
  
  
    
            suiteFew.addTest(Astakos('test_' + argv[1]))


  		





  
  185
  
    
            suiteFew.addTest(Astakos('test_' + argv[1], config))


  		





  180
  186
  
    

  		





  181
  187
  
    
    TextTestRunner(verbosity=2).run(suiteFew)


  		





  182
  188
  
    

  		












  

    
      b/kamaki/clients/tests/cyclades.py
    
  






  63
  63
  
    

  		





  64
  64
  
    
    def tearDown(self):


  		





  65
  65
  
    
        """Destoy servers used in testing"""


  		





  66
  
  
    
        self.do_with_progress_bar(


  		





  67
  
  
    
            self._delete_network,


  		





  68
  
  
    
            'Delete %s networks' % len(self.networks),


  		





  69
  
  
    
            self.networks.keys())


  		





  
  66
  
    
        for net in self.networks.keys():


  		





  
  67
  
    
            self._delete_network(net)


  		





  
  68
  
    
        #self.do_with_progress_bar(


  		





  
  69
  
    
        #    self._delete_network,


  		





  
  70
  
    
        #    'Delete %s networks' % len(self.networks),


  		





  
  71
  
    
        #    self.networks.keys())


  		





  70
  72
  
    
        for server in self.servers.values():


  		





  71
  73
  
    
            self._delete_server(server['id'])


  		





  72
  74
  
    
            print('DEL VM %s (%s)' % (server['id'], server['name']))


  		





  ......




  111
  113
  
    
        print('Disconnect nics of network %s' % netid)


  		





  112
  114
  
    
        self.client.disconnect_network_nics(netid)


  		





  113
  115
  
    

  		





  114
  
  
    
        def netwait(self, wait):


  		





  
  116
  
    
        def netwait(wait):


  		





  115
  117
  
    
            try:


  		





  116
  118
  
    
                self.client.delete_network(netid)


  		





  117
  119
  
    
            except ClientError:


  		





  ......




  119
  121
  
    
        self.do_with_progress_bar(


  		





  120
  122
  
    
            netwait,


  		





  121
  123
  
    
            'Delete network %s' % netid,


  		





  122
  
  
    
            self._waits[:5])


  		





  
  124
  
    
            self._waits[:7])


  		





  123
  125
  
    

  		





  124
  126
  
    
    def _wait_for_network(self, netid, status):


  		





  125
  127
  
    

  		





  126
  
  
    
        def netwait(self, wait):


  		





  
  128
  
    
        def netwait(wait):


  		





  127
  129
  
    
            r = self.client.get_network_details(netid)


  		





  128
  130
  
    
            if r['status'] == status:


  		





  129
  131
  
    
                return


  		





  ......




  136
  138
  
    
    def _wait_for_nic(self, netid, servid, in_creation=True):


  		





  137
  139
  
    
        self._wait_for_network(netid, 'ACTIVE')


  		





  138
  140
  
    

  		





  139
  
  
    
        def nicwait(self, wait):


  		





  
  141
  
    
        def nicwait(wait):


  		





  140
  142
  
    
            nics = self.client.list_server_nics(servid)


  		





  141
  143
  
    
            for net in nics:


  		





  142
  144
  
    
                found_nic = net['network_id'] == netid


  		





  ......




  151
  153
  
    
                servid,


  		





  152
  154
  
    
                '' if in_creation else 'dis'),


  		





  153
  155
  
    
            self._waits[:5])


  		





  
  156
  
    
        return netid in [net['network_id']\


  		





  
  157
  
    
            for net in self.client.list_server_nics(servid)]


  		





  154
  158
  
    

  		





  155
  159
  
    
    def _has_status(self, servid, status):


  		





  156
  160
  
    
        r = self.client.get_server_details(servid)


  		





  ......




  259
  263
  
    

  		





  260
  264
  
    
    def _test_0030_wait_test_servers_to_build(self):


  		





  261
  265
  
    
        """Pseudo-test to wait for VMs to load"""


  		





  262
  
  
    
        from sys import stdout


  		





  263
  
  
    
        stdout.write('')


  		





  264
  
  
    
        stdout.flush()


  		





  
  266
  
    
        print('')


  		





  265
  267
  
    
        self._wait_for_status(self.server1['id'], 'BUILD')


  		





  266
  268
  
    
        self._wait_for_status(self.server2['id'], 'BUILD')


  		





  267
  269
  
    

  		





  ......




  319
  321
  
    

  		





  320
  322
  
    
    def _test_0070_wait_test_servers_to_reboot(self):


  		





  321
  323
  
    
        """Pseudo-test to wait for VMs to load"""


  		





  322
  
  
    
        from sys import stdout


  		





  323
  
  
    
        stdout.write('')


  		





  324
  
  
    
        stdout.flush()


  		





  
  324
  
    
        print('')


  		





  325
  325
  
    
        self._wait_for_status(self.server1['id'], 'REBOOT')


  		





  326
  326
  
    
        self._wait_for_status(self.server2['id'], 'REBOOT')


  		





  327
  327
  
    

  		





  ......




  470
  470
  
    
        self._wait_for_status(self.server1['id'], 'STOPPED')


  		





  471
  471
  
    
        r = self.client.get_server_details(self.server1['id'])


  		





  472
  472
  
    
        self.assertEqual(r['status'], 'ACTIVE')


  		





  
  473
  
    

  		





  
  474
  
    
    def test_get_server_console(self):


  		





  
  475
  
    
        """Test get_server_console"""


  		





  
  476
  
    
        self.server2 = self._create_server(self.servname2,


  		





  
  477
  
    
            self.flavorid + 2,


  		





  
  478
  
    
            self.img)


  		





  
  479
  
    
        self._wait_for_status(self.server2['id'], 'BUILD')


  		





  
  480
  
    
        self._test_0190_get_server_console()


  		





  
  481
  
    

  		





  
  482
  
    
    def _test_0190_get_server_console(self):


  		





  
  483
  
    
        r = self.client.get_server_console(self.server2['id'])


  		





  
  484
  
    
        self.assertTrue('host' in r)


  		





  
  485
  
    
        self.assertTrue('password' in r)


  		





  
  486
  
    
        self.assertTrue('port' in r)


  		





  
  487
  
    
        self.assertTrue('type' in r)


  		





  
  488
  
    

  		





  
  489
  
    
    def test_get_firewall_profile(self):


  		





  
  490
  
    
        """Test get_firewall_profile"""


  		





  
  491
  
    
        self.server1 = self._create_server(self.servname1,


  		





  
  492
  
    
            self.flavorid,


  		





  
  493
  
    
            self.img)


  		





  
  494
  
    
        self._test_0200_get_firewall_profile()


  		





  
  495
  
    

  		





  
  496
  
    
    def _test_0200_get_firewall_profile(self):


  		





  
  497
  
    
        self._wait_for_status(self.server1['id'], 'BUILD')


  		





  
  498
  
    
        fprofile = self.client.get_firewall_profile(self.server1['id'])


  		





  
  499
  
    
        self.assertTrue(fprofile in self.PROFILES)


  		





  
  500
  
    

  		





  
  501
  
    
    def test_set_firewall_profile(self):


  		





  
  502
  
    
        """Test set_firewall_profile"""


  		





  
  503
  
    
        self.server1 = self._create_server(self.servname1,


  		





  
  504
  
    
            self.flavorid,


  		





  
  505
  
    
            self.img)


  		





  
  506
  
    
        self._test_0210_set_firewall_profile()


  		





  
  507
  
    

  		





  
  508
  
    
    def _test_0210_set_firewall_profile(self):


  		





  
  509
  
    

  		





  
  510
  
    
        self._wait_for_status(self.server1['id'], 'BUILD')


  		





  
  511
  
    
        PROFILES = ['DISABLED', 'ENABLED', 'DISABLED', 'PROTECTED']


  		





  
  512
  
    
        fprofile = self.client.get_firewall_profile(self.server1['id'])


  		





  
  513
  
    
        print('')


  		





  
  514
  
    
        count_success = 0


  		





  
  515
  
    
        for counter, fprofile in enumerate(PROFILES):


  		





  
  516
  
    
            npos = counter + 1


  		





  
  517
  
    
            try:


  		





  
  518
  
    
                nprofile = PROFILES[npos]


  		





  
  519
  
    
            except IndexError:


  		





  
  520
  
    
                nprofile = PROFILES[0]


  		





  
  521
  
    
            print('\tprofile swap %s: %s -> %s' % (npos, fprofile, nprofile))


  		





  
  522
  
    
            self.client.set_firewall_profile(self.server1['id'], nprofile)


  		





  
  523
  
    
            time.sleep(0.5)


  		





  
  524
  
    
            self.client.reboot_server(self.server1['id'], hard=True)


  		





  
  525
  
    
            time.sleep(1)


  		





  
  526
  
    
            self._wait_for_status(self.server1['id'], 'REBOOT')


  		





  
  527
  
    
            time.sleep(0.5)


  		





  
  528
  
    
            changed = self.client.get_firewall_profile(self.server1['id'])


  		





  
  529
  
    
            try:


  		





  
  530
  
    
                self.assertEqual(changed, nprofile)


  		





  
  531
  
    
            except AssertionError as err:


  		





  
  532
  
    
                if count_success:


  		





  
  533
  
    
                    print('\tFAIL in swap #%s' % npos)


  		





  
  534
  
    
                    break


  		





  
  535
  
    
                else:


  		





  
  536
  
    
                    raise err


  		





  
  537
  
    
            count_success += 1


  		





  
  538
  
    

  		





  
  539
  
    
    def test_get_server_stats(self):


  		





  
  540
  
    
        self.server1 = self._create_server(self.servname1,


  		





  
  541
  
    
            self.flavorid,


  		





  
  542
  
    
            self.img)


  		





  
  543
  
    
        self._test_0220_get_server_stats()


  		





  
  544
  
    

  		





  
  545
  
    
    def _test_0220_get_server_stats(self):


  		





  
  546
  
    
        r = self.client.get_server_stats(self.server1['id'])


  		





  
  547
  
    
        for term in ('cpuBar',


  		





  
  548
  
    
        'cpuTimeSeries',


  		





  
  549
  
    
        'netBar',


  		





  
  550
  
    
        'netTimeSeries',


  		





  
  551
  
    
        'refresh'):


  		





  
  552
  
    
            self.assertTrue(term in r)


  		





  
  553
  
    

  		





  
  554
  
    
    def test_create_network(self):


  		





  
  555
  
    
        """Test create_network"""


  		





  
  556
  
    
        self._test_0230_create_network()


  		





  
  557
  
    

  		





  
  558
  
    
    def _test_0230_create_network(self):


  		





  
  559
  
    
        self.network1 = self._create_network(self.netname1)


  		





  
  560
  
    
        self._wait_for_network(self.network1['id'], 'ACTIVE')


  		





  
  561
  
    
        self.network1 = self.client.get_network_details(self.network1['id'])


  		





  
  562
  
    
        nets = self.client.list_networks(self.network1['id'])


  		





  
  563
  
    
        chosen = [net for net in nets if net['id'] == self.network1['id']][0]


  		





  
  564
  
    
        chosen.pop('updated')


  		





  
  565
  
    
        net1 = dict(self.network1)


  		





  
  566
  
    
        net1.pop('updated')


  		





  
  567
  
    
        self.assert_dicts_are_deeply_equal(chosen, net1)


  		





  
  568
  
    

  		





  
  569
  
    
    def test_connect_server(self):


  		





  
  570
  
    
        """Test connect_server"""


  		





  
  571
  
    
        self.server1 = self._create_server(self.servname1,


  		





  
  572
  
    
            self.flavorid,


  		





  
  573
  
    
            self.img)


  		





  
  574
  
    
        self.network1 = self._create_network(self.netname1)


  		





  
  575
  
    
        self._wait_for_status(self.server1['id'], 'BUILD')


  		





  
  576
  
    
        self._wait_for_network(self.network1['id'], 'ACTIVE')


  		





  
  577
  
    
        self._test_0240_connect_server()


  		





  
  578
  
    

  		





  
  579
  
    
    def _test_0250_connect_server(self):


  		





  
  580
  
    
        self.client.connect_server(self.server1['id'], self.network1['id'])


  		





  
  581
  
    
        self.assertTrue(self._wait_for_nic(


  		





  
  582
  
    
            self.network1['id'],


  		





  
  583
  
    
            self.server1['id']))


  		





  
  584
  
    

  		





  
  585
  
    
    def test_disconnect_server(self):


  		





  
  586
  
    
        """Test disconnect_server"""


  		





  
  587
  
    
        self.test_connect_server()


  		





  
  588
  
    
        self._test_0250_disconnect_server()


  		





  
  589
  
    

  		





  
  590
  
    
    def _test_0250_disconnect_server(self):


  		





  
  591
  
    
        self.client.disconnect_server(self.server1['id'], self.network1['id'])


  		





  
  592
  
    
        self.assertTrue(self._wait_for_nic(self.network1['id'],


  		





  
  593
  
    
            self.server1['id'],


  		





  
  594
  
    
            in_creation=False))


  		





  
  595
  
    

  		





  
  596
  
    
    def _test_0260_wait_for_second_network(self):


  		





  
  597
  
    
        self.network2 = self._create_network(self.netname2)


  		





  
  598
  
    
        self._wait_for_network(self.network2['id'], 'ACTIVE')


  		





  
  599
  
    

  		





  
  600
  
    
    def test_list_server_nics(self):


  		





  
  601
  
    
        """Test list_server_nics"""


  		





  
  602
  
    
        self.server1 = self._create_server(self.servname1,


  		





  
  603
  
    
            self.flavorid,


  		





  
  604
  
    
            self.img)


  		





  
  605
  
    
        self.network2 = self._create_network(self.netname2)


  		





  
  606
  
    
        self._wait_for_status(self.server1['id'], 'BUILD')


  		





  
  607
  
    
        self._wait_for_network(self.network2['id'], 'ACTIVE')


  		





  
  608
  
    
        self._test_0280_list_server_nics()


  		





  
  609
  
    

  		





  
  610
  
    
    def _test_0280_list_server_nics(self):


  		





  
  611
  
    
        r = self.client.list_server_nics(self.server1['id'])


  		





  
  612
  
    
        len0 = len(r)


  		





  
  613
  
    
        self.client.connect_server(self.server1['id'], self.network2['id'])


  		





  
  614
  
    
        self.assertTrue(self._wait_for_nic(


  		





  
  615
  
    
            self.network2['id'],


  		





  
  616
  
    
            self.server1['id']))


  		





  
  617
  
    
        r = self.client.list_server_nics(self.server1['id'])


  		





  
  618
  
    
        self.assertTrue(len(r) > len0)


  		





  
  619
  
    

  		





  
  620
  
    
    def test_list_networks(self):


  		





  
  621
  
    
        """Test list_network"""


  		





  
  622
  
    
        self.network1 = self._create_network(self.netname1)


  		





  
  623
  
    
        self._wait_for_network(self.network1['id'], 'ACTIVE')


  		





  
  624
  
    
        self._test_0290_list_networks()


  		





  
  625
  
    

  		





  
  626
  
    
    def _test_0290_list_networks(self):


  		





  
  627
  
    
        r = self.client.list_networks()


  		





  
  628
  
    
        self.assertTrue(len(r) > 1)


  		





  
  629
  
    
        ids = [net['id'] for net in r]


  		





  
  630
  
    
        names = [net['name'] for net in r]


  		





  
  631
  
    
        self.assertTrue('1' in ids)


  		





  
  632
  
    
        #self.assertTrue('public' in names)


  		





  
  633
  
    
        self.assertTrue(self.network1['id'] in ids)


  		





  
  634
  
    
        self.assertTrue(self.network1['name'] in names)


  		





  
  635
  
    

  		





  
  636
  
    
        r = self.client.list_networks(detail=True)


  		





  
  637
  
    
        ids = [net['id'] for net in r]


  		





  
  638
  
    
        names = [net['name'] for net in r]


  		





  
  639
  
    
        for net in r:


  		





  
  640
  
    
            self.assertTrue(net['id'] in ids)


  		





  
  641
  
    
            self.assertTrue(net['name'] in names)


  		





  
  642
  
    
            for term in ('status', 'updated', 'created'):


  		





  
  643
  
    
                self.assertTrue(term in net.keys())


  		





  
  644
  
    

  		





  
  645
  
    
    def test_get_network_details(self):


  		





  
  646
  
    
        """Test get_network_details"""


  		





  
  647
  
    
        self.network1 = self._create_network(self.netname1)


  		





  
  648
  
    
        self._test_0300_get_network_details()


  		





  
  649
  
    

  		





  
  650
  
    
    def _test_0300_get_network_details(self):


  		





  
  651
  
    
        r = self.client.get_network_details(self.network1['id'])


  		





  
  652
  
    
        net1 = dict(self.network1)


  		





  
  653
  
    
        net1.pop('status')


  		





  
  654
  
    
        net1.pop('updated', None)


  		





  
  655
  
    
        net1.pop('attachments')


  		





  
  656
  
    
        r.pop('status')


  		





  
  657
  
    
        r.pop('updated', None)


  		





  
  658
  
    
        r.pop('attachments')


  		





  
  659
  
    
        self.assert_dicts_are_deeply_equal(net1, r)


  		





  
  660
  
    

  		





  
  661
  
    
    def test_update_network_name(self):


  		





  
  662
  
    
        self.network2 = self._create_network(self.netname2)


  		





  
  663
  
    
        self._test_0310_update_network_name()


  		





  
  664
  
    

  		





  
  665
  
    
    def _test_0310_update_network_name(self):


  		





  
  666
  
    
        updated_name = self.netname2 + '_upd'


  		





  
  667
  
    
        self.client.update_network_name(self.network2['id'], updated_name)


  		





  
  668
  
    

  		





  
  669
  
    
        def netwait(wait):


  		





  
  670
  
    
            r = self.client.get_network_details(self.network2['id'])


  		





  
  671
  
    
            if r['name'] == updated_name:


  		





  
  672
  
    
                return


  		





  
  673
  
    
            time.sleep(wait)


  		





  
  674
  
    
        self.do_with_progress_bar(


  		





  
  675
  
    
            netwait,


  		





  
  676
  
    
            'Network %s name is changing:' % self.network2['id'],


  		





  
  677
  
    
            self._waits[:5])


  		





  
  678
  
    

  		





  
  679
  
    
        r = self.client.get_network_details(self.network2['id'])


  		





  
  680
  
    
        self.assertEqual(r['name'], updated_name)


  		





  
  681
  
    

  		





  
  682
  
    
    """ Don't have auth to test this


  		





  
  683
  
    
    def test_delete_image(self):


  		





  
  684
  
    
        ""Test delete_image""


  		





  
  685
  
    
        self._test_0330_delete_image()


  		





  
  686
  
    
    def _test_0330_delete_image(self):


  		





  
  687
  
    
        images = self.client.list_images()


  		





  
  688
  
    
        self.client.delete_image(images[2]['id'])


  		





  
  689
  
    
        try:


  		





  
  690
  
    
            r = self.client.get_image_details(images[2]['id'], success=(400))


  		





  
  691
  
    
        except ClientError as err:


  		





  
  692
  
    
            self.assertEqual(err.status, 404)


  		





  
  693
  
    

  		





  
  694
  
    
    def test_create_image_metadata(self):


  		





  
  695
  
    
        ""Test create_image_metadata""


  		





  
  696
  
    
        self._test_0340_create_image_metadata()


  		





  
  697
  
    
    def _test_0340_create_image_metadata(self):


  		





  
  698
  
    
        r = self.client.create_image_metadata(self.img, 'mykey', 'myval')


  		





  
  699
  
    
        self.assertEqual(r['mykey'], 'myval')


  		





  
  700
  
    

  		





  
  701
  
    
    def test_update_image_metadata(self):


  		





  
  702
  
    
        ""Test update_image_metadata""


  		





  
  703
  
    
        self._test_0350_update_image_metadata()


  		





  
  704
  
    
    def _test_0350_update_image_metadata(self):


  		





  
  705
  
    
        r = self.client.create_image_metadata(self.img, 'mykey0', 'myval')


  		





  
  706
  
    
        r = self.client.update_image_metadata(self.img, 'mykey0', 'myval0')


  		





  
  707
  
    
        self.assertEqual(r['mykey0'], 'myval0')


  		





  
  708
  
    

  		





  
  709
  
    
    def test_delete_image_metadata(self):


  		





  
  710
  
    
        ""Test delete_image_metadata""


  		





  
  711
  
    
        self._test_0360_delete_image_metadata()


  		





  
  712
  
    
    def _test_0360_delete_image_metadata(self):


  		





  
  713
  
    
        self.client.create_image_metadata(self.img, 'mykey1', 'myval1')


  		





  
  714
  
    
        self.client.delete_image_metadata(self.img, 'mykey1')


  		





  
  715
  
    
        r = self.client.get_image_metadata(self.img)


  		





  
  716
  
    
        self.assertNotEqual('mykey1' in r)


  		





  
  717
  
    
    """


  		












Also available in:
  Unified diff