Merge lp:~mpontillo/maas/node-statistics-bug-1584926--part2 into lp:~maas-committers/maas/trunk

[Mike Pontillo]

* Add new APIs to fetch machines and devices using a "group by":
   - machines by-status [numeric=<bool>] [count=<bool>] [summary=<bool>]
   - machines by-user [count=<bool>] [summary=<bool>]
   - machines by-zone [count=<bool>] [summary=<bool>]
   - devices by-parent [by_system_id=<bool>] [count=<bool>] [summary=<bool>]
 * Add new API to map node status IDs to labels:
   - machines get-status-descriptions

[MAAS Lander (maas-lander)]

Transitioned to Git.

lp:maas has now moved from Bzr to Git.
Please propose your branches with Launchpad using Git.

git clone https://git.launchpad.net/maas

Unmerged revisions

5146. By Mike Pontillo on 2016-06-16

Add tests for devices by-parent.

5145. By Mike Pontillo on 2016-06-16

Add tests for machines by-zone.

5144. By Mike Pontillo on 2016-06-16

Add tests for machines by-status.

5143. By Mike Pontillo on 2016-06-16

Add tests for machines by-user.

5142. By Mike Pontillo on 2016-06-16

Reinstate API changes for devices and machines.

5141. By Mike Pontillo on 2016-06-16

Revert changes to devices.py and machines.py. (they'll be moved to another branch)

5140. By Mike Pontillo on 2016-06-16

Fix lint, review comments.

5139. By Mike Pontillo on 2016-06-16

More tests.

5138. By Mike Pontillo on 2016-06-16

Start adding test cases.

5137. By Mike Pontillo on 2016-06-15

Format imports.

=== modified file 'src/maasserver/api/devices.py'
--- src/maasserver/api/devices.py	2016-05-12 19:07:37 +0000
+++ src/maasserver/api/devices.py	2016-06-16 21:29:13 +0000
@@ -6,6 +6,7 @@
     "DevicesHandler",
     ]
 
+from formencode.validators import StringBool
 from maasserver.api.logger import maaslog
 from maasserver.api.nodes import (
     NodeHandler,
@@ -13,13 +14,17 @@
     OwnerDataMixin,
 )
 from maasserver.api.support import operation
+from maasserver.api.utils import get_optional_param
 from maasserver.enum import NODE_PERMISSION
 from maasserver.exceptions import MAASAPIValidationError
 from maasserver.forms import (
     DeviceForm,
     DeviceWithMACsForm,
 )
-from maasserver.models.node import Device
+from maasserver.models.node import (
+    Device,
+    Node,
+)
 from maasserver.utils.orm import reload_object
 from piston3.utils import rc
 
@@ -190,6 +195,34 @@
         else:
             raise MAASAPIValidationError(form.errors)
 
+    @operation(idempotent=True)
+    def by_parent(self, request):
+        """Fetches the list of devices by parent.
+
+        Optional arguments:
+        summary: If True, prints a summary of each node instead of the complete
+        object.
+        count: If True, prints a count of the number of nodes allocated to each
+        user instead of any node details.
+        by_system_id: If True, prints the parent node system_id values instead
+        of hostnames.
+
+        Also accepts any filter parameter the 'read' operation accepts.
+        """
+        summary = get_optional_param(
+            request.GET, 'summary', default=False, validator=StringBool)
+        count = get_optional_param(
+            request.GET, 'count', default=False, validator=StringBool)
+        by_system_id = get_optional_param(
+            request.GET, 'by_system_id', default=False, validator=StringBool)
+        return {
+            node.system_id if by_system_id else node.hostname:
+                self.prepare_results(
+                    self._query(request).filter(parent=node),
+                    count=count, summary=summary)
+            for node in Node.objects.filter(children__isnull=False)
+        }
+
     @classmethod
     def resource_uri(cls, *args, **kwargs):
         return ('devices_handler', [])

=== modified file 'src/maasserver/api/machines.py'
--- src/maasserver/api/machines.py	2016-06-10 16:43:12 +0000
+++ src/maasserver/api/machines.py	2016-06-16 21:29:13 +0000
@@ -45,6 +45,7 @@
 from maasserver.enum import (
     NODE_PERMISSION,
     NODE_STATUS,
+    NODE_STATUS_CHOICES,
 )
 from maasserver.exceptions import (
     MAASAPIBadRequest,
@@ -68,6 +69,8 @@
     Filesystem,
     Machine,
     RackController,
+    User,
+    Zone,
 )
 from maasserver.models.node import RELEASABLE_STATUSES
 from maasserver.node_constraint_filter_forms import AcquireNodeForm
