heat tests : move GenericResource into tests directory

The resource.py GenericResource type is only used in tests, so
move it into the tests area, such that it can't accidentally be
used in the main heat codebase when we fail to import any resource
plugins..

Change-Id: I3912cc540903002a6dd5109e7ce51c7eb67ebf10

diff --git a/heat/engine/resource.py b/heat/engine/resource.py
index ee9c93f08b3254426f829b6fe4a6a42f40e43e65..f64430549df7c332ee9fb989800fe795cf11085f 100644 (file)
--- a/heat/engine/resource.py
+++ b/heat/engine/resource.py
@@ -40,7 +40,12 @@ def get_types():
 
 def get_class(resource_type):
     '''Return the Resource class for a given resource type'''
-    return _resource_classes.get(resource_type)
+    cls = _resource_classes.get(resource_type)
+    if cls is None:
+        msg = "Unknown resource Type : %s" % resource_type
+        raise exception.StackValidationFailed(message=msg)
+    else:
+        return cls
 
 
 def _register_class(resource_type, resource_class):
@@ -118,7 +123,7 @@ class Resource(object):
             return super(Resource, cls).__new__(cls)
 
         # Select the correct subclass to instantiate
-        ResourceClass = get_class(json['Type']) or GenericResource
+        ResourceClass = get_class(json['Type'])
         return ResourceClass(name, json, stack)
 
     def __init__(self, name, json_snippet, stack):
@@ -534,13 +539,3 @@ class Resource(object):
         if new_metadata:
             logger.warning("Resource %s does not implement metadata update" %
                            self.name)
-
-
-class GenericResource(Resource):
-    properties_schema = {}
-
-    def handle_create(self):
-        logger.warning('Creating generic resource (Type "%s")' % self.type())
-
-    def handle_update(self, json_snippet=None):
-        logger.warning('Updating generic resource (Type "%s")' % self.type())

diff --git a/heat/tests/generic_resource.py b/heat/tests/generic_resource.py
new file mode 100644 (file)
index 0000000..5c068a2
--- /dev/null
+++ b/heat/tests/generic_resource.py
@@ -0,0 +1,32 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from heat.engine import resource
+
+from heat.openstack.common import log as logging
+
+logger = logging.getLogger(__name__)
+
+
+class GenericResource(resource.Resource):
+    '''
+    Dummy resource for use in tests
+    '''
+    properties_schema = {}
+
+    def handle_create(self):
+        logger.warning('Creating generic resource (Type "%s")' % self.type())
+
+    def handle_update(self, json_snippet=None):
+        logger.warning('Updating generic resource (Type "%s")' % self.type())

diff --git a/heat/tests/test_event.py b/heat/tests/test_event.py
index 04e361aa63ab932732cd634332f74081e944857a..c57c76a712974b5842b251c58578047bfb191dad 100644 (file)
--- a/heat/tests/test_event.py
+++ b/heat/tests/test_event.py
@@ -20,9 +20,12 @@ import unittest
 from heat.common import context
 import heat.db as db_api
 from heat.engine import parser
+from heat.engine import resource
 from heat.engine import template
 from heat.engine import event
 
+from heat.tests import generic_resource as generic_rsrc
+
 
 tmpl = {
     'Resources': {
@@ -48,6 +51,9 @@ class EventTest(unittest.TestCase):
 
         self.m.ReplayAll()
 
+        resource._register_class('GenericResourceType',
+                                 generic_rsrc.GenericResource)
+
         self.stack = parser.Stack(self.ctx, 'event_load_test_stack',
                                   template.Template(tmpl))
         self.stack.store()

diff --git a/heat/tests/test_parser.py b/heat/tests/test_parser.py
index 0e21d1f2b929e76754b3244ce17c66e30c4430be..2f06ca5b75673f44e88b5202672324261eb1a86b 100644 (file)
--- a/heat/tests/test_parser.py
+++ b/heat/tests/test_parser.py
@@ -25,7 +25,10 @@ from heat.engine import resource
 from heat.engine import parser
 from heat.engine import parameters
 from heat.engine import template
+
 from heat.tests.utils import stack_delete_after
+from heat.tests import generic_resource as generic_rsrc
+
 import heat.db as db_api
 
 
@@ -302,6 +305,9 @@ class StackTest(unittest.TestCase):
         self.ctx.username = self.username
         self.ctx.tenant_id = 'test_tenant'
 
+        resource._register_class('GenericResourceType',
+                                 generic_rsrc.GenericResource)
+
         self.m.ReplayAll()
 
     def tearDown(self):
@@ -510,7 +516,7 @@ class StackTest(unittest.TestCase):
     def test_update_modify_ok_replace(self):
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
 
         tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType',
                                             'Properties': {'Foo': 'abc'}}}}
