Merge "Remind the user when sort_key is invalid"

magnum/db/sqlalchemy/api.py

@@ -95,8 +95,13 @@ def _paginate_query(model, limit=None, marker=None, sort_key=None,
     sort_keys = ['id']
     if sort_key and sort_key not in sort_keys:
         sort_keys.insert(0, sort_key)
-    query = db_utils.paginate_query(query, model, limit, sort_keys,
-                                    marker=marker, sort_dir=sort_dir)
+    try:
+        query = db_utils.paginate_query(query, model, limit, sort_keys,
+                                        marker=marker, sort_dir=sort_dir)
+    except db_exc.InvalidSortKey:
+        raise exception.InvalidParameterValue(
+            _('The sort_key value "%(key)s" is an invalid field for sorting')
+            % {'key': sort_key})
     return query.all()
 
 

magnum/tests/unit/db/test_bay.py

@@ -74,6 +74,20 @@ class DbBayTestCase(base.DbTestCase):
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
+    def test_get_bay_list_sorted(self):
+        uuids = []
+        for _ in range(5):
+            bay = utils.create_test_bay(uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(bay.uuid))
+        res = self.dbapi.get_bay_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_bay_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_bay_list_with_filters(self):
         bm1 = utils.get_test_baymodel(id=1, uuid=magnum_utils.generate_uuid())
         bm2 = utils.get_test_baymodel(id=2, uuid=magnum_utils.generate_uuid())

magnum/tests/unit/db/test_baymodel.py

@@ -41,6 +41,20 @@ class DbBaymodelTestCase(base.DbTestCase):
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
+    def test_get_baymodel_list_sorted(self):
+        uuids = []
+        for _ in range(5):
+            bm = utils.create_test_baymodel(uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(bm['uuid']))
+        res = self.dbapi.get_baymodel_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_baymodel_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_baymodel_list_with_filters(self):
         bm1 = self._create_test_baymodel(
             id=1,

magnum/tests/unit/db/test_container.py

@@ -71,6 +71,21 @@ class DbContainerTestCase(base.DbTestCase):
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
+    def test_get_container_list_sorted(self):
+        uuids = []
+        for _ in range(5):
+            container = utils.create_test_container(
+                uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(container.uuid))
+        res = self.dbapi.get_container_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_container_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_container_list_with_filters(self):
         container1 = utils.create_test_container(
             name='container-one',

magnum/tests/unit/db/test_node.py

@@ -71,6 +71,20 @@ class DbNodeTestCase(base.DbTestCase):
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
+    def test_get_node_list_sorted(self):
+        uuids = []
+        for _ in range(5):
+            node = utils.create_test_node(uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(node.uuid))
+        res = self.dbapi.get_node_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_node_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_node_list_with_filters(self):
         node1 = utils.create_test_node(
             type='virt',

magnum/tests/unit/db/test_pod.py

@@ -85,6 +85,20 @@ class DbPodTestCase(base.DbTestCase):
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
+    def test_get_pod_list_sorted(self):
+        uuids = [self.pod.uuid]
+        for _ in range(5):
+            pod = utils.create_test_pod(uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(pod.uuid))
+        res = self.dbapi.get_pod_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_pod_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_pod_list_with_filters(self):
         bay1 = utils.get_test_bay(id=11, uuid=magnum_utils.generate_uuid())
         bay2 = utils.get_test_bay(id=12, uuid=magnum_utils.generate_uuid())

magnum/tests/unit/db/test_replicationcontroller.py

@@ -83,6 +83,20 @@ class DbRCTestCase(base.DbTestCase):
         rc_uuids = [r.uuid for r in rc]
         self.assertEqual(sorted(uuids), sorted(rc_uuids))
 
+    def test_get_rc_list_sorted(self):
+        uuids = [self.rc.uuid]
+        for _ in range(5):
+            rc = utils.create_test_rc(uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(rc.uuid))
+        res = self.dbapi.get_rc_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_rc_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_rc_list_bay_not_exist(self):
         rc = self.dbapi.get_rc_list(self.context, filters={
                                     'bay_uuid': self.bay.uuid})

magnum/tests/unit/db/test_service.py

@@ -83,6 +83,21 @@ class DbServiceTestCase(base.DbTestCase):
         res_uuids = [r.uuid for r in res]
         self.assertEqual(sorted(uuids), sorted(res_uuids))
 
+    def test_get_service_list_sorted(self):
+        uuids = [self.service.uuid]
+        for _ in range(5):
+            service = utils.create_test_service(
+                uuid=magnum_utils.generate_uuid())
+            uuids.append(six.text_type(service.uuid))
+        res = self.dbapi.get_service_list(self.context, sort_key='uuid')
+        res_uuids = [r.uuid for r in res]
+        self.assertEqual(sorted(uuids), res_uuids)
+
+        self.assertRaises(exception.InvalidParameterValue,
+                          self.dbapi.get_service_list,
+                          self.context,
+                          sort_key='foo')
+
     def test_get_service_list_with_filters(self):
         bay1 = utils.get_test_bay(id=11, uuid=magnum_utils.generate_uuid())
         bay2 = utils.get_test_bay(id=12, uuid=magnum_utils.generate_uuid())

magnum/tests/unit/db/utils.py

@@ -50,6 +50,20 @@ def get_test_baymodel(**kw):
     }
 
 
+def create_test_baymodel(**kw):
+    """Create test baymodel entry in DB and return BayModel DB object.
+    Function to be used to create test BayModel objects in the database.
+    :param kw: kwargs with overriding values for baymodel's attributes.
+    :returns: Test BayModel DB object.
+    """
+    baymodel = get_test_baymodel(**kw)
+    # Let DB generate ID if it isn't specified explicitly
+    if 'id' not in kw:
+        del baymodel['id']
+    dbapi = db_api.get_instance()
+    return dbapi.create_baymodel(baymodel)
+
+
 def get_test_bay(**kw):
     return {
         'id': kw.get('id', 42),