@@ -1358,6 +1361,89 @@
                 rack.hostname, hostname),
             content_type=("text/plain; charset=%s" % settings.DEFAULT_CHARSET))
 
+    @operation(idempotent=True)
+    def get_status_descriptions(self, request):
+        """Returns the mapping of stauts IDs to status labels."""
+        return {choice[0]: choice[1] for choice in NODE_STATUS_CHOICES}
+
+    @operation(idempotent=True)
+    def by_user(self, request):
+        """Fetches the list of nodes allocated to each user.
+
+        Optional arguments:
+        summary: If True, prints a summary of each node instead of the complete
+        object.
+        count: If True, prints a count of the number of nodes allocated to each
+        user instead of any node details.
+
+        Also accepts any filter parameter the 'read' operation accepts.
+        """
+        summary = get_optional_param(
+            request.GET, 'summary', default=False, validator=StringBool)
+        count = get_optional_param(
+            request.GET, 'count', default=False, validator=StringBool)
+        return {
+            user.username:
+                self.prepare_results(
+                    self._query(request).filter(owner=user),
+                    count=count, summary=summary)
+            for user in User.objects.filter(is_active=True)
+        }
+
+    @operation(idempotent=True)
+    def by_status(self, request):
+        """Fetches the list of nodes grouped by node status.
+
+        Optional arguments:
+        summary: If True, prints a summary of each node instead of the complete
+        object.
+        count: If True, prints a count of the number of nodes with each status
+        instead of any node details.
+        numeric: If True, prints numeric status values as the key instead of
+        friendly descriptions.
+
+        Also accepts any filter parameter the 'read' operation accepts.
+        """
+        summary = get_optional_param(
+            request.GET, 'summary', default=False, validator=StringBool)
+        count = get_optional_param(
+            request.GET, 'count', default=False, validator=StringBool)
+        numeric = get_optional_param(
+            request.GET, 'numeric', default=False, validator=StringBool)
+        return {
+            # NODE_STATUS_CHOICES[0] will be the numeric value; [1] is the
+            # description.
+            status_choice[0 if numeric else 1]:
+                self.prepare_results(
+                    self._query(request).filter(status=status_choice[0]),
+                    count=count, summary=summary)
+            for status_choice in NODE_STATUS_CHOICES
+            }
+
+    @operation(idempotent=True)
+    def by_zone(self, request):
+        """Fetches the list of nodes grouped by zone.
+
+        Optional arguments:
+        summary: If True, prints a summary of each node instead of the complete
+        object.
+        count: If True, prints a count of the number of nodes in each zone
+        instead of any node details.
+
+        Also accepts any filter parameter the 'read' operation accepts.
+        """
+        summary = get_optional_param(
+            request.GET, 'summary', default=False, validator=StringBool)
+        count = get_optional_param(
+            request.GET, 'count', default=False, validator=StringBool)
+        return {
+            zone.name:
+                self.prepare_results(
+                    self._query(request).filter(zone=zone),
+                    count=count, summary=summary)
+            for zone in Zone.objects.all()
+            }
+
     @classmethod
     def resource_uri(cls, *args, **kwargs):
         return ('machines_handler', [])

=== modified file 'src/maasserver/api/tests/test_devices.py'
--- src/maasserver/api/tests/test_devices.py	2016-05-24 22:05:45 +0000
+++ src/maasserver/api/tests/test_devices.py	2016-06-16 21:29:13 +0000
@@ -23,6 +23,7 @@
 from maasserver.utils.converters import json_load_bytes
 from maasserver.utils.orm import reload_object
 from maastesting.matchers import MockCalledOnce
+from testtools.matchers import (Equals, HasLength)
 
 
 class DeviceOwnerDataTest(APITestCase.ForUser):
@@ -201,6 +202,73 @@
             [device.system_id for device in devices],
             [device.get('system_id') for device in parsed_result])
 
