def test_rand_uuid(self):
     actual = data_utils.rand_uuid()
     self.assertIsInstance(actual, str)
     self.assertRegex(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 test_create_with_nonexistent_volume_type(self):
     # Should not be able to create volume with nonexistent volume_type.
     self.name_field = self.special_fields['name_field']
     params = {self.name_field: data_utils.rand_uuid(),
               'volume_type': data_utils.rand_uuid()}
     self.assertRaises(lib_exc.NotFound,
                       self.volumes_client.create_volume, **params)

 def test_create_flavor_with_uuid_id(self):
     flavor_id = data_utils.rand_uuid()
     new_flavor_id = self.create_flavor(ram=self.ram,
                                        vcpus=self.vcpus,
                                        disk=self.disk,
                                        id=flavor_id)['id']
     self.assertEqual(new_flavor_id, flavor_id)

    def test_metadata(self):
        key_name = data_utils.rand_name('testkey')
        self.client.import_key_pair(KeyName=key_name,
                                    PublicKeyMaterial=PUBLIC_KEY_MATERIAL)
        self.addResourceCleanUp(self.client.delete_key_pair, KeyName=key_name)

        sec_group_name = self.create_standard_security_group()
        user_data = six.text_type(data_utils.rand_uuid()) + six.unichr(1071)
        instance_id = self.run_instance(KeyName=key_name, UserData=user_data,
                                        SecurityGroups=[sec_group_name])

        data = self.client.describe_instance_attribute(
            InstanceId=instance_id, Attribute='userData')
        self.assertEqual(
            data['UserData']['Value'],
            base64.b64encode(user_data.encode("utf-8")).decode("utf-8"))

        ip_address = self.get_instance_ip(instance_id)

        ssh_client = ssh.Client(ip_address, CONF.aws.image_user,
                                pkey=PRIVATE_KEY_MATERIAL)

        url = 'http://169.254.169.254'
        data = ssh_client.exec_command('curl %s/latest/user-data' % url)
        if isinstance(data, six.binary_type):
            data = data.decode("utf-8")
        self.assertEqual(user_data, data)

        data = ssh_client.exec_command('curl %s/latest/meta-data/ami-id' % url)
        self.assertEqual(CONF.aws.image_id, data)

        data = ssh_client.exec_command(
            'curl %s/latest/meta-data/public-keys/0/openssh-key' % url)
        # compare only keys. without 'sha-rsa' and owner
        self.assertEqual(PUBLIC_KEY_MATERIAL.split()[1], data.split()[1])

    def test_compare_console_output(self):
        key_name = data_utils.rand_name('testkey')
        pkey = self.create_key_pair(key_name)
        sec_group_name = self.create_standard_security_group()
        instance_id = self.run_instance(KeyName=key_name,
                                        SecurityGroups=[sec_group_name])

        data_to_check = data_utils.rand_uuid()
        ip_address = self.get_instance_ip(instance_id)
        ssh_client = ssh.Client(ip_address, CONF.aws.image_user, pkey=pkey)
        cmd = 'sudo sh -c "echo \\"%s\\" >/dev/console"' % data_to_check
        ssh_client.exec_command(cmd)

        waiter = base.EC2Waiter(self.client.get_console_output)
        waiter.wait_no_exception(InstanceId=instance_id)

        def _compare_console_output():
            data = self.client.get_console_output(InstanceId=instance_id)
            self.assertEqual(instance_id, data['InstanceId'])
            self.assertIsNotNone(data['Timestamp'])
            self.assertIn('Output', data)
            self.assertIn(data_to_check, data['Output'])

        waiter = base.EC2Waiter(_compare_console_output)
        waiter.wait_no_exception()

 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_run_workspace_rename(self):
     new_name = data_utils.rand_uuid()
     cmd = ['tempest', 'workspace', '--workspace-path', self.store_file,
            'rename', "--old-name", self.name, '--new-name', new_name]
     self._run_cmd_gets_return_code(cmd, 0)
     self.assertIsNone(self.workspace_manager.get_workspace(self.name))
     self.assertIsNotNone(self.workspace_manager.get_workspace(new_name))

    def test_get_nonexistent_hypervisor_uptime(self):
        nonexistent_hypervisor_id = data_utils.rand_uuid()

        self.assertRaises(
            lib_exc.NotFound,
            self.client.show_hypervisor_uptime,
            nonexistent_hypervisor_id)

    def test_update_cluster_template_404(self):
        patch_model = datagen.cluster_template_name_patch_data()

        self.assertRaises(
            exceptions.NotFound,
            self.cluster_template_client.patch_cluster_template,
            data_utils.rand_uuid(), patch_model)

    def test_show_servers_with_nonexistent_hypervisor(self):
        nonexistent_hypervisor_id = data_utils.rand_uuid()

        self.assertRaises(
            lib_exc.NotFound,
            self.client.list_servers_on_hypervisor,
            nonexistent_hypervisor_id)

def cluster_data(name=data_utils.rand_name('cluster'),
                 cluster_template_id=data_utils.rand_uuid(),
                 node_count=random_int(1, 5), discovery_url=gen_random_ip(),
                 create_timeout=random_int(1, 30),
                 master_count=random_int(1, 5)):
    """Generates random cluster data

    cluster_template_id cannot be random for the cluster to be valid due to
    validations for the presence of clustertemplate prior to clustertemplate
    creation.

    :param name: cluster name (must be unique)
    :param cluster_template_id: clustertemplate unique id (must already exist)
    :param node_count: number of agents for cluster
    :param discovery_url: url provided for node discovery
    :param create_timeout: timeout in minutes for cluster create
    :param master_count: number of master nodes for the cluster
    :returns: ClusterEntity with generated data
    """

    data = {
        "name": name,
        "cluster_template_id": cluster_template_id,
        "keypair": config.Config.keypair_id,
        "node_count": node_count,
        "discovery_url": None,
        "create_timeout": create_timeout,
        "master_count": master_count
    }
    model = cluster_model.ClusterEntity.from_dict(data)

    return model

 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 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(lib_exc.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)

 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(lib_exc.NotFound,
                       self.client.show_server_metadata_item,
                       non_existent_server_id,
                       'test2')

def bay_data(name=data_utils.rand_name('bay'),
             baymodel_id=data_utils.rand_uuid(),
             node_count=random_int(1, 5), discovery_url=gen_random_ip(),
             bay_create_timeout=random_int(1, 30),
             master_count=random_int(1, 5)):
    """Generates random bay data

    BayModel_id cannot be random for the bay to be valid due to
    validations for the presence of baymodel prior to baymodel
    creation.

    :param name: bay name (must be unique)
    :param baymodel_id: baymodel unique id (must already exist)
    :param node_count: number of agents for bay
    :param discovery_url: url provided for node discovery
    :param bay_create_timeout: timeout in minutes for bay create
    :param master_count: number of master nodes for the bay
    :returns: BayEntity with generated data
    """

    data = {
        "name": name,
        "baymodel_id": baymodel_id,
        "node_count": node_count,
        "discovery_url": None,
        "bay_create_timeout": bay_create_timeout,
        "master_count": master_count
    }
    model = bay_model.BayEntity.from_dict(data)

    return model

    def test_update_baymodel_404(self):
        patch_model = datagen.baymodel_name_patch_data()

        self.assertRaises(
            exceptions.NotFound,
            self.baymodel_client.patch_baymodel,
            data_utils.rand_uuid(), patch_model)

 def test_update_attached_volume_with_nonexistent_volume_in_uri(self):
     volume = self.create_volume()
     nonexistent_volume = data_utils.rand_uuid()
     self.assertRaises(lib_exc.NotFound,
                       self.admin_servers_client.update_attached_volume,
                       self.server['id'], nonexistent_volume,
                       volumeId=volume['id'])

 def test_path_expansion(self):
     name = data_utils.rand_uuid()
     path = os.path.join("~", name)
     os.makedirs(os.path.expanduser(path))
     self.addCleanup(shutil.rmtree, path, ignore_errors=True)
     self.workspace_manager.register_new_workspace(name, path)
     self.assertIsNotNone(self.workspace_manager.get_workspace(name))