Rename meta-->metadata and remove values @CLI

Refs: #3633

diff --git a/Changelog b/Changelog
index 2c03fe1..02bb857 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -54,6 +54,8 @@ Changes:
     - server: firewall, metadata
 - Add a _format_image_headers method and use it in image_register and get_meta
     for uniform image meta output [#3797]
+- Rename meta-->metadata and remove values @lib [#3633]
+
 
 Features:
 

diff --git a/kamaki/cli/commands/__init__.py b/kamaki/cli/commands/__init__.py
index da596bf..223ac8a 100644 (file)
--- a/kamaki/cli/commands/__init__.py
+++ b/kamaki/cli/commands/__init__.py
@@ -31,7 +31,7 @@
 # interpreted as representing official policies, either expressed
 # or implied, of GRNET S.A.command
 
-from kamaki.logger import get_logger
+from kamaki.cli.logger import get_logger
 from kamaki.cli.utils import print_json, print_items
 from kamaki.cli.argument import FlagArgument
 

diff --git a/kamaki/cli/commands/cyclades.py b/kamaki/cli/commands/cyclades.py
index b24df1e..6f456b1 100644 (file)
--- a/kamaki/cli/commands/cyclades.py
+++ b/kamaki/cli/commands/cyclades.py
@@ -98,30 +98,12 @@ class server_list(_init_cyclades, _optional_json):
         enum=FlagArgument('Enumerate results', '--enumerate')
     )
 
-    def _make_results_pretty(self, servers):
-        for server in servers:
-            addr_dict = {}
-            if 'attachments' in server:
-                for addr in server['attachments']['values']:
-                    ips = addr.pop('values', [])
-                    for ip in ips:
-                        addr['IPv%s' % ip['version']] = ip['addr']
-                    if 'firewallProfile' in addr:
-                        addr['firewall'] = addr.pop('firewallProfile')
-                    addr_dict[addr.pop('id')] = addr
-                server['attachments'] = addr_dict if addr_dict else None
-            if 'metadata' in server:
-                server['metadata'] = server['metadata']['values']
-
     @errors.generic.all
     @errors.cyclades.connection
     @errors.cyclades.date
     def _run(self):
         servers = self.client.list_servers(self['detail'], self['since'])
 
-        if self['detail'] and not self['json_output']:
-            self._make_results_pretty(servers)
-
         kwargs = dict(with_enumeration=self['enum'])
         if self['more']:
             kwargs['page_size'] = self['limit'] if self['limit'] else 10
@@ -144,27 +126,11 @@ class server_info(_init_cyclades, _optional_json):
     - hardware flavor and os image ids
     """
 
-    def _pretty(self, server):
-        addr_dict = {}
-        if 'attachments' in server:
-            atts = server.pop('attachments')
-            for addr in atts['values']:
-                ips = addr.pop('values', [])
-                for ip in ips:
-                    addr['IPv%s' % ip['version']] = ip['addr']
-                if 'firewallProfile' in addr:
-                    addr['firewall'] = addr.pop('firewallProfile')
-                addr_dict[addr.pop('id')] = addr
-            server['attachments'] = addr_dict if addr_dict else None
-        if 'metadata' in server:
-            server['metadata'] = server['metadata']['values']
-        print_dict(server, ident=1)
-
     @errors.generic.all
     @errors.cyclades.connection
     @errors.cyclades.server_id
     def _run(self, server_id):
-        self._print(self.client.get_server_details(server_id), self._pretty)
+        self._print(self.client.get_server_details(server_id), print_dict)
 
     def main(self, server_id):
         super(self.__class__, self)._run()
@@ -224,8 +190,10 @@ class server_create(_init_cyclades, _optional_json):
     @errors.plankton.id
     @errors.cyclades.flavor_id
     def _run(self, name, flavor_id, image_id):
-        self._print([self.client.create_server(
-            name, int(flavor_id), image_id, self['personality'])])
+        self._print(
+            self.client.create_server(
+                name, int(flavor_id), image_id, self['personality']),
+            print_dict)
 
     def main(self, name, flavor_id, image_id):
         super(self.__class__, self)._run()
@@ -328,7 +296,8 @@ class server_console(_init_cyclades, _optional_json):
     @errors.cyclades.connection
     @errors.cyclades.server_id
     def _run(self, server_id):
-        self._print([self.client.get_server_console(int(server_id))])
+        self._print(
+            self.client.get_server_console(int(server_id)), print_dict)
 
     def main(self, server_id):
         super(self.__class__, self)._run()
@@ -413,7 +382,7 @@ class server_metadata_list(_init_cyclades, _optional_json):
     @errors.cyclades.metadata
     def _run(self, server_id, key=''):
         self._print(
-            [self.client.get_server_metadata(int(server_id), key)], title=())
+            self.client.get_server_metadata(int(server_id), key), print_dict)
 
     def main(self, server_id, key=''):
         super(self.__class__, self)._run()
@@ -448,8 +417,8 @@ class server_metadata_set(_init_cyclades, _optional_json):
                         '/server metadata set <server id>'
                         'key1=value1 key2=value2'])
         self._print(
-            [self.client.update_server_metadata(int(server_id), **metadata)],
-            title=())
+            self.client.update_server_metadata(int(server_id), **metadata),
+            print_dict)
 
     def main(self, server_id, *key_equals_val):
         super(self.__class__, self)._run()
@@ -481,7 +450,7 @@ class server_stats(_init_cyclades, _optional_json):
     @errors.cyclades.connection
     @errors.cyclades.server_id
     def _run(self, server_id):
-        self._print([self.client.get_server_stats(int(server_id))])
+        self._print(self.client.get_server_stats(int(server_id)), print_dict)
 
     def main(self, server_id):
         super(self.__class__, self)._run()
@@ -566,7 +535,8 @@ class flavor_info(_init_cyclades, _optional_json):
     @errors.cyclades.connection
     @errors.cyclades.flavor_id
     def _run(self, flavor_id):
-        self._print([self.client.get_flavor_details(int(flavor_id))])
+        self._print(
+            self.client.get_flavor_details(int(flavor_id)), print_dict)
 
     def main(self, flavor_id):
         super(self.__class__, self)._run()
@@ -579,20 +549,11 @@ class network_info(_init_cyclades, _optional_json):
     To get a list of available networks and network ids, try /network list
     """
 
-    @classmethod
-    def _make_result_pretty(self, net):
-        if 'attachments' in net:
-            att = net['attachments']['values']
-            count = len(att)
-            net['attachments'] = att if count else None
-
     @errors.generic.all
     @errors.cyclades.connection
     @errors.cyclades.network_id
     def _run(self, network_id):
         network = self.client.get_network_details(int(network_id))
-        self._make_result_pretty(network)
-        #print_dict(network, exclude=('id'))
         self._print(network, print_dict, exclude=('id'))
 
     def main(self, network_id):
@@ -613,16 +574,10 @@ class network_list(_init_cyclades, _optional_json):
         enum=FlagArgument('Enumerate results', '--enumerate')
     )
 
