Added missing test tags to compute tests

Change-Id: I13d3042da668970947bcf0f59ac7d5c738f7ef1c

test_repo/compute/admin/test_admin_authorization.py

@@ -31,67 +31,80 @@ class AdminAuthorizationTest(ComputeFixture):
     def tearDownClass(cls):
         super(AdminAuthorizationTest, cls).tearDownClass()
 
+    @tags(type='negative', net='no')
     def test_lock_server_fails_as_user(self):
         """A lock request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.lock_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_unlock_server_fails_as_user(self):
         """An unlock request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.unlock_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_migrate_server_fails_as_user(self):
         """A migrate request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.migrate_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_live_migrate_server_fails_as_user(self):
         """A live migrate request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.live_migrate_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_stop_server_fails_as_user(self):
         """A stop request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.stop_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_start_server_fails_as_user(self):
         """A start request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.start_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_suspend_server_fails_as_user(self):
         """A suspend request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.suspend_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_resume_server_fails_as_user(self):
         """A resume request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.resume_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_pause_server_fails_as_user(self):
         """A pause request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.pause_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_unpause_server_fails_as_user(self):
         """An unpause request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.unpause_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_reset_server_state_fails_as_user(self):
         """A reset state request should fail when not made by an admin"""
         with self.assertRaises(BadRequest):
             self.servers_client.reset_state(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_create_flavor_fails_as_user(self):
         with self.assertRaises(ItemNotFound):
             self.flavors_client.create_flavor(
                 name='test555', ram='128', vcpus='1', disk='10', id='100',
                 is_public=True)
 
+    @tags(type='negative', net='no')
     def test_delete_flavor_fails_as_user(self):
         with self.assertRaises(ItemNotFound):
             self.flavors_client.delete_flavor(self.flavor_ref)

test_repo/compute/admin/test_create_flavor.py

@@ -38,12 +38,14 @@ class CreateFlavorsAdminTest(ComputeAdminFixture):
         super(CreateFlavorsAdminTest, cls).tearDownClass()
         cls.admin_flavors_client.delete_flavor(cls.flavor_id)
 
+    @tags(type='positive', net='no')
     def test_create_server_from_new_flavor(self):
         resp = self.server_behaviors.create_active_server(
             flavor_ref=self.flavor_id)
         server = resp.entity
         self.resources.add(server.id, self.servers_client.delete_server)
 
+    @tags(type='positive', net='no')
     def test_create_flavor_with_duplicate(self):
         with self.assertRaises(ActionInProgress):
             self.admin_flavors_client.create_flavor(

test_repo/compute/admin/test_flavors_admin.py

@@ -27,6 +27,7 @@ class FlavorsAdminTest(ComputeAdminFixture):
     def tearDownClass(cls):
         super(FlavorsAdminTest, cls).tearDownClass()
 
+    @tags(type='positive', net='no')
     def test_create_delete_flavors(self):
         self.admin_flavors_client.create_flavor(name='test2', ram='128', vcpus='1',
                                                 disk='10', id='99', is_public=True)

test_repo/compute/extensions/keypairs/test_keypairs.py

@@ -14,11 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from cafe.drivers.unittest.decorators import tags
 from test_repo.compute.fixtures import ComputeFixture
 
 
 class KeypairsTest(ComputeFixture):
 
+    @tags(type='positive', net='no')
     def test_create_delete_keypair(self):
         resp = self.keypairs_client.create_keypair('test3')
         self.assertEqual(resp.status_code, 200)

test_repo/compute/extensions/security_groups/test_security_groups.py

@@ -14,11 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from cafe.drivers.unittest.decorators import tags
 from test_repo.compute.fixtures import ComputeFixture
 
 
 class SecurityGroupTest(ComputeFixture):
 
+    @tags(type='positive', net='no')
     def test_create_delete_security_group(self):
         resp = self.sec_groups_client.create_security_group(name='test',
                                                             description='test group')

test_repo/compute/functional/flavors/test_flavors.py

@@ -21,6 +21,7 @@ from test_repo.compute.fixtures import ComputeFixture
 
 class FlavorsTest(ComputeFixture):
 
+    @tags(type='smoke', net='no')
     def test_list_flavors(self):
         """ List of all flavors should contain the expected flavor """
         response = self.flavors_client.list_flavors()
@@ -33,6 +34,7 @@ class FlavorsTest(ComputeFixture):
                 return
         self.fail("The expected flavor: %s not found in the flavor list." % flavor.id)
 
+    @tags(type='smoke', net='no')
     def test_list_flavors_with_detail(self):
         """ Detailed list of all flavors should contain the expected flavor """
         response = self.flavors_client.list_flavors_with_detail()
@@ -42,12 +44,14 @@ class FlavorsTest(ComputeFixture):
         flavor = response.entity
         self.assertIn(flavor, flavors, "The expected flavor: %s not found in the flavor list." % flavor.id)
 
+    @tags(type='smoke', net='no')
     def test_get_flavor(self):
         """ The expected flavor details should be returned """
         response = self.flavors_client.get_flavor_details(self.flavor_ref)
         flavor = response.entity
         self.assertEqual(self.flavor_ref, flavor.id, "Could not retrieve the expected flavor.")
 
+    @tags(type='negative', net='no')
     def test_get_non_existent_flavor(self):
         """flavor details are not returned for non existent flavors"""
         try:
@@ -56,6 +60,7 @@ class FlavorsTest(ComputeFixture):
         except ItemNotFound:
             pass
 
+    @tags(type='positive', net='no')
     def test_list_flavors_limit_results(self):
         """Only the expected number of flavors should be returned"""
         response = self.flavors_client.list_flavors(limit=1)
@@ -63,6 +68,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(1, len(flavors),
                          "The length of flavor list was %s instead of 1" % len(flavors))
 
+    @tags(type='positive', net='no')
     def test_list_flavors_detailed_limit_results(self):
         """Only the expected number of flavors (detailed) should be returned"""
         response = self.flavors_client.list_flavors_with_detail(limit=1)
@@ -70,6 +76,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(1, len(flavors),
                          "The length of flavor list was %s instead of 1" % len(flavors))
 
+    @tags(type='positive', net='no')
     def test_list_flavors_using_marker(self):
         """The list of flavors should start from the provided marker"""
         response = self.flavors_client.list_flavors()
@@ -88,6 +95,7 @@ class FlavorsTest(ComputeFixture):
                          msg='Filtered flavor was incorrectly \
                          included in the list of returned flavors')
 
+    @tags(type='positive', net='no')
     def test_list_flavors_detailed_using_marker(self):
         """The list of flavors should start from the provided marker"""
         response = self.flavors_client.list_flavors_with_detail()
@@ -104,6 +112,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(actual_flavors, expected_flavors,
                          msg='Filtered flavors list does not begin at provided marker')
 
+    @tags(type='positive', net='no')
     def test_list_flavors_detailed_filter_by_min_disk(self):
         """The detailed list of flavors should be filtered by disk space"""
         response = self.flavors_client.list_flavors_with_detail()
@@ -120,6 +129,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(actual_flavors, expected_flavors,
                          msg="A flavor with min_disk lower than %s was returned" % (flavors[1].disk))
 
+    @tags(type='positive', net='no')
     def test_list_flavors_detailed_filter_by_min_ram(self):
         """The detailed list of flavors should be filtered by RAM"""
         response = self.flavors_client.list_flavors_with_detail()
@@ -135,6 +145,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(actual_flavors, expected_flavors,
                          msg="A flavor with min_ram lower than %s was returned" % (flavors[1].ram))
 
+    @tags(type='positive', net='no')
     def test_list_flavors_filter_by_min_disk(self):
         """The list of flavors should be filtered by disk space"""
         response = self.flavors_client.list_flavors_with_detail()
@@ -151,6 +162,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(actual_flavors, expected_flavors,
                          msg="A flavor with min_disk lower than %s was returned" % (flavors[1].disk))
 
+    @tags(type='positive', net='no')
     def test_list_flavors_filter_by_min_ram(self):
         """The list of flavors should be filtered by RAM"""
         response = self.flavors_client.list_flavors_with_detail()
@@ -167,6 +179,7 @@ class FlavorsTest(ComputeFixture):
         self.assertEqual(actual_flavors, expected_flavors,
                          msg="A flavor with min_disk lower than %s was returned" % flavors[1].ram)
 
+    @tags(type='negative', net='no')
     def test_list_flavors_detailed_filter_by_invalid_min_disk(self):
         """The detailed list of flavors should be filtered by disk space"""
         with self.assertRaises(BadRequest):
@@ -176,6 +189,7 @@ class FlavorsTest(ComputeFixture):
                             msg="The list of flavors is not empty for \
                             an invalid min disk value")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_detailed_filter_by_invalid_min_ram(self):
         """The detailed list of flavors should be filtered by RAM"""
         with self.assertRaises(BadRequest):
