Raise NotFound in software_config_get/software_deployment_get

This change results in the required behaviour of show_software_config
and show_software_deployment which will now also raising NotFound if
no entity with the ID was found.

partial blueprint hot-software-config-rest

Change-Id: I297a4a2a0592f1b60fe9bef0e097abe73cf57d75

heat/db/sqlalchemy/api.py

@@ -616,18 +616,16 @@ def software_config_get(context, config_id):
     result = model_query(context, models.SoftwareConfig).get(config_id)
     if (result is not None and context is not None and
             result.tenant != context.tenant_id):
-        return None
+        result = None
 
+    if not result:
+        raise exception.NotFound(_('Software config with id %s not found') %
+                                 config_id)
     return result
 
 
 def software_config_delete(context, config_id):
     config = software_config_get(context, config_id)
-    if not config:
-        raise exception.NotFound(
-            _('Attempt to delete software config with '
-              '%(id)s %(msg)s') % {'id': config_id,
-                                   'msg': 'that does not exist'})
     session = Session.object_session(config)
     session.delete(config)
     session.flush()
@@ -644,8 +642,11 @@ def software_deployment_get(context, deployment_id):
     result = model_query(context, models.SoftwareDeployment).get(deployment_id)
     if (result is not None and context is not None and
             result.tenant != context.tenant_id):
-        return None
+        result = None
 
+    if not result:
+        raise exception.NotFound(_('Deployment with id %s not found') %
+                                 deployment_id)
     return result
 
 
@@ -660,13 +661,6 @@ def software_deployment_get_all(context, server_id=None):
 
 def software_deployment_update(context, deployment_id, values):
     deployment = software_deployment_get(context, deployment_id)
-
-    if not deployment:
-        raise exception.NotFound(
-            _('Attempt to update software deployment with '
-              'id: %(id)s %(msg)s') % {'id': deployment_id,
-                                       'msg': 'that does not exist'})
-
     deployment.update(values)
     deployment.save(_session(context))
     return deployment
@@ -674,11 +668,6 @@ def software_deployment_update(context, deployment_id, values):
 
 def software_deployment_delete(context, deployment_id):
     deployment = software_deployment_get(context, deployment_id)
-    if not deployment:
-        raise exception.NotFound(
-            _('Attempt to delete software deployment '
-              'with %(id)s %(msg)s') % {'id': deployment_id,
-                                        'msg': 'that does not exist'})
     session = Session.object_session(deployment)
     session.delete(deployment)
     session.flush()

heat/tests/test_engine_service.py

@@ -2566,8 +2566,12 @@ class SoftwareConfigServiceTest(HeatTestCase):
 
     def test_show_software_config(self):
         config_id = str(uuid.uuid4())