@@ -527,8 +533,8 @@ class StackTest(unittest.TestCase):
         updated_stack = parser.Stack(self.ctx, 'updated_stack',
                                      template.Template(tmpl2))
         # patch in a dummy handle_update
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
         self.m.ReplayAll()
@@ -542,7 +548,7 @@ class StackTest(unittest.TestCase):
     def test_update_modify_update_failed(self):
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
 
         tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType',
                                             'Properties': {'Foo': 'abc'}}}}
@@ -561,8 +567,8 @@ class StackTest(unittest.TestCase):
                                      template.Template(tmpl2))
 
         # patch in a dummy handle_update
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_FAILED)
         self.m.ReplayAll()
@@ -575,7 +581,7 @@ class StackTest(unittest.TestCase):
     def test_update_modify_replace_failed_delete(self):
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
 
         tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType',
                                             'Properties': {'Foo': 'abc'}}}}
@@ -594,8 +600,8 @@ class StackTest(unittest.TestCase):
                                      template.Template(tmpl2))
 
         # patch in a dummy handle_update
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
@@ -614,7 +620,7 @@ class StackTest(unittest.TestCase):
     def test_update_modify_replace_failed_create(self):
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
 
         tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType',
                                             'Properties': {'Foo': 'abc'}}}}
@@ -633,14 +639,14 @@ class StackTest(unittest.TestCase):
                                      template.Template(tmpl2))
 
         # patch in a dummy handle_update
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
         # patch in a dummy handle_create making the replace fail creating
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_create')
-        resource.GenericResource.handle_create().AndRaise(Exception)
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
         self.m.ReplayAll()
 
         self.stack.update(updated_stack)
@@ -651,7 +657,7 @@ class StackTest(unittest.TestCase):
     def test_update_rollback(self):
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
 
         tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType',
                                             'Properties': {'Foo': 'abc'}}}}