+    def test_GET_by_parent(self):
+        factory.make_Node()
+        parent = factory.make_Node()
+        child1 = factory.make_Device(parent=parent)
+        child2 = factory.make_Device(parent=parent)
+        devices = [child1, child2]
+        response = self.client.get(reverse('devices_handler'), {
+            'op': 'by_parent'
+        })
+        parsed_result = json_load_bytes(response.content)
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [device.system_id for device in devices],
+            [device.get('system_id')
+             for device in parsed_result[parent.hostname]])
+
+    def test_GET_summary_by_parent(self):
+        factory.make_Node()
+        parent = factory.make_Node()
+        child1 = factory.make_Device(parent=parent)
+        child2 = factory.make_Device(parent=parent)
+        devices = [child1, child2]
+        response = self.client.get(reverse('devices_handler'), {
+            'op': 'by_parent',
+            'summary': True
+        })
+        parsed_result = json_load_bytes(response.content)
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [device.system_id for device in devices],
+            [device.get('system_id')
+             for device in parsed_result[parent.hostname]])
+        self.assertThat(parsed_result[parent.hostname], HasLength(2))
+
+    def test_GET_by_parent_system_id(self):
+        factory.make_Node()
+        parent = factory.make_Node()
+        child1 = factory.make_Device(parent=parent)
+        child2 = factory.make_Device(parent=parent)
+        devices = [child1, child2]
+        response = self.client.get(reverse('devices_handler'), {
+            'op': 'by_parent',
+            'by_system_id': True
+        })
+        parsed_result = json_load_bytes(response.content)
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [device.system_id for device in devices],
+            [device.get('system_id')
+             for device in parsed_result[parent.system_id]])
+
+    def test_GET_by_parent_count(self):
+        factory.make_Node()
+        parent = factory.make_Node()
+        num_devices = random.choice([3, 5, 7])
+        devices = [
+            factory.make_Device(parent=parent) for _ in range(num_devices)
+        ]
+        response = self.client.get(reverse('devices_handler'), {
+            'op': 'by_parent',
+            'by_system_id': True,
+            'count': True
+        })
+        parsed_result = json_load_bytes(response.content)
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertThat(parsed_result[parent.system_id], Equals(len(devices)))
+
     def test_read_ignores_nodes(self):
         factory.make_Node(
             status=NODE_STATUS.ALLOCATED, owner=self.user)
@@ -209,8 +277,7 @@
 
         self.assertEqual(http.client.OK, response.status_code)
         self.assertEqual(
-            [],
-            [device.get('system_id') for device in parsed_result])
+            [], [device.get('system_id') for device in parsed_result])
 
     def test_read_with_id_returns_matching_devices(self):
         # The "list" operation takes optional "id" parameters.  Only

=== modified file 'src/maasserver/api/tests/test_machines.py'
--- src/maasserver/api/tests/test_machines.py	2016-06-16 21:29:13 +0000
+++ src/maasserver/api/tests/test_machines.py	2016-06-16 21:29:13 +0000
@@ -252,6 +252,283 @@
         self.assertEqual(http.client.OK, response.status_code)
         self.expectThat(parsed_result, Equals(num_hosts))
 