-        self.assertIsNone(
-            self.engine.show_software_config(self.ctx, config_id))
+
+        e = self.assertRaises(rpc_common.ClientException,
+                              self.engine.show_software_config,
+                              self.ctx, config_id)
+        self.assertIs(e._exc_info[0], exception.NotFound)
+
         config = self._create_software_config()
         config_id = config['id']
         self.assertEqual(
@@ -2602,8 +2606,11 @@ class SoftwareConfigServiceTest(HeatTestCase):
         self.assertIsNotNone(config)
         config_id = config['id']
         self.engine.delete_software_config(self.ctx, config_id)
-        config = self.engine.show_software_config(self.ctx, config_id)
-        self.assertIsNone(config)
+
+        e = self.assertRaises(rpc_common.ClientException,
+                              self.engine.show_software_config,
+                              self.ctx, config_id)
+        self.assertIs(e._exc_info[0], exception.NotFound)
 
     def _create_software_deployment(self, config_id=None, input_values={},
                                     signal_id=None, action='INIT',
@@ -2631,8 +2638,11 @@ class SoftwareConfigServiceTest(HeatTestCase):
 
     def test_show_software_deployment(self):
         deployment_id = str(uuid.uuid4())
-        self.assertIsNone(
-            self.engine.show_software_deployment(self.ctx, deployment_id))
+        e = self.assertRaises(rpc_common.ClientException,
+                              self.engine.show_software_deployment,
+                              self.ctx, deployment_id)
+        self.assertIs(e._exc_info[0], exception.NotFound)
+
         deployment = self._create_software_deployment()
         self.assertIsNotNone(deployment)
         deployment_id = deployment['id']

heat/tests/test_sqlalchemy_api.py

@@ -617,8 +617,11 @@ class SqlAlchemyTest(HeatTestCase):
         self.assertEqual(tenant_id, config.tenant)
 
     def test_software_config_get(self):
-        self.assertIsNone(
-            db_api.software_config_get(self.ctx, str(uuid.uuid4())))
+        self.assertRaises(
+            exception.NotFound,
+            db_api.software_config_get,
+            self.ctx,
+            str(uuid.uuid4()))
         io = {'inputs': [{'name': 'foo'}, {'name': 'bar'}],
               'outputs': [{'name': 'result'}]}
         tenant_id = self.ctx.tenant_id
@@ -640,8 +643,11 @@ class SqlAlchemyTest(HeatTestCase):
         self.assertEqual(conf, config.config)
         self.assertEqual(io, config.io)
         self.ctx.tenant_id = None
-        config = db_api.software_config_get(self.ctx, config_id)
-        self.assertIsNone(config)
+        self.assertRaises(
+            exception.NotFound,
+            db_api.software_config_get,
+            self.ctx,
+            config_id)
 
     def test_software_config_delete(self):
         tenant_id = self.ctx.tenant_id
@@ -650,8 +656,13 @@ class SqlAlchemyTest(HeatTestCase):
                        'tenant': tenant_id})
         config_id = config.id
         db_api.software_config_delete(self.ctx, config_id)
-        config = db_api.software_config_get(self.ctx, config_id)
-        self.assertIsNone(config)
+        err = self.assertRaises(
+            exception.NotFound,
+            db_api.software_config_get,
+            self.ctx,
+            config_id)
+        self.assertIn(config_id, str(err))
+
         err = self.assertRaises(
             exception.NotFound, db_api.software_config_delete,
             self.ctx, config_id)
@@ -678,8 +689,11 @@ class SqlAlchemyTest(HeatTestCase):
         self.assertEqual(values['tenant'], deployment.tenant)
 
     def test_software_deployment_get(self):
-        self.assertIsNone(
-            db_api.software_deployment_get(self.ctx, str(uuid.uuid4())))
+        self.assertRaises(
+            exception.NotFound,
+            db_api.software_deployment_get,
+            self.ctx,
+            str(uuid.uuid4()))
         values = self._deployment_values()
         deployment = db_api.software_deployment_create(self.ctx, values)
         self.assertIsNotNone(deployment)
@@ -691,8 +705,11 @@ class SqlAlchemyTest(HeatTestCase):
         self.assertEqual(values['server_id'], deployment.server_id)
         self.assertEqual(values['input_values'], deployment.input_values)
         self.ctx.tenant_id = None
-        deployment = db_api.software_deployment_get(self.ctx, deployment_id)
-        self.assertIsNone(deployment)
+        self.assertRaises(
+            exception.NotFound,
+            db_api.software_deployment_get,
+            self.ctx,
+            deployment_id)
 
     def test_software_deployment_get_all(self):
         self.assertEqual([], db_api.software_deployment_get_all(self.ctx))
@@ -737,8 +754,14 @@ class SqlAlchemyTest(HeatTestCase):
         deployment = db_api.software_deployment_get(self.ctx, deployment_id)
         self.assertIsNotNone(deployment)
         db_api.software_deployment_delete(self.ctx, deployment_id)
-        deployment = db_api.software_deployment_get(self.ctx, deployment_id)
-        self.assertIsNone(deployment)
+
+        err = self.assertRaises(
+            exception.NotFound,
+            db_api.software_deployment_get,
+            self.ctx,
+            deployment_id)
+
+        self.assertIn(deployment_id, str(err))
 
 
 def create_raw_template(context, **kwargs):