@@ -671,19 +677,19 @@ class StackTest(unittest.TestCase):
 
         # There will be two calls to handle_update, one for the new template
         # then another (with the initial template) for rollback
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             tmpl['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
         # patch in a dummy handle_create making the replace fail when creating
         # the replacement resource, but succeed the second call (rollback)
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_create')
-        resource.GenericResource.handle_create().AndRaise(Exception)
-        resource.GenericResource.handle_create().AndReturn(None)
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
+        generic_rsrc.GenericResource.handle_create().AndReturn(None)
         self.m.ReplayAll()
 
         self.stack.update(updated_stack)
@@ -695,7 +701,7 @@ class StackTest(unittest.TestCase):
     def test_update_rollback_fail(self):
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
 
         tmpl = {'Resources': {'AResource': {'Type': 'GenericResourceType',
                                             'Properties': {'Foo': 'abc'}}}}
@@ -715,19 +721,19 @@ class StackTest(unittest.TestCase):
 
         # There will be two calls to handle_update, one for the new template
         # then another (with the initial template) for rollback
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             tmpl['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
         # patch in a dummy handle_create making the replace fail when creating
         # the replacement resource, and again on the second call (rollback)
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_create')
-        resource.GenericResource.handle_create().AndRaise(Exception)
-        resource.GenericResource.handle_create().AndRaise(Exception)
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
         self.m.ReplayAll()
 
         self.stack.update(updated_stack)
@@ -754,8 +760,8 @@ class StackTest(unittest.TestCase):
 
         # patch in a dummy handle_create making the replace fail when creating
         # the replacement resource, and succeed on the second call (rollback)
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_create')
-        resource.GenericResource.handle_create().AndRaise(Exception)
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
         self.m.ReplayAll()
 
         self.stack.update(updated_stack)
@@ -802,7 +808,7 @@ class StackTest(unittest.TestCase):
         '''
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
         tmpl = {'Resources': {
                 'AResource': {'Type': 'GenericResourceType',
                               'Properties': {'Foo': 'abc'}},
@@ -825,21 +831,21 @@ class StackTest(unittest.TestCase):
         self.assertEqual(self.stack['BResource'].properties['Foo'],
                          'AResource')
 
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        resource.GenericResource.handle_update(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
         br2_snip = {'Type': 'GenericResourceType',
                     'Properties': {'Foo': 'inst-007'}}
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             br2_snip).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
-        self.m.StubOutWithMock(resource.GenericResource, 'FnGetRefId')
-        resource.GenericResource.FnGetRefId().AndReturn(
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'FnGetRefId')
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'AResource')
-        resource.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
             'inst-007')
         self.m.ReplayAll()
 
@@ -860,7 +866,7 @@ class StackTest(unittest.TestCase):
         '''
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
         tmpl = {'Resources': {
                 'AResource': {'Type': 'GenericResourceType',
                               'Properties': {'Foo': 'abc'}},
@@ -884,27 +890,27 @@ class StackTest(unittest.TestCase):
         self.assertEqual(self.stack['BResource'].properties['Foo'],
                          'AResource')
 
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        self.m.StubOutWithMock(resource.GenericResource, 'FnGetRefId')
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_create')
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'FnGetRefId')
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
 
         # mocks for first (failed update)
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'AResource')
 
         # mock to make the replace fail when creating the replacement resource
-        resource.GenericResource.handle_create().AndRaise(Exception)
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
 
         # mocks for second rollback update
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             tmpl['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
-        resource.GenericResource.handle_create().AndReturn(None)
-        resource.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
+        generic_rsrc.GenericResource.handle_create().AndReturn(None)
+        generic_rsrc.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
             'AResource')
 
         self.m.ReplayAll()
@@ -927,7 +933,7 @@ class StackTest(unittest.TestCase):
         '''
         # patch in a dummy property schema for GenericResource
         dummy_schema = {'Foo': {'Type': 'String'}}
-        resource.GenericResource.properties_schema = dummy_schema
+        generic_rsrc.GenericResource.properties_schema = dummy_schema
         tmpl = {'Resources': {
                 'AResource': {'Type': 'GenericResourceType',
                               'Properties': {'Foo': 'abc'}},
@@ -951,67 +957,67 @@ class StackTest(unittest.TestCase):
         self.assertEqual(self.stack['BResource'].properties['Foo'],
                          'AResource')
 
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_update')
-        self.m.StubOutWithMock(resource.GenericResource, 'FnGetRefId')
-        self.m.StubOutWithMock(resource.GenericResource, 'handle_create')
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_update')
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'FnGetRefId')
+        self.m.StubOutWithMock(generic_rsrc.GenericResource, 'handle_create')
 
         # mocks for first and second (failed update)
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             tmpl2['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
         br2_snip = {'Type': 'GenericResourceType',
                     'Properties': {'Foo': 'inst-007'}}
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             br2_snip).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'AResource')
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
         # self.state_set(self.UPDATE_IN_PROGRESS)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
         # self.state_set(self.DELETE_IN_PROGRESS)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
         # self.state_set(self.DELETE_COMPLETE)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
         # self.properties.validate()
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
         # self.state_set(self.CREATE_IN_PROGRESS)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
 
         # mock to make the replace fail when creating the second
         # replacement resource
-        resource.GenericResource.handle_create().AndReturn(None)
-        resource.GenericResource.handle_create().AndRaise(Exception)
+        generic_rsrc.GenericResource.handle_create().AndReturn(None)
+        generic_rsrc.GenericResource.handle_create().AndRaise(Exception)
 
         # mocks for second rollback update
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             tmpl['Resources']['AResource']).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
         br2_snip = {'Type': 'GenericResourceType',
                     'Properties': {'Foo': 'AResource'}}
-        resource.GenericResource.handle_update(
+        generic_rsrc.GenericResource.handle_update(
             br2_snip).AndReturn(
                 resource.Resource.UPDATE_REPLACE)
 
         # self.state_set(self.DELETE_IN_PROGRESS)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
         # self.state_set(self.DELETE_IN_PROGRESS)
-        resource.GenericResource.FnGetRefId().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().AndReturn(
             'inst-007')
 
-        resource.GenericResource.handle_create().AndReturn(None)
-        resource.GenericResource.handle_create().AndReturn(None)
+        generic_rsrc.GenericResource.handle_create().AndReturn(None)
+        generic_rsrc.GenericResource.handle_create().AndReturn(None)
 
         # reverting to AResource
-        resource.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
+        generic_rsrc.GenericResource.FnGetRefId().MultipleTimes().AndReturn(
             'AResource')
 
         self.m.ReplayAll()

diff --git a/heat/tests/test_resource.py b/heat/tests/test_resource.py
index 830ec68345cd6880536f84f3385fa6dcbe7b4abc..19f39139c4967764d777b0233c874479e70c4669 100644 (file)
--- a/heat/tests/test_resource.py
+++ b/heat/tests/test_resource.py
@@ -18,51 +18,78 @@ from nose.plugins.attrib import attr
 import mox
 
 from heat.common import context
+from heat.common import exception
 from heat.engine import parser
 from heat.engine import resource
 from heat.openstack.common import uuidutils
 
+from heat.tests import generic_resource as generic_rsrc
+
 
 @attr(tag=['unit', 'resource'])
 @attr(speed='fast')
 class ResourceTest(unittest.TestCase):
     def setUp(self):
+        self.m = mox.Mox()
         self.stack = parser.Stack(None, 'test_stack', parser.Template({}),
                                   stack_id=uuidutils.generate_uuid())
 
+        resource._register_class('GenericResourceType',
+                                 generic_rsrc.GenericResource)
+
+    def tearDown(self):
+        self.m.UnsetStubs()
+
+    def test_get_class_ok(self):
+        cls = resource.get_class('GenericResourceType')
+        self.assertEqual(cls, generic_rsrc.GenericResource)
+
+    def test_get_class_noexist(self):
+        self.assertRaises(exception.StackValidationFailed, resource.get_class,
+                          'NoExistResourceType')
+
+    def test_resource_new_ok(self):
+        snippet = {'Type': 'GenericResourceType'}
+        res = resource.Resource('aresource', snippet, self.stack)
+
+    def test_resource_new_err(self):
+        snippet = {'Type': 'NoExistResourceType'}
+        self.assertRaises(exception.StackValidationFailed,
+                          resource.Resource, 'aresource', snippet, self.stack)
+
     def test_state_defaults(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_res_def', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_res_def', tmpl, self.stack)
         self.assertEqual(res.state, None)
         self.assertEqual(res.state_description, '')
 
     def test_state(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.state_set('bar')
         self.assertEqual(res.state, 'bar')
 
     def test_state_description(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.state_set('blarg', 'wibble')
         self.assertEqual(res.state_description, 'wibble')
 
     def test_type(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         self.assertEqual(res.type(), 'Foo')
 
     def test_created_time(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_res_new', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_res_new', tmpl, self.stack)
         self.assertEqual(res.created_time, None)
         res._store()
         self.assertNotEqual(res.created_time, None)
 
     def test_updated_time(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_res_upd', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_res_upd', tmpl, self.stack)
         res._store()
         stored_time = res.updated_time
         res.state_set(res.CREATE_IN_PROGRESS, 'testing')
@@ -74,7 +101,7 @@ class ResourceTest(unittest.TestCase):
             'Type': 'Foo',
             'foo': {'Fn::Join': [' ', ['bar', 'baz', 'quux']]}
         }
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
 
         parsed_tmpl = res.parsed_template()
         self.assertEqual(parsed_tmpl['Type'], 'Foo')
@@ -85,13 +112,13 @@ class ResourceTest(unittest.TestCase):
 
     def test_parsed_template_default(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         self.assertEqual(res.parsed_template('foo'), {})
         self.assertEqual(res.parsed_template('foo', 'bar'), 'bar')
 
     def test_metadata_default(self):
         tmpl = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         self.assertEqual(res.metadata, {})
 
     def test_equals_different_stacks(self):
@@ -100,9 +127,9 @@ class ResourceTest(unittest.TestCase):
         tmpl3 = {'Type': 'Bar'}
         stack2 = parser.Stack(None, 'test_stack', parser.Template({}),
                               stack_id=-1)
-        res1 = resource.GenericResource('test_resource', tmpl1, self.stack)
-        res2 = resource.GenericResource('test_resource', tmpl2, stack2)
-        res3 = resource.GenericResource('test_resource2', tmpl3, stack2)
+        res1 = generic_rsrc.GenericResource('test_resource', tmpl1, self.stack)
+        res2 = generic_rsrc.GenericResource('test_resource', tmpl2, stack2)
+        res3 = generic_rsrc.GenericResource('test_resource2', tmpl3, stack2)
 
         self.assertEqual(res1, res2)
         self.assertNotEqual(res1, res3)
@@ -110,29 +137,31 @@ class ResourceTest(unittest.TestCase):
     def test_equals_names(self):
         tmpl1 = {'Type': 'Foo'}
         tmpl2 = {'Type': 'Foo'}
-        res1 = resource.GenericResource('test_resource1', tmpl1, self.stack)
-        res2 = resource.GenericResource('test_resource2', tmpl2, self.stack)
+        res1 = generic_rsrc.GenericResource('test_resource1',
+                                            tmpl1, self.stack)
+        res2 = generic_rsrc.GenericResource('test_resource2', tmpl2,
+                                            self.stack)
 
         self.assertNotEqual(res1, res2)
 
     def test_update_template_diff_empty(self):
         tmpl = {'Type': 'Foo'}
         update_snippet = {}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         self.assertRaises(NotImplementedError, res.update_template_diff,
                           update_snippet)
 
     def test_update_template_diff_changed_notallowed(self):
         tmpl = {'Type': 'Foo'}
         update_snippet = {'Type': 'Bar'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         self.assertRaises(NotImplementedError, res.update_template_diff,
                           update_snippet)
 
     def test_update_template_diff_changed_modified(self):
         tmpl = {'Type': 'Foo', 'Metadata': {'foo': 123}}
         update_snippet = {'Type': 'Foo', 'Metadata': {'foo': 456}}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_keys = ('Metadata',)
         diff = res.update_template_diff(json_snippet=update_snippet)
         self.assertEqual(diff, {'Metadata': {'foo': 456}})
@@ -140,7 +169,7 @@ class ResourceTest(unittest.TestCase):
     def test_update_template_diff_changed_add(self):
         tmpl = {'Type': 'Foo'}
         update_snippet = {'Type': 'Foo', 'Metadata': {'foo': 123}}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_keys = ('Metadata',)
         diff = res.update_template_diff(json_snippet=update_snippet)
         self.assertEqual(diff, {'Metadata': {'foo': 123}})
@@ -148,7 +177,7 @@ class ResourceTest(unittest.TestCase):
     def test_update_template_diff_changed_remove(self):
         tmpl = {'Type': 'Foo', 'Metadata': {'foo': 123}}
         update_snippet = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_keys = ('Metadata',)
         diff = res.update_template_diff(json_snippet=update_snippet)
         self.assertEqual(diff, {'Metadata': None})
@@ -156,14 +185,14 @@ class ResourceTest(unittest.TestCase):
     def test_update_template_diff_properties_none(self):
         tmpl = {'Type': 'Foo'}
         update_snippet = {'Type': 'Foo'}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         diff = res.update_template_diff_properties(json_snippet=update_snippet)
         self.assertEqual(diff, {})
 
     def test_update_template_diff_properties_added(self):
         tmpl = {'Type': 'Foo'}
         update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 123}}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_properties = ('Bar',)
         diff = res.update_template_diff_properties(json_snippet=update_snippet)
         self.assertEqual(diff, {'Bar': 123})
@@ -171,7 +200,7 @@ class ResourceTest(unittest.TestCase):
     def test_update_template_diff_properties_removed(self):
         tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}}
         update_snippet = {'Type': 'Foo', 'Properties': {}}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_properties = ('Bar',)
         diff = res.update_template_diff_properties(json_snippet=update_snippet)
         self.assertEqual(diff, {'Bar': None})
@@ -179,7 +208,7 @@ class ResourceTest(unittest.TestCase):
     def test_update_template_diff_properties_changed(self):
         tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}}
         update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 456}}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_properties = ('Bar',)
         diff = res.update_template_diff_properties(json_snippet=update_snippet)
         self.assertEqual(diff, {'Bar': 456})
@@ -187,7 +216,7 @@ class ResourceTest(unittest.TestCase):
     def test_update_template_diff_properties_notallowed(self):
         tmpl = {'Type': 'Foo', 'Properties': {'Bar': 123}}
         update_snippet = {'Type': 'Foo', 'Properties': {'Bar': 456}}
-        res = resource.GenericResource('test_resource', tmpl, self.stack)
+        res = generic_rsrc.GenericResource('test_resource', tmpl, self.stack)
         res.update_allowed_properties = ('Cat',)
         self.assertRaises(NotImplementedError,
                           res.update_template_diff_properties,
@@ -208,8 +237,8 @@ class MetadataTest(unittest.TestCase):
         ctx.username = 'metadata_test_user'
         self.stack = parser.Stack(ctx, 'test_stack', parser.Template({}))
         self.stack.store()
-        self.res = resource.GenericResource('metadata_resource',
-                                            tmpl, self.stack)
+        self.res = generic_rsrc.GenericResource('metadata_resource',
+                                                tmpl, self.stack)
         self.res.create()
 
     def tearDown(self):