def test_get_all_flavors_sorted_list_sort(self):
        # Test default sort
        all_flavors = flavors.get_all_flavors_sorted_list()
        self.assertEqual(DEFAULT_FLAVORS, all_flavors)

        # Test sorted by name
        all_flavors = flavors.get_all_flavors_sorted_list(sort_key='name')
        expected = sorted(DEFAULT_FLAVORS, key=lambda item: item['name'])
        self.assertEqual(expected, all_flavors)

    def test_get_all_flavors_sorted_list_marker(self):
        all_flavors = flavors.get_all_flavors_sorted_list()

        # Set the 3rd result as the marker
        marker_flavorid = all_flavors[2]["flavorid"]
        marked_flavors = flavors.get_all_flavors_sorted_list(marker=marker_flavorid)
        # We expect everything /after/ the 3rd result
        expected_results = all_flavors[3:]
        self.assertEqual(expected_results, marked_flavors)

    def test_get_all_flavors_sorted_list_marker(self):
        """Check results can be returned after marker"""
        all_flavors = flavors.get_all_flavors_sorted_list()

        # Set the 3rd result as the marker
        marker_flavorid = all_flavors[2]['id']
        marked_flavors = flavors.get_all_flavors_sorted_list(
            marker=marker_flavorid)
        # We expect everything /after/ the 3rd result
        expected_results = all_flavors[3:]
        self.assertEqual(expected_results, marked_flavors)

    def test_get_all_flavors_sorted_list_marker(self):
        all_flavors = flavors.get_all_flavors_sorted_list()

        # Set the 3rd result as the marker
        marker_flavorid = all_flavors[2].flavorid
        marked_flavors = flavors.get_all_flavors_sorted_list(marker=marker_flavorid)
        # We expect everything /after/ the 3rd result
        expected_results = all_flavors[3:]
        self.assertEqual(len(expected_results), len(marked_flavors))
        for i in range(len(marked_flavors)):
            f = marked_flavors[i]
            self.assertIsInstance(f, objects.Flavor)
            self.assertEqual(expected_results[i].flavorid, f.flavorid)

    def test_get_all_flavors_sorted_list_sort(self):
        # Test default sort
        all_flavors = flavors.get_all_flavors_sorted_list()
        self.assertEqual(len(DEFAULT_FLAVORS), len(all_flavors))
        for i in range(len(all_flavors)):
            f = all_flavors[i]
            self.assertIsInstance(f, objects.Flavor)
            self.assertEqual(DEFAULT_FLAVORS[i]['flavorid'], f.flavorid)

        # Test sorted by name
        all_flavors = flavors.get_all_flavors_sorted_list(sort_key='name')
        expected = sorted(DEFAULT_FLAVORS, key=lambda item: item['name'])
        self.assertEqual(len(expected), len(all_flavors))
        for i in range(len(all_flavors)):
            f = all_flavors[i]
            self.assertIsInstance(f, objects.Flavor)
            self.assertEqual(expected[i]['flavorid'], f.flavorid)

    def _get_flavors(self, req):
        """Helper function that returns a list of flavor dicts."""
        filters = {}
        sort_key = req.params.get('sort_key') or 'flavorid'
        sort_dir = req.params.get('sort_dir') or 'asc'
        limit = req.params.get('limit') or None
        marker = req.params.get('marker') or None

        context = req.environ['nova.context']
        if context.is_admin:
            # Only admin has query access to all flavor types
            filters['is_public'] = self._parse_is_public(
                    req.params.get('is_public', None))
        else:
            filters['is_public'] = True
            filters['disabled'] = False

        if 'min_ram' in req.params:
            try:
                filters['min_memory_mb'] = int(req.params['min_ram'])
            except ValueError:
                msg = _('Invalid min_ram filter [%s]') % req.params['min_ram']
                raise webob.exc.HTTPBadRequest(explanation=msg)

        if 'min_disk' in req.params:
            try:
                filters['min_root_gb'] = int(req.params['min_disk'])
            except ValueError:
                msg = (_('Invalid min_disk filter [%s]') %
                       req.params['min_disk'])
                raise webob.exc.HTTPBadRequest(explanation=msg)

        try:
            limited_flavors = flavors.get_all_flavors_sorted_list(context,
                filters=filters, sort_key=sort_key, sort_dir=sort_dir,
                limit=limit, marker=marker)
        except exception.MarkerNotFound:
            msg = _('marker [%s] not found') % marker
            raise webob.exc.HTTPBadRequest(explanation=msg)

        return limited_flavors

    def _get_flavors(self, req):
        """Helper function that returns a list of flavor dicts."""
        filters = {}
        sort_key = req.params.get("sort_key") or "flavorid"
        sort_dir = req.params.get("sort_dir") or "asc"
        limit = req.params.get("limit") or None
        marker = req.params.get("marker") or None

        context = req.environ["nova.context"]
        if context.is_admin:
            # Only admin has query access to all flavor types
            filters["is_public"] = self._parse_is_public(req.params.get("is_public", None))
        else:
            filters["is_public"] = True
            filters["disabled"] = False

        if "min_ram" in req.params:
            try:
                filters["min_memory_mb"] = int(req.params["min_ram"])
            except ValueError:
                msg = _("Invalid min_ram filter [%s]") % req.params["min_ram"]
                raise webob.exc.HTTPBadRequest(explanation=msg)

        if "min_disk" in req.params:
            try:
                filters["min_root_gb"] = int(req.params["min_disk"])
            except ValueError:
                msg = _("Invalid min_disk filter [%s]") % req.params["min_disk"]
                raise webob.exc.HTTPBadRequest(explanation=msg)

        try:
            limited_flavors = flavors.get_all_flavors_sorted_list(
                context, filters=filters, sort_key=sort_key, sort_dir=sort_dir, limit=limit, marker=marker
            )
        except exception.MarkerNotFound:
            msg = _("marker [%s] not found") % marker
            raise webob.exc.HTTPBadRequest(explanation=msg)

        return limited_flavors

 def test_get_all_flavors_sorted_list_limit(self):
     """Check a limit can be applied to
     flavors.get_all_flavors_sorted_list.
     """
     limited_flavors = flavors.get_all_flavors_sorted_list(limit=2)
     self.assertEqual(2, len(limited_flavors))

 def test_get_all_flavors_sorted_list_limit(self):
     limited_flavors = flavors.get_all_flavors_sorted_list(limit=2)
     self.assertEqual(2, len(limited_flavors))