-    def _make_results_pretty(self, nets):
-        for net in nets:
-            network_info._make_result_pretty(net)
-
     @errors.generic.all
     @errors.cyclades.connection
     def _run(self):
         networks = self.client.list_networks(self['detail'])
-        if self['detail']:
-            self._make_results_pretty(networks)
         kwargs = dict(with_enumeration=self['enum'])
         if self['more']:
             kwargs['page_size'] = self['limit'] or 10
@@ -654,12 +609,12 @@ class network_create(_init_cyclades, _optional_json):
     @errors.cyclades.connection
     @errors.cyclades.network_max
     def _run(self, name):
-        self._print([self.client.create_network(
+        self._print(self.client.create_network(
             name,
             cidr=self['cidr'],
             gateway=self['gateway'],
             dhcp=self['dhcp'],
-            type=self['type'])])
+            type=self['type']), print_dict)
 
     def main(self, name):
         super(self.__class__, self)._run()

diff --git a/kamaki/cli/commands/image.py b/kamaki/cli/commands/image.py
index b5aa335..1402283 100644 (file)
--- a/kamaki/cli/commands/image.py
+++ b/kamaki/cli/commands/image.py
@@ -533,21 +533,14 @@ class image_compute_list(_init_cyclades, _optional_json):
         enum=FlagArgument('Enumerate results', '--enumerate')
     )
 
-    def _make_results_pretty(self, images):
-        for img in images:
-            if 'metadata' in img:
-                img['metadata'] = img['metadata']['values']
-
     @errors.generic.all
     @errors.cyclades.connection
     def _run(self):
         images = self.client.list_images(self['detail'])
-        if self['detail'] and not self['json_output']:
-            self._make_results_pretty(images)
         kwargs = dict(with_enumeration=self['enum'])
         if self['more']:
             kwargs['page_size'] = self['limit'] or 10