@@ -185,6 +199,7 @@ class FlavorsTest(ComputeFixture):
                             msg="The list of flavors is not empty for \
                             an invalid min RAM value")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_filter_by_invalid_min_disk(self):
         """The detailed list of flavors should be filtered by disk space"""
         with self.assertRaises(BadRequest):
@@ -194,6 +209,7 @@ class FlavorsTest(ComputeFixture):
                             msg="The list of flavors is not empty for an \
                             invalid min disk value")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_filter_by_invalid_min_ram(self):
         """The detailed list of flavors should be filtered by RAM"""
         with self.assertRaises(BadRequest):
@@ -203,6 +219,7 @@ class FlavorsTest(ComputeFixture):
                             msg="The list of flavors is not empty for \
                             an invalid min RAM value")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_detailed_filter_min_disk_value_greater_than_max_flavor_disk(self):
         """The detailed list of flavors should be filtered by disk space"""
         response = self.flavors_client.list_flavors_with_detail(min_disk='99999')
@@ -211,6 +228,7 @@ class FlavorsTest(ComputeFixture):
                         msg="The list of flavors is not empty for the value \
                         of min disk greater then max flavor disk size.")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_detailed_filter_min_ram_value_greater_than_max_flavor_ram(self):
         """The detailed list of flavors should be filtered by RAM"""
         response = self.flavors_client.list_flavors_with_detail(min_ram='99999')