+    def test_GET_by_user_lists_machines(self):
+        # The api allows for fetching the list of Machines.
+        machine1 = factory.make_Node()
+        machine2 = factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        # This device should be ignored.
+        factory.make_Device()
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_user',
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [machine2.system_id], extract_system_ids(
+                parsed_result[self.user.username]))
+
+    def test_GET_by_user_lists_machines_with_summary(self):
+        # The api allows for fetching the list of Machines.
+        machine1 = factory.make_Node()
+        machine2 = factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        # This device should be ignored.
+        factory.make_Device()
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_user',
+            'summary': True
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [machine2.system_id],
+            extract_system_ids(parsed_result[self.user.username]))
+        # Ensure each result is a summary (only contains two items)
+        self.expectThat(len(parsed_result[self.user.username][0]), Equals(2))
+
+    def test_GET_by_user_lists_machines_with_count(self):
+        # The api allows for fetching the list of Machines.
+        num_hosts = random.choice([3, 5, 7, 9])
+        for _ in range(num_hosts):
+            factory.make_Node(status=NODE_STATUS.ALLOCATED, owner=self.user)
+        factory.make_Node(status=NODE_STATUS.READY)
+        factory.make_Node(status=NODE_STATUS.READY)
+        # This device should be ignored.
+        factory.make_Device()
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_user',
+            'count': True
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.expectThat(parsed_result[self.user.username], Equals(num_hosts))
+
+    def test_GET_by_status_lists_machines(self):
+        # The api allows for fetching the list of Machines.
+        ready = factory.make_Node(status=NODE_STATUS.READY)
+        allocated = factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        broken = factory.make_Node(status=NODE_STATUS.BROKEN)
+        commissioning = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
+        deployed = factory.make_Node(
+            status=NODE_STATUS.DEPLOYED, owner=self.user)
+        disk_erasing = factory.make_Node(status=NODE_STATUS.DISK_ERASING)
+        failed_commissioning = factory.make_Node(
+            status=NODE_STATUS.FAILED_COMMISSIONING)
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_status',
+            'numeric': True
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [ready.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.READY)]))
+        self.assertItemsEqual(
+            [allocated.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.ALLOCATED)]))
+        self.assertItemsEqual(
+            [broken.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.BROKEN)]))
+        self.assertItemsEqual(
+            [commissioning.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.COMMISSIONING)]))
+        self.assertItemsEqual(
+            [deployed.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.DEPLOYED)]))
+        self.assertItemsEqual(
+            [disk_erasing.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.DISK_ERASING)]))
+        self.assertItemsEqual(
+            [failed_commissioning.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.FAILED_COMMISSIONING)]))
+
+    def test_GET_by_status_lists_machines_with_summary(self):
+        # The api allows for fetching the list of Machines.
+        ready = factory.make_Node(status=NODE_STATUS.READY)
+        allocated = factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        broken = factory.make_Node(status=NODE_STATUS.BROKEN)
+        commissioning = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
+        deployed = factory.make_Node(
+            status=NODE_STATUS.DEPLOYED, owner=self.user)
+        disk_erasing = factory.make_Node(status=NODE_STATUS.DISK_ERASING)
+        failed_commissioning = factory.make_Node(
+            status=NODE_STATUS.FAILED_COMMISSIONING)
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_status',
+            'summary': True,
+            'numeric': True,
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [ready.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.READY)]))
+        self.assertItemsEqual(
+            [allocated.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.ALLOCATED)]))
+        self.assertItemsEqual(
+            [broken.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.BROKEN)]))
+        self.assertItemsEqual(
+            [commissioning.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.COMMISSIONING)]))
+        self.assertItemsEqual(
+            [deployed.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.DEPLOYED)]))
+        self.assertItemsEqual(
+            [disk_erasing.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.DISK_ERASING)]))
+        self.assertItemsEqual(
+            [failed_commissioning.system_id], extract_system_ids(
+                parsed_result[str(NODE_STATUS.FAILED_COMMISSIONING)]))
+        # Ensure each result is a summary (only contains two items)
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.READY)][0]), Equals(2))
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.ALLOCATED)][0]), Equals(2))
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.BROKEN)][0]), Equals(2))
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.COMMISSIONING)][0]), Equals(2))
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.DEPLOYED)][0]), Equals(2))
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.DISK_ERASING)][0]), Equals(2))
+        self.expectThat(
+            len(parsed_result[str(NODE_STATUS.FAILED_COMMISSIONING)][0]),
+            Equals(2))
+
+    def test_GET_by_status_lists_machines_with_count(self):
+        factory.make_Node(status=NODE_STATUS.READY)
+        factory.make_Node(status=NODE_STATUS.READY)
+        factory.make_Node(
+            status=NODE_STATUS.ALLOCATED, owner=self.user)
+        factory.make_Node(status=NODE_STATUS.BROKEN)
+        factory.make_Node(status=NODE_STATUS.BROKEN)
+        factory.make_Node(status=NODE_STATUS.BROKEN)
+        factory.make_Node(status=NODE_STATUS.COMMISSIONING)
+        factory.make_Node(
+            status=NODE_STATUS.DEPLOYED, owner=self.user)
+        factory.make_Node(status=NODE_STATUS.DISK_ERASING)
+        factory.make_Node(
+            status=NODE_STATUS.FAILED_COMMISSIONING)
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_status',
+            'count': True,
+            'numeric': True,
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+
+        # Ensure each result is a count
+        self.expectThat(parsed_result[str(NODE_STATUS.READY)], Equals(2))
+        self.expectThat(parsed_result[str(NODE_STATUS.ALLOCATED)], Equals(1))
+        self.expectThat(parsed_result[str(NODE_STATUS.BROKEN)], Equals(3))
+        self.expectThat(
+            parsed_result[str(NODE_STATUS.COMMISSIONING)], Equals(1))
+        self.expectThat(parsed_result[str(NODE_STATUS.DEPLOYED)], Equals(1))
+        self.expectThat(
+            parsed_result[str(NODE_STATUS.DISK_ERASING)], Equals(1))
+        self.expectThat(
+            parsed_result[str(NODE_STATUS.FAILED_COMMISSIONING)], Equals(1))
+
+    def test_GET_by_status_lists_statuses_in_human_readable_format(self):
+        factory.make_Node(status=NODE_STATUS.READY)
+        factory.make_Node(status=NODE_STATUS.READY)
+        factory.make_Node(status=NODE_STATUS.BROKEN)
+        factory.make_Node(status=NODE_STATUS.BROKEN)
+        factory.make_Node(status=NODE_STATUS.BROKEN)
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_status',
+            'count': True,
+            'numeric': False,
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+
+        # Ensure each result is a count mapped to a human readable status.
+        self.expectThat(parsed_result["Ready"], Equals(2))
+        self.expectThat(parsed_result["Broken"], Equals(3))
+        self.expectThat(parsed_result["Commissioning"], Equals(0))
+
+    def test_GET_by_zone_lists_machines(self):
+        zone1 = factory.make_Zone(name="zone1")
+        zone2 = factory.make_Zone(name="zone2")
+        machinez1 = factory.make_Node(zone=zone1)
+        machinez2 = factory.make_Node(zone=zone2)
+        # This device should be ignored.
+        factory.make_Device()
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_zone',
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [machinez1.system_id], extract_system_ids(
+                parsed_result[zone1.name]))
+        self.assertItemsEqual(
+            [machinez2.system_id], extract_system_ids(
+                parsed_result[zone2.name]))
+
+    def test_GET_by_zone_lists_machines_with_summary(self):
+        zone1 = factory.make_Zone(name="zone1")
+        zone2 = factory.make_Zone(name="zone2")
+        machinez1 = factory.make_Node(zone=zone1)
+        machinez2 = factory.make_Node(zone=zone2)
+        # This device should be ignored.
+        factory.make_Device()
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_zone',
+            'summary': True
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        self.assertItemsEqual(
+            [machinez1.system_id], extract_system_ids(
+                parsed_result[zone1.name]))
+        self.assertItemsEqual(
+            [machinez2.system_id], extract_system_ids(
+                parsed_result[zone2.name]))
+        # Ensure each result is a summary (only contains two items)
+        self.expectThat(len(parsed_result[zone1.name][0]), Equals(2))
+        self.expectThat(len(parsed_result[zone2.name][0]), Equals(2))
+
+    def test_GET_by_zone_lists_machines_with_count(self):
+        zone1 = factory.make_Zone(name="zone1")
+        zone2 = factory.make_Zone(name="zone2")
+        zone1_num_machines = random.choice([3, 5, 7])
+        for _ in range(zone1_num_machines):
+            factory.make_Node(zone=zone1)
+        zone2_num_machines = random.choice([3, 5, 7])
+        for _ in range(zone2_num_machines):
+            factory.make_Node(zone=zone2)
+        # This device should be ignored.
+        factory.make_Device()
+        response = self.client.get(reverse('machines_handler'), {
+            'op': 'by_zone',
+            'count': True
+        })
+        parsed_result = json.loads(
+            response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertEqual(http.client.OK, response.status_code)
+        # Ensure each result has the correct count
+        self.expectThat(
+            parsed_result[zone1.name], Equals(zone1_num_machines))
+        self.expectThat(
+            parsed_result[zone2.name], Equals(zone2_num_machines))
+
     def test_GET_machines_issues_constant_number_of_queries(self):
         # XXX: GavinPanella 2014-10-03 bug=1377335
         self.skip("Unreliable; something is causing varying counts.")