-        else:
+        elif self['limit']:
             images = images[:self['limit']]
         self._print(images, **kwargs)
 
@@ -565,9 +558,7 @@ class image_compute_info(_init_cyclades, _optional_json):
     @errors.plankton.id
     def _run(self, image_id):
         image = self.client.get_image_details(image_id)
-        if (not self['json_output']) and 'metadata' in image:
-            image['metadata'] = image['metadata']['values']
-        self._print([image])
+        self._print(image, print_dict)
 
     def main(self, image_id):
         super(self.__class__, self)._run()

diff --git a/kamaki/cli/errors.py b/kamaki/cli/errors.py
index e15bf32..57e2560 100644 (file)
--- a/kamaki/cli/errors.py
+++ b/kamaki/cli/errors.py
@@ -31,7 +31,7 @@
 # interpreted as representing official policies, either expressed
 # or implied, of GRNET S.A.
 
-from kamaki.logger import get_logger
+from kamaki.cli.logger import get_logger
 
 log = get_logger('kamaki.cli')
 

diff --git a/kamaki/clients/compute/__init__.py b/kamaki/clients/compute/__init__.py
index a055c73..3cfbeb8 100644 (file)
--- a/kamaki/clients/compute/__init__.py
+++ b/kamaki/clients/compute/__init__.py
@@ -153,7 +153,7 @@ class ComputeClient(ComputeRestClient):
         """
         command = path4url('metadata', key)
         r = self.servers_get(server_id, command)
-        return r.json['meta'] if key else r.json['metadata']
+        return r.json['metadata']
 
     def create_server_metadata(self, server_id, key, val):
         """
@@ -165,13 +165,13 @@ class ComputeClient(ComputeRestClient):
 
         :returns: dict of updated key:val metadata
         """
-        req = {'meta': {key: val}}
+        req = {'metadata': {key: val}}
         r = self.servers_put(
             server_id,
             'metadata/' + key,
             json_data=req,
             success=201)
-        return r.json['meta']
+        return r.json['metadata']
 
     def update_server_metadata(self, server_id, **metadata):
         """
@@ -202,7 +202,7 @@ class ComputeClient(ComputeRestClient):
         """
         :param detail: (bool) detailed flavor info if set, short if not
 
-        :returns: (dict) flavor info
+        :returns: (list) flavor info
         """
         r = self.flavors_get(command='detail' if detail else '')
         return r.json['flavors']
@@ -258,7 +258,7 @@ class ComputeClient(ComputeRestClient):
         """
         command = path4url('metadata', key)
         r = self.images_get(image_id, command)
-        return r.json['meta'] if key else r.json['metadata']
+        return r.json['metadata']
 
     def create_image_metadata(self, image_id, key, val):
         """
@@ -270,9 +270,9 @@ class ComputeClient(ComputeRestClient):
 
         :returns: (dict) updated metadata
         """
-        req = {'meta': {key: val}}
+        req = {'metadata': {key: val}}
         r = self.images_put(image_id, 'metadata/' + key, json_data=req)
-        return r.json['meta']
+        return r.json['metadata']
 
     def update_image_metadata(self, image_id, **metadata):
         """

