def test_rand_uuid(self):
     actual = data_utils.rand_uuid()
     self.assertIsInstance(actual, str)
     self.assertRegexpMatches(actual, "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]"
                                      "{4}-[0-9a-f]{4}-[0-9a-f]{12}$")
     actual2 = data_utils.rand_uuid()
     self.assertNotEqual(actual, actual2)

 def _associate_node_with_instance(self):
     self.client.set_node_power_state(self.node["uuid"], "power off")
     waiters.wait_for_bm_node_status(self.client, self.node["uuid"], "power_state", "power off")
     instance_uuid = data_utils.rand_uuid()
     self.client.update_node(self.node["uuid"], instance_uuid=instance_uuid)
     self.addCleanup(self.client.update_node, uuid=self.node["uuid"], instance_uuid=None)
     return instance_uuid

 def test_create_snapshot_with_nonexistent_volume_id(self):
     # Create a snapshot with nonexistent volume id
     s_name = data_utils.rand_name(self.__class__.__name__ + '-snap')
     self.assertRaises(lib_exc.NotFound,
                       self.snapshots_client.create_snapshot,
                       volume_id=data_utils.rand_uuid(),
                       display_name=s_name)

 def test_delete_metadata_non_existent_server(self):
     # Should not be able to delete metadata item from a non-existent server
     non_existent_server_id = data_utils.rand_uuid()
     self.assertRaises(exceptions.NotFound,
                       self.client.delete_server_metadata_item,
                       non_existent_server_id,
                       'd')

 def test_rebuild_non_existent_server(self):
     # Rebuild a non existent server
     nonexistent_server = data_utils.rand_uuid()
     self.assertRaises(lib_exc.NotFound,
                       self.client.rebuild_server,
                       nonexistent_server,
                       self.image_ref_alt)

 def test_get_nonexistent_volume_type_id(self):
     # Should not get volume type extra spec for nonexistent type id.
     extra_specs = {"spec1": "val1"}
     self.assertRaises(
         lib_exc.NotFound,
         self.admin_volume_types_client.show_volume_type_extra_specs,
         data_utils.rand_uuid(), extra_specs.keys()[0])

 def test_delete_nonexistent_volume_type_id(self):
     # Should not delete volume type extra spec for nonexistent
     # type id.
     self.assertRaises(
         lib_exc.NotFound,
         self.admin_volume_types_client.delete_volume_type_extra_specs,
         data_utils.rand_uuid(), "spec1")

 def test_get_nonexistent_extra_spec_id(self):
     # Should not get volume type extra spec for nonexistent extra spec
         # id.
     self.assertRaises(
         lib_exc.NotFound,
         self.admin_volume_types_client.show_volume_type_extra_specs,
         self.volume_type['id'], data_utils.rand_uuid())

    def populate_spam_table(self, table_name, usercount, itemcount):

        dates = ['2013-12-0%sT16:00:00.000001' % i for i in range(1, 8)]
        from_headers = ["%[email protected]" % rand_name() for _ in range(10)]
        to_headers = ["%[email protected]" % rand_name() for _ in range(10)]
        emails = []

        new_items = []
        for _ in range(usercount):
            email = "%[email protected]" % rand_name()
            emails.append(email)

            for item in range(itemcount):
                message_id = rand_uuid()
                date = random.choice(dates)
                # put item
                item = {
                    "user_id": {"S": email},
                    "date_message_id": {"S": date + "#" + message_id},
                    "message_id": {"S": message_id},
                    "from_header": {"S": random.choice(from_headers)},
                    "to_header": {"S": random.choice(to_headers)},
                }
                new_items.append(item)
                self.conn.put_item(table_name, item)
        return new_items

 def test_server_metadata_non_existent_server(self):
     # GET on a non-existent server should not succeed
     non_existent_server_id = data_utils.rand_uuid()
     self.assertRaises(exceptions.NotFound,
                       self.client.get_server_metadata_item,
                       non_existent_server_id,
                       'test2')

 def test_create_image_from_nonexistent_server(self):
     # An image should not be created with invalid server id
     # Create a new image with invalid server id
     nonexistent_server_id = data_utils.rand_uuid()
     name = data_utils.rand_name('image')
     meta = {'image_type': 'test'}
     self.assertRaises(exceptions.NotFound, self.__create_image__,
                       nonexistent_server_id, name, meta)

    def test_create_port_duplicated_port_uuid(self):
        node_id = self.node['uuid']
        address = data_utils.rand_mac_address()
        uuid = data_utils.rand_uuid()

        self.create_port(node_id=node_id, address=address, uuid=uuid)
        self.assertRaises(exc.Conflict, self.create_port, node_id=node_id,
                          address=address, uuid=uuid)

 def test_set_nonexistent_image_metadata_item(self):
     # Negative test: Metadata item should not be set to a
     # nonexistent image
     meta = {'key1': 'alt'}
     self.assertRaises(exceptions.NotFound,
                       self.client.set_image_metadata_item,
                       data_utils.rand_uuid(), 'key1',
                       meta)

 def test_delete_nonexistent_volume_type_id(self):
     # Should not delete volume type extra spec for nonexistent
         # type id.
     extra_specs = {"spec1": "val1"}
     self.assertRaises(
         lib_exc.NotFound,
         self.volume_types_client.delete_volume_type_extra_specs,
         data_utils.rand_uuid(), extra_specs.keys()[0])

 def test_update_metadata_non_existent_server(self):
     # An update should not happen for a non-existent server
     non_existent_server_id = data_utils.rand_uuid()
     meta = {'key1': 'value1', 'key2': 'value2'}
     self.assertRaises(exceptions.NotFound,
                       self.client.update_server_metadata,
                       non_existent_server_id,
                       meta)

    def test_attach_volumes_with_nonexistent_volume_id(self):
        server = self.create_server(wait_until='ACTIVE')

        self.assertRaises(lib_exc.NotFound,
                          self.client.attach_volume,
                          data_utils.rand_uuid(),
                          instance_uuid=server['id'],
                          mountpoint=self.mountpoint)

 def test_create_nonexistent_type_id(self):
     # Should not create volume type extra spec for nonexistent volume
         # type id.
     extra_specs = {"spec2": "val1"}
     self.assertRaises(
         lib_exc.NotFound,
         self.admin_volume_types_client.create_volume_type_extra_specs,
         data_utils.rand_uuid(), extra_specs)

 def test_set_metadata_non_existent_server(self):
     # Set metadata on a non-existent server should not succeed
     non_existent_server_id = data_utils.rand_uuid()
     meta = {'meta1': 'data1'}
     self.assertRaises(exceptions.NotFound,
                       self.client.set_server_metadata,
                       non_existent_server_id,
                       meta)

 def test_update_nonexistent_extra_spec_id(self):
     # Should not update volume type extra specs with nonexistent id.
     extra_spec = {"spec1": "val2"}
     self.assertRaises(
         lib_exc.BadRequest,
         self.admin_volume_types_client.update_volume_type_extra_specs,
         self.volume_type['id'], data_utils.rand_uuid(),
         extra_spec)

    def test_update_name_of_non_existent_server(self):
        # Update name of a non-existent server

        nonexistent_server = data_utils.rand_uuid()
        new_name = data_utils.rand_name('server') + '_updated'

        self.assertRaises(lib_exc.NotFound, self.client.update_server,
                          nonexistent_server, name=new_name)