@@ -219,6 +237,7 @@ class FlavorsTest(ComputeFixture):
                         msg="The list of flavors is not empty for the value \
                         of min RAM greater then max flavor RAM size.")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_filter_min_disk_value_greater_than_max_flavor_disk(self):
         """The detailed list of flavors should be filtered by disk space"""
         response = self.flavors_client.list_flavors(min_disk='99999')
@@ -227,6 +246,7 @@ class FlavorsTest(ComputeFixture):
                         msg="The list of flavors is not empty for the value \
                         of min disk greater then max flavor disk size.")
 
+    @tags(type='negative', net='no')
     def test_list_flavors_filter_min_disk_value_greater_than_max_flavor_ram(self):
         """The detailed list of flavors should be filtered by RAM"""
         response = self.flavors_client.list_flavors(min_ram='99999')

test_repo/compute/functional/servers/test_update_server.py

@@ -40,6 +40,7 @@ class UpdateServerTest(ComputeFixture):
 
         cls.server = cls.servers_client.get_server(cls.original_server.id).entity
 
+    @tags(type='smoke', net='no')
     def test_update_server_response(self):
         updated_server = self.resp.entity
         self.assertEqual(updated_server.name, self.new_name,

test_repo/compute/integration/__init__.py

@@ -12,4 +12,4 @@ 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.
-"""
+"""

test_repo/compute/integration/identity/__init__.py

@@ -12,4 +12,4 @@ 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.
-"""
+"""

test_repo/compute/integration/identity/test_authentication_required.py

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from cafe.drivers.unittest.decorators import tags
 from cloudcafe.compute.common.datagen import rand_name
 from cloudcafe.compute.common.types import NovaImageStatusTypes
 from cloudcafe.compute.common.types import NovaServerRebootTypes
@@ -35,136 +36,159 @@ class TokenRequiredTests(ComputeFixture):
         image_name = rand_name('testimage')
         cls.image_meta = {'key1': 'value1', 'key2': 'value2'}
         image_resp = cls.servers_client.create_image(cls.server.id,
-                                                      image_name,
+                                                     image_name,
-                                                      cls.image_meta)
+                                                     cls.image_meta)
         assert image_resp.status_code == 202
         cls.image_id = cls.parse_image_id(image_resp)