diff --git a/kamaki/clients/compute/test.py b/kamaki/clients/compute/test.py
index 7b0ca52..e793d89 100644 (file)
--- a/kamaki/clients/compute/test.py
+++ b/kamaki/clients/compute/test.py
@@ -62,7 +62,7 @@ vm_recv = dict(server=dict(
     suspended=False,
     progress=0,
     id=31173,
-    metadata=dict(values=dict(os="debian", users="root"))))
+    metadata=dict(os="debian", users="root")))
 img_recv = dict(image=dict(
     status="ACTIVE",
     updated="2013-02-26T11:10:14+00:00",
@@ -70,7 +70,7 @@ img_recv = dict(image=dict(
     created="2013-02-26T11:03:29+00:00",
     progress=100,
     id=img_ref,
-    metadata=dict(values=dict(
+    metadata=dict(
         partition_table="msdos",
         kernel="2.6.32",
         osfamily="linux",
@@ -79,15 +79,15 @@ img_recv = dict(image=dict(
         sortorder="1",
         os="debian",
         root_partition="1",
-        description="Debian 6.0.7 (Squeeze) Base System"))))
-vm_list = dict(servers=dict(values=[
+        description="Debian 6.0.7 (Squeeze) Base System")))
+vm_list = dict(servers=[
     dict(name='n1', id=1),
-    dict(name='n2', id=2)]))
-flavor_list = dict(flavors=dict(values=[
+    dict(name='n2', id=2)])
+flavor_list = dict(flavors=[
     dict(id=41, name="C1R1024D20"),
     dict(id=42, name="C1R1024D40"),
-    dict(id=43, name="C1R1028D20")]))
-img_list = dict(images=dict(values=[
+    dict(id=43, name="C1R1028D20")])
+img_list = dict(images=[
     dict(name="maelstrom", id="0fb03e45-7d5a-4515-bd4e-e6bbf6457f06"),
     dict(name="edx_saas", id="1357163d-5fd8-488e-a117-48734c526206"),
     dict(name="Debian_Wheezy_Base", id="1f8454f0-8e3e-4b6c-ab8e-5236b728dffe"),
@@ -95,7 +95,7 @@ img_list = dict(images=dict(values=[
     dict(name="Ubuntu Desktop", id="37bc522c-c479-4085-bfb9-464f9b9e2e31"),
     dict(name="Ubuntu 12.10", id="3a24fef9-1a8c-47d1-8f11-e07bd5e544fd"),
     dict(name="Debian Base", id="40ace203-6254-4e17-a5cb-518d55418a7d"),
-    dict(name="ubuntu_bundled", id="5336e265-5c7c-4127-95cb-2bf832a79903")]))
+    dict(name="ubuntu_bundled", id="5336e265-5c7c-4127-95cb-2bf832a79903")])
 
 
 class FR(object):
@@ -282,7 +282,7 @@ class ComputeClient(TestCase):
             r = self.client.list_servers(detail)
             self.assertEqual(SG.mock_calls[-1], call(
                 command='detail' if detail else ''))
-            for i, vm in enumerate(vm_list['servers']['values']):
+            for i, vm in enumerate(vm_list['servers']):
                 self.assert_dicts_are_equal(r[i], vm)
             self.assertEqual(i + 1, len(r))
 
@@ -314,28 +314,29 @@ class ComputeClient(TestCase):
     def test_create_server_metadata(self, SP):
         vm_id = vm_recv['server']['id']
         metadata = dict(m1='v1', m2='v2', m3='v3')
-        FR.json = dict(meta=vm_recv['server'])
+        FR.json = dict(metadata=vm_recv['server'])
         for k, v in metadata.items():
             r = self.client.create_server_metadata(vm_id, k, v)
             self.assert_dicts_are_equal(r, vm_recv['server'])
             self.assertEqual(SP.mock_calls[-1], call(
-                vm_id, 'meta/%s' % k,
-                json_data=dict(meta={k: v}), success=201))
+                vm_id, 'metadata/%s' % k,
+                json_data=dict(metadata={k: v}), success=201))
 
     @patch('%s.servers_get' % compute_pkg, return_value=FR())
     def test_get_server_metadata(self, SG):
         vm_id = vm_recv['server']['id']
         metadata = dict(m1='v1', m2='v2', m3='v3')
-        FR.json = dict(metadata=dict(values=metadata))
+        FR.json = dict(metadata=metadata)
         r = self.client.get_server_metadata(vm_id)
-        SG.assert_called_once_with(vm_id, '/meta')
+        SG.assert_called_once_with(vm_id, '/metadata')
         self.assert_dicts_are_equal(r, metadata)
 
         for k, v in metadata.items():
-            FR.json = dict(meta={k: v})
+            FR.json = dict(metadata={k: v})
             r = self.client.get_server_metadata(vm_id, k)
             self.assert_dicts_are_equal(r, {k: v})
-            self.assertEqual(SG.mock_calls[-1], call(vm_id, '/meta/%s' % k))
+            self.assertEqual(
+                SG.mock_calls[-1], call(vm_id, '/metadata/%s' % k))
 
     @patch('%s.servers_post' % compute_pkg, return_value=FR())
     def test_update_server_metadata(self, SP):
@@ -345,7 +346,7 @@ class ComputeClient(TestCase):
         r = self.client.update_server_metadata(vm_id, **metadata)
         self.assert_dicts_are_equal(r, metadata)
         SP.assert_called_once_with(
-            vm_id, 'meta',
+            vm_id, 'metadata',
             json_data=dict(metadata=metadata), success=201)
 
     @patch('%s.servers_delete' % compute_pkg, return_value=FR())
@@ -353,7 +354,7 @@ class ComputeClient(TestCase):
         vm_id = vm_recv['server']['id']
         key = 'metakey'
         self.client.delete_server_metadata(vm_id, key)
-        SD.assert_called_once_with(vm_id, 'meta/' + key)
+        SD.assert_called_once_with(vm_id, 'metadata/' + key)
 
     @patch('%s.flavors_get' % compute_pkg, return_value=FR())
     def test_list_flavors(self, FG):
@@ -361,14 +362,14 @@ class ComputeClient(TestCase):
         for cmd in ('', 'detail'):
             r = self.client.list_flavors(detail=(cmd == 'detail'))
             self.assertEqual(FG.mock_calls[-1], call(command=cmd))
-            self.assert_dicts_are_equal(dict(values=r), flavor_list['flavors'])
+            self.assertEqual(r, flavor_list['flavors'])
 
     @patch('%s.flavors_get' % compute_pkg, return_value=FR())
     def test_get_flavor_details(self, FG):
-        FR.json = dict(flavor=flavor_list['flavors'])
+        FR.json = dict(flavor=flavor_list['flavors'][0])
         r = self.client.get_flavor_details(fid)
         FG.assert_called_once_with(fid)
-        self.assert_dicts_are_equal(r, flavor_list['flavors'])
+        self.assert_dicts_are_equal(r, flavor_list['flavors'][0])
 
     @patch('%s.images_get' % compute_pkg, return_value=FR())
     def test_list_images(self, IG):
@@ -376,7 +377,7 @@ class ComputeClient(TestCase):
         for cmd in ('', 'detail'):
             r = self.client.list_images(detail=(cmd == 'detail'))
             self.assertEqual(IG.mock_calls[-1], call(command=cmd))
-            expected = img_list['images']['values']
+            expected = img_list['images']
             for i in range(len(r)):
                 self.assert_dicts_are_equal(expected[i], r[i])
 
@@ -390,12 +391,12 @@ class ComputeClient(TestCase):
     @patch('%s.images_get' % compute_pkg, return_value=FR())
     def test_get_image_metadata(self, IG):
         for key in ('', '50m3k3y'):
-            FR.json = dict(meta=img_recv['image']) if (
-                key) else dict(metadata=dict(values=img_recv['image']))
+            FR.json = dict(metadata=img_recv['image']) if (
+                key) else dict(metadata=img_recv['image'])
             r = self.client.get_image_metadata(img_ref, key)
             self.assertEqual(IG.mock_calls[-1], call(
                 '%s' % img_ref,
-                '/meta%s' % (('/%s' % key) if key else '')))
+                '/metadata%s' % (('/%s' % key) if key else '')))
             self.assert_dicts_are_equal(img_recv['image'], r)
 
     @patch('%s.servers_delete' % compute_pkg, return_value=FR())
@@ -412,11 +413,11 @@ class ComputeClient(TestCase):
     @patch('%s.images_put' % compute_pkg, return_value=FR())
     def test_create_image_metadata(self, IP):
         (key, val) = ('k1', 'v1')
-        FR.json = dict(meta=img_recv['image'])
+        FR.json = dict(metadata=img_recv['image'])
         r = self.client.create_image_metadata(img_ref, key, val)
         IP.assert_called_once_with(
-            img_ref, 'meta/%s' % key,
-            json_data=dict(meta={key: val}))
+            img_ref, 'metadata/%s' % key,
+            json_data=dict(metadata={key: val}))
         self.assert_dicts_are_equal(r, img_recv['image'])
 
     @patch('%s.images_post' % compute_pkg, return_value=FR())
@@ -425,7 +426,7 @@ class ComputeClient(TestCase):
         FR.json = dict(metadata=metadata)
         r = self.client.update_image_metadata(img_ref, **metadata)
         IP.assert_called_once_with(
-            img_ref, 'meta',
+            img_ref, 'metadata',
             json_data=dict(metadata=metadata))
         self.assert_dicts_are_equal(r, metadata)
 
@@ -433,7 +434,7 @@ class ComputeClient(TestCase):
     def test_delete_image_metadata(self, ID):
         key = 'metakey'
         self.client.delete_image_metadata(img_ref, key)
-        ID.assert_called_once_with(img_ref, '/meta/%s' % key)
+        ID.assert_called_once_with(img_ref, '/metadata/%s' % key)
 
 
 if __name__ == '__main__':

diff --git a/kamaki/clients/cyclades/test.py b/kamaki/clients/cyclades/test.py
index e94015d..773098b 100644 (file)
--- a/kamaki/clients/cyclades/test.py
+++ b/kamaki/clients/cyclades/test.py
@@ -52,10 +52,10 @@ vm_recv = dict(server=dict(
     suspended=False,
     progress=0,
     id=31173,
-    metadata=dict(values=dict(os="debian", users="root"))))
-vm_list = dict(servers=dict(values=[
+    metadata=dict(os="debian", users="root")))
+vm_list = dict(servers=[
     dict(name='n1', id=1),
-    dict(name='n2', id=2)]))
+    dict(name='n2', id=2)])
 net_send = dict(network=dict(dhcp=False, name='someNet'))
 net_recv = dict(network=dict(
     status="PENDING",
@@ -70,13 +70,13 @@ net_recv = dict(network=dict(
     cidr="192.168.1.0/24",
     type="MAC_FILTERED",
     gateway=None,
-    attachments=dict(values=[dict(name='att1'), dict(name='att2')])))
-net_list = dict(networks=dict(values=[
+    attachments=[dict(name='att1'), dict(name='att2')]))
+net_list = dict(networks=[
     dict(id=1, name='n1'),
     dict(id=2, name='n2'),
-    dict(id=3, name='n3')]))
-firewalls = dict(attachments=dict(values=[
-    dict(firewallProfile='50m3_pr0f1L3', otherStuff='57uff')]))
+    dict(id=3, name='n3')])
+firewalls = dict(attachments=[
+    dict(firewallProfile='50m3_pr0f1L3', otherStuff='57uff')])
 
 
 class FR(object):