-        cls.image_behaviors.wait_for_image_status(cls.image_id, NovaImageStatusTypes.ACTIVE)
+        cls.image_behaviors.wait_for_image_status(
+            cls.image_id, NovaImageStatusTypes.ACTIVE)
         cls.resources.add(cls.image_id, cls.images_client.delete_image)
-        cls.auth_token = {'headers':{'X-Auth-Token': None}}
+        cls.auth_token = {'headers': {'X-Auth-Token': None}}
 
     @classmethod
     def tearDownClass(cls):
         super(TokenRequiredTests, cls).tearDownClass()
 
+    @tags(type='negative', net='no')
     def test_list_flavors_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.flavors_client.list_flavors(
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_flavors_detailed_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.flavors_client.list_flavors_with_detail(
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_get_flavor_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.flavors_client.get_flavor_details(
                 self.flavor_ref,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_images_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.list_images(
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_images_detailed_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.list_images_with_detail(
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_get_image_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.get_image(
                 self.image_ref,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_delete_image_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.delete_image(
                 self.image_id,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_servers_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.list_servers(
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_servers_detailed_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.list_servers_with_detail(
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_server_addresses_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.list_addresses(
                 self.server.id, requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_server_addresses_by_network_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.list_addresses_by_network(
                 self.server.id, 'prviate', requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_create_server_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.create_server(
                 'test', self.image_ref, self.flavor_ref,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_get_server_unauthorized(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.get_server(
                 self.server.id,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_delete_server_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.delete_server(
                 self.server.id,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_change_server_password_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.change_password(
                 self.server.id, 'newP@ssw0rd',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_reboot_server_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.reboot(
                 self.server.id, NovaServerRebootTypes.SOFT,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_rebuild_server_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.rebuild(
                 self.server.id, self.image_ref_alt,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_resize_server_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.resize(
                 self.server.id, self.flavor_ref_alt,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_create_image_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.create_image(
                 self.server.id, 'testimage',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_server_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.list_server_metadata(
                 self.server.id,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_server_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.list_server_metadata(
                 self.server.id,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_set_server_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
@@ -172,6 +196,7 @@ class TokenRequiredTests(ComputeFixture):
                 self.server.id, new_meta,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_update_server_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
@@ -179,30 +204,35 @@ class TokenRequiredTests(ComputeFixture):
                 self.server.id, new_meta,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_get_server_metadata_item_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.get_server_metadata_item(
                 self.server.id, 'meta_key_1',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_delete_server_metadata_item_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.delete_server_metadata_item(
                 self.server.id, 'meta_key_1',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_set_server_metadata_item_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.servers_client.set_server_metadata_item(
                 self.server.id, 'meta_key_1', 'newvalue',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_list_image_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.list_image_metadata(
                 self.image_id,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_set_image_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
@@ -210,6 +240,7 @@ class TokenRequiredTests(ComputeFixture):
                 self.image_id, new_meta,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_update_image_metadata_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
@@ -217,18 +248,21 @@ class TokenRequiredTests(ComputeFixture):
                 self.image_id, new_meta,
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_get_image_metadata_item_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.get_image_metadata_item(
                 self.image_id, 'key1',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_delete_image_metadata_item_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.delete_image_metadata_item(
                 self.image_id, 'key1',
                 requestslib_kwargs=self.auth_token)
 
+    @tags(type='negative', net='no')
     def test_set_image_metadata_item_with_invalid_token(self):
         with self.assertRaises(Unauthorized):
             self.images_client.set_image_metadata_item(
@@ -241,8 +275,8 @@ class InvalidTokenTests(TokenRequiredTests):
     @classmethod
     def setUpClass(cls):
         super(InvalidTokenTests, cls).setUpClass()
-        cls.auth_token = {'headers':{'X-Auth-Token': 'abc'}}
+        cls.auth_token = {'headers': {'X-Auth-Token': 'abc'}}
 
     @classmethod
     def tearDownClass(cls):
-        super(InvalidTokenTests, cls).tearDownClass()
+        super(InvalidTokenTests, cls).tearDownClass()

test_repo/compute/integration/identity/test_authorization.py

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from cafe.drivers.unittest.decorators import tags
 from cloudcafe.auth.provider import AuthProvider
 from cloudcafe.auth.config import ComputeAuthorizationConfig
 from cloudcafe.compute.common.datagen import rand_name
@@ -27,7 +28,6 @@ from cloudcafe.compute.images_api.client import ImagesClient
 from test_repo.compute.fixtures import ComputeFixture
 
 
-
 class AuthorizationTests(ComputeFixture):
 
     @classmethod
@@ -46,7 +46,8 @@ class AuthorizationTests(ComputeFixture):
                                                      cls.image_meta)
         assert image_resp.status_code == 202
         cls.image_id = cls.parse_image_id(image_resp)
-        cls.image_behaviors.wait_for_image_status(cls.image_id, NovaImageStatusTypes.ACTIVE)
+        cls.image_behaviors.wait_for_image_status(
+            cls.image_id, NovaImageStatusTypes.ACTIVE)
         cls.resources.add(cls.image_id, cls.images_client.delete_image)
 
         secondary_user = ComputeAuthorizationConfig()
@@ -70,113 +71,136 @@ class AuthorizationTests(ComputeFixture):
     def tearDownClass(cls):
         super(AuthorizationTests, cls).tearDownClass()
 
+    @tags(type='negative', net='no')
     def test_get_image_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.images_client.get_image(self.image_id)
 
+    @tags(type='negative', net='no')
     def test_delete_image_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.images_client.delete_image(self.image_id)
 
+    @tags(type='negative', net='no')
     def test_get_server_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.get_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_list_server_addresses_with_invalid_token(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.list_addresses(
                 self.server.id)
 
+    @tags(type='negative', net='no')
     def test_list_server_addresses_by_network_with_invalid_token(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.list_addresses_by_network(
                 self.server.id, 'prviate')
 
+    @tags(type='negative', net='no')
     def test_delete_server_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.delete_server(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_change_server_password_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.change_password(self.server.id, 'newP@ssw0rd')
 
+    @tags(type='negative', net='no')
     def test_reboot_server_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.reboot(self.server.id,
                                        NovaServerRebootTypes.SOFT)
 
+    @tags(type='negative', net='no')
     def test_rebuild_server_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.rebuild(self.server.id, self.image_ref_alt)
 
+    @tags(type='negative', net='no')
     def test_resize_server_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.resize(self.server.id, self.flavor_ref_alt)
 
+    @tags(type='negative', net='no')
     def test_create_image_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.create_image(self.server.id, 'testimage')
 
+    @tags(type='negative', net='no')
     def test_list_server_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.list_server_metadata(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_list_server_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.list_server_metadata(self.server.id)
 
+    @tags(type='negative', net='no')
     def test_set_server_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
             self.servers_client.set_server_metadata(self.server.id, new_meta)
 
+    @tags(type='negative', net='no')
     def test_update_server_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
             self.servers_client.update_server_metadata(
                 self.server.id, new_meta)
 
+    @tags(type='negative', net='no')
     def test_get_server_metadata_item_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.get_server_metadata_item(
                 self.server.id, 'meta_key_1')
 
+    @tags(type='negative', net='no')
     def test_delete_server_metadata_item_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.delete_server_metadata_item(
                 self.server.id, 'meta_key_1')
 
+    @tags(type='negative', net='no')
     def test_set_server_metadata_item_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.servers_client.set_server_metadata_item(
                 self.server.id, 'meta_key_1', 'newvalue')
 
+    @tags(type='negative', net='no')
     def test_list_image_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.images_client.list_image_metadata(self.image_id)
 
+    @tags(type='negative', net='no')
     def test_set_image_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
             self.images_client.set_image_metadata(self.image_id, new_meta)
 
+    @tags(type='negative', net='no')
     def test_update_image_metadata_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             new_meta = {'meta2': 'data2', 'meta3': 'data3'}
             self.images_client.update_image_metadata(self.image_id, new_meta)
 
+    @tags(type='negative', net='no')
     def test_get_image_metadata_item_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.images_client.get_image_metadata_item(
                 self.image_id, 'key1')
 
+    @tags(type='negative', net='no')
     def test_delete_image_metadata_item_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.images_client.delete_image_metadata_item(
                 self.image_id, 'key1')
 
+    @tags(type='negative', net='no')
     def test_set_image_metadata_item_unauthorized(self):
         with self.assertRaises(ItemNotFound):
             self.images_client.set_image_metadata_item(
                 self.image_id, 'key1', 'newvalue')
-