@@ -233,7 +233,7 @@ class CycladesClient(TestCase):
             self.assertEqual(SG.mock_calls[-1], call(
                 command='detail' if detail else '',
                 changes_since=since))
-            expected = vm_list['servers']['values']
+            expected = vm_list['servers']
             for i, vm in enumerate(r):
                 self.assert_dicts_are_equal(vm, expected[i])
             self.assertEqual(i + 1, len(expected))
@@ -267,7 +267,7 @@ class CycladesClient(TestCase):
 
     def test_get_firewall_profile(self):
         vm_id = vm_recv['server']['id']
-        v = firewalls['attachments']['values'][0]['firewallProfile']
+        v = firewalls['attachments'][0]['firewallProfile']
         with patch.object(
                 cyclades.CycladesClient, 'get_server_details',
                 return_value=firewalls) as GSD:
@@ -285,7 +285,7 @@ class CycladesClient(TestCase):
     @patch('%s.servers_post' % cyclades_pkg, return_value=FR())
     def test_set_firewall_profile(self, SP):
         vm_id = vm_recv['server']['id']
-        v = firewalls['attachments']['values'][0]['firewallProfile']
+        v = firewalls['attachments'][0]['firewallProfile']
         self.client.set_firewall_profile(vm_id, v)
         SP.assert_called_once_with(
             vm_id, 'action',
@@ -354,11 +354,11 @@ class CycladesClient(TestCase):
     @patch('%s.servers_get' % cyclades_pkg, return_value=FR())
     def test_list_server_nics(self, SG):
         vm_id = vm_recv['server']['id']
-        nics = dict(addresses=dict(values=[dict(id='nic1'), dict(id='nic2')]))
+        nics = dict(addresses=[dict(id='nic1'), dict(id='nic2')])
         FR.json = nics
         r = self.client.list_server_nics(vm_id)
         SG.assert_called_once_with(vm_id, 'ips')
-        expected = nics['addresses']['values']
+        expected = nics['addresses']
         for i in range(len(r)):
             self.assert_dicts_are_equal(r[i], expected[i])
         self.assertEqual(i + 1, len(r))
@@ -366,7 +366,7 @@ class CycladesClient(TestCase):
     @patch('%s.networks_get' % cyclades_pkg, return_value=FR())
     def test_list_networks(self, NG):
         FR.json = net_list
-        expected = net_list['networks']['values']
+        expected = net_list['networks']
         for detail in ('', 'detail'):
             r = self.client.list_networks(detail=True if detail else False)
             self.assertEqual(NG.mock_calls[-1], call(command=detail))
@@ -380,7 +380,7 @@ class CycladesClient(TestCase):
         FR.json = net_recv
         r = self.client.list_network_nics(net_id)
         NG.assert_called_once_with(network_id=net_id)
-        expected = net_recv['network']['attachments']['values']
+        expected = net_recv['network']['attachments']
         for i in range(len(r)):
             self.assert_dicts_are_equal(r[i], expected[i])