diff --git a/renku/cli/dataset.py b/renku/cli/dataset.py
index 6f7c9918ea..47d4c973be 100644
--- a/renku/cli/dataset.py
+++ b/renku/cli/dataset.py
@@ -385,9 +385,34 @@ def dataset(ctx, revision, datadir, format):
 
 @dataset.command()
 @click.argument('name')
-def create(name):
+@click.option(
+    '--short-name', default='', help='A convenient name for dataset.'
+)
+@click.option(
+    '-d', '--description', default='', help='Dataset\'s description.'
+)
+@click.option(
+    '-c',
+    '--creator',
+    default=None,
+    multiple=True,
+    help='Creator\'s name and email ("Name <email>").'
+)
+def create(name, short_name, description, creator):
     """Create an empty dataset in the current repo."""
-    create_dataset(name)
+    creators = creator or ()
+
+    dataset = create_dataset(
+        name=name,
+        short_name=short_name,
+        description=description,
+        creators=creators
+    )
+    click.echo(
+        'Use the name "{}" to refer to this dataset.'.format(
+            dataset.short_name
+        )
+    )
     click.secho('OK', fg='green')
 
 
@@ -606,14 +631,16 @@ def export_(id, provider, publish, tag):
 
 @dataset.command('import')
 @click.argument('uri')
-@click.option('-n', '--name', help='Dataset name.')
+@click.option(
+    '--short-name', default='', help='A convenient name for dataset.'
+)
 @click.option(
     '-x',
     '--extract',
     is_flag=True,
     help='Extract files before importing to dataset.'
 )
-def import_(uri, name, extract):
+def import_(uri, short_name, extract):
     """Import data from a 3rd party provider.
 
     Supported providers: [Zenodo, Dataverse]
@@ -638,9 +665,9 @@ def _init(lock, id_queue):
         tqdm.set_lock(lock)
 
     import_dataset(
-        uri,
-        name,
-        extract,
+        uri=uri,
+        short_name=short_name,
+        extract=extract,
         with_prompt=True,
         pool_init_fn=_init,
         pool_init_args=(mp.RLock(), id_queue),
diff --git a/renku/core/commands/checks/migration.py b/renku/core/commands/checks/migration.py
index 6bec34afce..ddb5a69524 100644
--- a/renku/core/commands/checks/migration.py
+++ b/renku/core/commands/checks/migration.py
@@ -162,7 +162,7 @@ def migrate_broken_dataset_paths(client):
         # migrate the refs
         ref = LinkReference.create(
             client=client,
-            name='datasets/{0}'.format(dataset.display_name),
+            name='datasets/{0}'.format(dataset.short_name),
             force=True,
         )
         ref.set_reference(expected_path / client.METADATA)
diff --git a/renku/core/commands/dataset.py b/renku/core/commands/dataset.py
index 51e78fc256..fb4fc42e5e 100644
--- a/renku/core/commands/dataset.py
+++ b/renku/core/commands/dataset.py
@@ -42,7 +42,7 @@
     MigrationRequired, ParameterError, UsageError
 from renku.core.management.datasets import DATASET_METADATA_PATHS
 from renku.core.management.git import COMMIT_DIFF_STRATEGY
-from renku.core.models.datasets import Dataset
+from renku.core.models.datasets import Dataset, generate_default_short_name
 from renku.core.models.provenance.agents import Person
 from renku.core.models.refs import LinkReference
 from renku.core.models.tabulate import tabulate
@@ -101,15 +101,26 @@ def dataset_parent(client, revision, datadir, format, ctx=None):
 @pass_local_client(
     clean=False, commit=True, commit_only=DATASET_METADATA_PATHS
 )
-def create_dataset(client, name, commit_message=None):
+def create_dataset(
+    client, name, short_name, description, creators, commit_message=None
+):
     """Create an empty dataset in the current repo.
 
     :raises: ``renku.core.errors.ParameterError``
     """
-    with client.with_dataset(name=name, create=True) as dataset:
-        creator = Person.from_git(client.repo)
-        if creator not in dataset.creator:
-            dataset.creator.append(creator)
+    if not creators:
+        creators = [Person.from_git(client.repo)]
+    else:
+        creators = [Person.from_string(c) for c in creators]
+
+    dataset, _, __ = client.create_dataset(
+        name=name,
+        short_name=short_name,
+        description=description,
+        creators=creators
+    )
+
+    return dataset
 
 
 @pass_local_client(
@@ -284,7 +295,7 @@ def dataset_remove(
     commit_message=None
 ):
     """Delete a dataset."""
-    datasets = {name: client.dataset_path(name) for name in names}
+    datasets = {name: client.get_dataset_path(name) for name in names}
 
     if not datasets:
         raise ParameterError(
@@ -422,8 +433,8 @@ def export_dataset(
 def import_dataset(
     client,
     uri,
-    name,
-    extract,
+    short_name='',
+    extract=False,
     with_prompt=False,
     pool_init_fn=None,
     pool_init_args=None,
@@ -474,6 +485,15 @@ def import_dataset(
         )
 
     if files:
+        if not short_name:
+            short_name = generate_default_short_name(
+                dataset.name, dataset.version
+            )
+
+        dataset.short_name = short_name
+
+        client.create_dataset(name=dataset.name, short_name=short_name)
+
         data_folder = tempfile.mkdtemp()
 
         pool_size = min(
@@ -511,20 +531,18 @@ def import_dataset(
             ))
         pool.close()
 
-        dataset_name = name or dataset.display_name
         dataset.url = remove_credentials(dataset.url)
         add_to_dataset(
             client,
             urls=[str(p) for p in Path(data_folder).glob('*')],
-            name=dataset_name,
-            with_metadata=dataset,
-            create=True
+            name=short_name,
+            with_metadata=dataset
         )
 
         if dataset.version:
             tag_name = re.sub('[^a-zA-Z0-9.-_]', '_', dataset.version)
             tag_dataset(
-                client, dataset_name, tag_name,
+                client, short_name, tag_name,
                 'Tag {} created by renku import'.format(dataset.version)
             )
 
@@ -633,7 +651,7 @@ def _filter(client, names=None, creators=None, include=None, exclude=None):
 
     records = []
     for path_, dataset in client.datasets.items():
-        if not names or dataset.name in names:
+        if not names or dataset.short_name in names:
             for file_ in dataset.files:
                 file_.dataset = dataset.name
                 path_ = file_.full_path.relative_to(client.path)
diff --git a/renku/core/commands/format/datasets.py b/renku/core/commands/format/datasets.py
index da3e62e202..92a7a3a046 100644
--- a/renku/core/commands/format/datasets.py
+++ b/renku/core/commands/format/datasets.py
@@ -31,7 +31,7 @@ def tabular(client, datasets):
         datasets,
         headers=OrderedDict((
             ('uid', 'id'),
-            ('display_name', None),
+            ('short_name', None),
             ('version', None),
             ('created', None),
             ('creators_csv', 'creators'),
diff --git a/renku/core/errors.py b/renku/core/errors.py
index 3b143a8671..8c68fde42c 100644
--- a/renku/core/errors.py
+++ b/renku/core/errors.py
@@ -128,7 +128,7 @@ def __init__(self, message=None):
             'Please use the "git config" command to configure it.\n\n'
             '\tgit config --set user.email "john.doe@example.com"\n'
         )
-        super(MissingUsername, self).__init__(message)
+        super().__init__(message)
 
 
 class AuthenticationError(RenkuException):
diff --git a/renku/core/management/datasets.py b/renku/core/management/datasets.py
index b48af3e039..d4871bc286 100644
--- a/renku/core/management/datasets.py
+++ b/renku/core/management/datasets.py
@@ -36,7 +36,8 @@
 from renku.core import errors
 from renku.core.management.clone import clone
 from renku.core.management.config import RENKU_HOME
-from renku.core.models.datasets import Dataset, DatasetFile, DatasetTag
+from renku.core.models.datasets import Dataset, DatasetFile, DatasetTag, \
+    generate_default_short_name, is_dataset_name_valid
 from renku.core.models.git import GitURL
 from renku.core.models.locals import with_reference
 from renku.core.models.provenance.agents import Person
@@ -85,31 +86,35 @@ def datasets(self):
         result = {}
         paths = (self.path / self.renku_datasets_path).rglob(self.METADATA)
         for path in paths:
-            result[path] = self.get_dataset(path)
+            result[path] = self.load_dataset_from_path(path)
         return result
 
-    def get_dataset(self, path, commit=None):
+    def load_dataset_from_path(self, path, commit=None):
         """Return a dataset from a given path."""
+        path = Path(path)
         if not path.is_absolute():
             path = self.path / path
         return Dataset.from_yaml(path, client=self, commit=commit)
 
-    def dataset_path(self, name):
+    def get_dataset_path(self, name):
         """Get dataset path from name."""
         path = self.renku_datasets_path / name / self.METADATA
         if not path.exists():
-            path = LinkReference(
-                client=self, name='datasets/' + name
-            ).reference
+            try:
+                path = LinkReference(
+                    client=self, name='datasets/' + name
+                ).reference
+            except errors.ParameterError:
+                return None
 
         return path
 
     def load_dataset(self, name=None):
         """Load dataset reference file."""
         if name:
-            path = self.dataset_path(name)
-            if path.exists():
-                return self.get_dataset(path)
+            path = self.get_dataset_path(name)
+            if path and path.exists():
+                return self.load_dataset_from_path(path)
 
     @contextmanager
     def with_dataset(self, name=None, identifier=None, create=False):
@@ -118,42 +123,17 @@ def with_dataset(self, name=None, identifier=None, create=False):
         clean_up_required = False
 
         if dataset is None:
-            # Avoid nested datasets: name mustn't have '/' in it
-            if len(Path(name).parts) > 1:
-                raise errors.ParameterError(
-                    'Dataset name {} is not valid.'.format(name)
-                )
-
             if not create:
                 raise errors.DatasetNotFound
-            clean_up_required = True
-            dataset_ref = None
-            identifier = str(uuid.uuid4())
-            path = (self.renku_datasets_path / identifier / self.METADATA)
-            try:
-                path.parent.mkdir(parents=True, exist_ok=False)
-            except FileExistsError:
-                raise errors.DatasetExistsError(
-                    'Dataset with reference {} exists'.format(path.parent)
-                )
-
-            with with_reference(path):
-                dataset = Dataset(
-                    identifier=identifier, name=name, client=self
-                )
-
-            if name:
-                dataset_ref = LinkReference.create(
-                    client=self, name='datasets/' + name
-                )
-                dataset_ref.set_reference(path)
 
+            clean_up_required = True
+            dataset, path, dataset_ref = self.create_dataset(name)
         elif create:
             raise errors.DatasetExistsError(
                 'Dataset exists: "{}".'.format(name)
             )
 
-        dataset_path = self.path / self.datadir / dataset.name
+        dataset_path = self.path / self.datadir / dataset.short_name
         dataset_path.mkdir(parents=True, exist_ok=True)
 
         try:
@@ -161,7 +141,7 @@ def with_dataset(self, name=None, identifier=None, create=False):
         except Exception:
             # TODO use a general clean-up strategy
             # https://github.com/SwissDataScienceCenter/renku-python/issues/736
-            if clean_up_required and dataset_ref:
+            if clean_up_required:
                 dataset_ref.delete()
                 shutil.rmtree(path.parent, ignore_errors=True)
             raise
@@ -174,6 +154,54 @@ def with_dataset(self, name=None, identifier=None, create=False):
 
         dataset.to_yaml()
 
+    def create_dataset(
+        self, name, short_name=None, description='', creators=()
+    ):
+        """Create a dataset."""
+        if not name:
+            raise errors.ParameterError('Dataset name must be provided.')
+
+        if not short_name:
+            short_name = generate_default_short_name(name, None)
+
+        if not is_dataset_name_valid(short_name):
+            raise errors.ParameterError(
+                'Dataset name "{}" is not valid.'.format(short_name)
+            )
+
+        if self.load_dataset(name=short_name):
+            raise errors.DatasetExistsError(
+                'Dataset exists: "{}".'.format(short_name)
+            )
+
+        identifier = str(uuid.uuid4())
+        path = (self.renku_datasets_path / identifier / self.METADATA)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=False)
+        except FileExistsError:
+            raise errors.DatasetExistsError(
+                'Dataset with reference {} exists'.format(path.parent)
+            )
+
+        with with_reference(path):
+            dataset = Dataset(
+                client=self,
+                identifier=identifier,
+                name=name,
+                short_name=short_name,
+                description=description,
+                creator=creators
+            )
+
+        dataset_ref = LinkReference.create(
+            client=self, name='datasets/' + short_name
+        )
+        dataset_ref.set_reference(path)
+
+        dataset.to_yaml()
+
+        return dataset, path, dataset_ref
+
     def add_data_to_dataset(
         self,
         dataset,
@@ -186,7 +214,7 @@ def add_data_to_dataset(
     ):
         """Import the data into the data directory."""
         warning_message = ''
-        dataset_path = self.path / self.datadir / dataset.name
+        dataset_path = self.path / self.datadir / dataset.short_name
 
         destination = destination or Path('.')
         destination = self._resolve_path(dataset_path, destination)
diff --git a/renku/core/models/datasets.py b/renku/core/models/datasets.py
index 8ac9989ba2..a7143041e8 100644
--- a/renku/core/models/datasets.py
+++ b/renku/core/models/datasets.py
@@ -29,9 +29,10 @@
 import attr
 from attr.validators import instance_of
 
-# from renku.core.models.creators import CreatorsMixin
+from renku.core import errors
 from renku.core.models.entities import Entity
 from renku.core.models.provenance.agents import Person
+from renku.core.models.refs import LinkReference
 from renku.core.utils.datetime8601 import parse_date
 from renku.core.utils.doi import extract_doi, is_doi
 
@@ -276,7 +277,7 @@ class Dataset(Entity, CreatorMixin):
 
     EDITABLE_FIELDS = [
         'creator', 'date_published', 'description', 'in_language', 'keywords',
-        'license', 'name', 'url', 'version', 'created', 'files'
+        'license', 'name', 'url', 'version', 'created', 'files', 'short_name'
     ]
 
     _id = jsonld.ib(default=None, context='@id', kw_only=True)
@@ -350,30 +351,23 @@ class Dataset(Entity, CreatorMixin):
 
     same_as = jsonld.ib(context='schema:sameAs', default=None, kw_only=True)
 
+    short_name = jsonld.ib(
+        default=None, context='schema:alternateName', kw_only=True
+    )
+
     @created.default
     def _now(self):
         """Define default value for datetime fields."""
         return datetime.datetime.now(datetime.timezone.utc)
 
-    @property
-    def display_name(self):
-        """Get dataset display name."""
-        name = re.sub(' +', ' ', self.name.lower()[:24])
-
-        def to_unix(el):
-            """Parse string to unix friendly name."""
-            parsed_ = re.sub('[^a-zA-Z0-9]', '', re.sub(' +', ' ', el))
-            parsed_ = re.sub(' .+', '.', parsed_.lower())
-            return parsed_
-
-        short_name = [to_unix(el) for el in name.split()]
-
-        if self.version:
-            version = to_unix(self.version)
-            name = '{0}_{1}'.format('_'.join(short_name), version)
-            return name
-
-        return '.'.join(short_name)
+    @short_name.validator
+    def short_name_validator(self, attribute, value):
+        """Validate short_name."""
+        # short_name might have been scaped and have '%' in it
+        if value and not is_dataset_name_valid(value, safe='%'):
+            raise errors.ParameterError(
+                'Invalid "short_name": {}'.format(value)
+            )
 
     @property
     def uid(self):
@@ -527,3 +521,44 @@ def __attrs_post_init__(self):
         except KeyError:
             # if with_dataset is used, the dataset is not committed yet
             pass
+
+        if not self.short_name:
+            self.short_name = generate_default_short_name(
+                self.name, self.version
+            )
+
+
+def is_dataset_name_valid(name, safe=''):
+    """A valid name is a valid Git reference name with no /."""
+    # TODO make name an RFC 3986 compatible name and migrate old projects
+    return (
+        name and LinkReference.check_ref_format(name, no_slashes=True) and
+        '/' not in name
+    )
+
+
+def generate_default_short_name(dataset_name, dataset_version):
+    """Get dataset short_name."""
+    # For compatibility with older versions use name as short_name
+    # if it is valid; otherwise, use encoded name
+    if is_dataset_name_valid(dataset_name):
+        return dataset_name
+
+    name = re.sub(r'\s+', ' ', dataset_name)
+    name = name.lower()[:24]
+
+    def to_unix(el):
+        """Parse string to unix friendly name."""
+        parsed_ = re.sub('[^a-zA-Z0-9]', '', re.sub(r'\s+', ' ', el))
+        parsed_ = re.sub(' .+', '.', parsed_.lower())
+        return parsed_
+
+    short_name = [to_unix(el) for el in name.split()]
+    short_name = [el for el in short_name if el]
+
+    if dataset_version:
+        version = to_unix(dataset_version)
+        name = '{0}_{1}'.format('_'.join(short_name), version)
+        return name
+
+    return '_'.join(short_name)
diff --git a/renku/core/models/provenance/activities.py b/renku/core/models/provenance/activities.py
index b658adc0a6..4e474de406 100644
--- a/renku/core/models/provenance/activities.py
+++ b/renku/core/models/provenance/activities.py
@@ -156,7 +156,7 @@ def default_generated(self):
             if str(path).startswith(
                 os.path.join(client.renku_home, client.DATASETS)
             ):
-                entity = client.get_dataset(Path(path), commit=commit)
+                entity = client.load_dataset_from_path(path, commit=commit)
             else:
                 entity = entity_cls(
                     commit=commit,
diff --git a/renku/core/models/provenance/agents.py b/renku/core/models/provenance/agents.py
index 7e731b1c5a..edd82a0680 100644
--- a/renku/core/models/provenance/agents.py
+++ b/renku/core/models/provenance/agents.py
@@ -127,6 +127,24 @@ def from_git(cls, git):
 
         return cls(name=name, email=email)
 
+    @classmethod
+    def from_string(cls, string):
+        """Create an instance from a 'Name <email>' string."""
+        REGEX = r'([^<]*)<{0,1}([^@<>]+@[^@<>]+\.[^@<>]+)*>{0,1}'
+        name, email = re.search(REGEX, string).groups()
+        name = name.rstrip()
+        # Check the git configuration.
+        if not name:  # pragma: no cover
+            raise errors.ParameterError(
+                'Name is not valid: Valid format is "Name <email>"'
+            )
+        if not email:  # pragma: no cover
+            raise errors.ParameterError(
+                'Email is not valid: Valid format is "Name <email>"'
+            )
+
+        return cls(name=name, email=email)
+
     def __attrs_post_init__(self):
         """Finish object initialization."""
         # handle the case where ids were improperly set
diff --git a/renku/core/models/refs.py b/renku/core/models/refs.py
index 23d7f8f0cf..30e6c3fab5 100644
--- a/renku/core/models/refs.py
+++ b/renku/core/models/refs.py
@@ -37,7 +37,7 @@ class LinkReference:
     """Define a name of the folder with references in the Renku folder."""
 
     @classmethod
-    def check_ref_format(cls, name):
+    def check_ref_format(cls, name, no_slashes=False):
         r"""Ensures that a reference name is well formed.
 
         It follows Git naming convention:
@@ -51,14 +51,15 @@ def check_ref_format(cls, name):
         - it ends with ".lock", or
         - it contains a "@{" portion
         """
-        return subprocess.run(('git', 'check-ref-format', name)
-                              ).returncode == 0
+        params = ('--allow-onelevel', name) if no_slashes else (name, )
+        return subprocess.run(('git', 'check-ref-format') +
+                              params).returncode == 0
 
     @name.validator
     def name_validator(self, attribute, value):
         """Validate reference name."""
         if not self.check_ref_format(value):
-            raise errors.UsageError(
+            raise errors.ParameterError(
                 'The reference name "{0}" is not valid.'.format(value)
             )
 
diff --git a/renku/data/shacl_shape.json b/renku/data/shacl_shape.json
index 31d53f2277..679e544223 100644
--- a/renku/data/shacl_shape.json
+++ b/renku/data/shacl_shape.json
@@ -380,6 +380,14 @@
                "sh:class": {
                   "@id": "prov:Generation"
                }
+            },
+            {
+               "nodeKind": "sh:Literal",
+               "path": "schema:alternateName",
+               "datatype": {
+                  "@id": "xsd:string"
+               },
+               "maxCount": 1
             }
          ]
       },
diff --git a/tests/cli/test_datasets.py b/tests/cli/test_datasets.py
index a7efdb7890..31d34d57af 100644
--- a/tests/cli/test_datasets.py
+++ b/tests/cli/test_datasets.py
@@ -56,6 +56,75 @@ def test_datasets_create_clean(runner, project, client):
         assert 'datasets' not in file_path
 
 
+def test_datasets_create_with_metadata(runner, client):
+    """Test creating a dataset with metadata."""
+    result = runner.invoke(
+        cli, [
+            'dataset', 'create', 'my-dataset', '--short-name', 'short-name',
+            '--description', 'some description here', '-c',
+            'John Doe <john.doe@mail.ch>', '-c',
+            'John Smiths<john.smiths@mail.ch>'
+        ]
+    )
+    assert 0 == result.exit_code
+    assert 'OK' in result.output
+
+    dataset = client.load_dataset(name='short-name')
+    assert dataset.name == 'my-dataset'
+    assert dataset.short_name == 'short-name'
+    assert dataset.description == 'some description here'
+    assert 'John Doe' in [c.name for c in dataset.creator]
+    assert 'john.doe@mail.ch' in [c.email for c in dataset.creator]
+    assert 'John Smiths' in [c.name for c in dataset.creator]
+    assert 'john.smiths@mail.ch' in [c.email for c in dataset.creator]
+
+
+def test_datasets_create_different_short_names(runner, client):
+    """Test creating datasets with same name but different short_name."""
+    result = runner.invoke(
+        cli, ['dataset', 'create', 'dataset', '--short-name', 'dataset-1']
+    )
+    assert 0 == result.exit_code
+    assert 'OK' in result.output
+
+    result = runner.invoke(
+        cli, ['dataset', 'create', 'dataset', '--short-name', 'dataset-2']
+    )
+    assert 0 == result.exit_code
+    assert 'OK' in result.output
+
+
+def test_datasets_create_with_same_name(runner, client):
+    """Test creating datasets with same name."""
+    result = runner.invoke(cli, ['dataset', 'create', 'dataset'])
+    assert 0 == result.exit_code
+    assert 'OK' in result.output
+
+    result = runner.invoke(cli, ['dataset', 'create', 'dataset'])
+    assert 1 == result.exit_code
+    assert 'Dataset exists: "dataset"' in result.output
+
+
+@pytest.mark.parametrize(
+    'name,short_name',
+    [('v.a.l.i.d_internal-name', 'v.a.l.i.d_internal-name'),
+     ('any name /@#$!', 'any_name'),
+     ('name longer than 24 characters', 'name_longer_than_24_char'),
+     ('semi valid-name', 'semi_validname'), ('dataset/new', 'datasetnew'),
+     ('/dataset', 'dataset'), ('dataset/', 'dataset')]
+)
+def test_datasets_valid_name(runner, client, name, short_name):
+    """Test creating datasets with valid name."""
+    result = runner.invoke(cli, ['dataset', 'create', name])
+    assert 0 == result.exit_code
+    assert 'Use the name "{}"'.format(short_name) in result.output
+    assert 'OK' in result.output
+
+    dataset = client.load_dataset(name=short_name)
+    assert dataset.name == name
+    assert dataset.short_name == short_name
+
+
 def test_datasets_create_dirty(runner, project, client):
     """Test creating a dataset in dirty repository."""
     # Create a file in root of the repository.
@@ -181,12 +250,16 @@ def test_dataset_create_exception_refs(runner, project, client):
     assert 'a' in result.output
 
 
-@pytest.mark.parametrize('name', ['dataset/new', '/dataset', 'dataset/'])
-def test_dataset_name_is_valid(client, runner, project, name):
-    """Test dataset name has no '/' character to avoid nested datasets."""
-    result = runner.invoke(cli, ['dataset', 'create', name])
+@pytest.mark.parametrize(
+    'creator,field', [('John Doe', 'Email'), ('John Doe<>', 'Email'),
+                      ('<john.doe@mail.ch>', 'Name'),
+                      ('John Doe<john.doe@mail>', 'Email')]
+)
+def test_dataset_creator_is_invalid(client, runner, creator, field):
+    """Test create dataset with invalid creator format."""
+    result = runner.invoke(cli, ['dataset', 'create', 'ds', '-c', creator])
     assert 2 == result.exit_code
-    assert 'is not valid' in result.output
+    assert field + ' is not valid' in result.output
 
 
 @pytest.mark.parametrize('output_format', DATASETS_FORMATS.keys())
@@ -665,6 +738,33 @@ def test_datasets_ls_files_correct_paths(tmpdir, runner, project):
         assert Path(record['path']).exists()
 
 
+def test_datasets_ls_files_with_display_name(directory_tree, runner, project):
+    """Test listing of data within dataset with include/exclude filters."""
+    # create a dataset
+    result = runner.invoke(
+        cli, ['dataset', 'create', 'my-dataset', '--short-name', 'short-name']
+    )
+    assert 0 == result.exit_code
+
+    # add data to dataset
+    result = runner.invoke(
+        cli,
+        ['dataset', 'add', 'short-name', directory_tree.strpath],
+        catch_exceptions=False,
+    )
+    assert 0 == result.exit_code
+
+    # list files with dataset name
+    result = runner.invoke(cli, ['dataset', 'ls-files', 'my-dataset'])
+    assert 0 == result.exit_code
+    assert 'dir2/file2' not in result.output
+
+    # list files with short_name
+    result = runner.invoke(cli, ['dataset', 'ls-files', 'short-name'])
+    assert 0 == result.exit_code
+    assert 'dir2/file2' in result.output
+
+
 def test_dataset_unlink_file_not_found(runner, project):
     """Test unlinking of file from dataset with no files found."""
     # create a dataset
@@ -861,7 +961,7 @@ def test_dataset_date_created_format(runner, client, project):
     assert 0 == result.exit_code
     assert 'OK' in result.output
 
-    path = client.dataset_path('dataset')
+    path = client.get_dataset_path('dataset')
     assert path.exists()
 
     with path.open(mode='r') as fp:
@@ -880,7 +980,7 @@ def test_dataset_file_date_created_format(tmpdir, runner, client, project):
     assert 0 == result.exit_code
     assert 'OK' in result.output
 
-    path = client.dataset_path('dataset')
+    path = client.get_dataset_path('dataset')
     assert path.exists()
 
     # Create data file.
diff --git a/tests/cli/test_integration_datasets.py b/tests/cli/test_integration_datasets.py
index 06f94c8b29..8743d811fd 100644
--- a/tests/cli/test_integration_datasets.py
+++ b/tests/cli/test_integration_datasets.py
@@ -545,8 +545,7 @@ def test_add_from_git_copies_metadata(runner, client):
     )
     assert 0 == result.exit_code
 
-    path = client.dataset_path('remote')
-    dataset = client.get_dataset(path)
+    dataset = client.load_dataset('remote')
     assert dataset.files[0].name == 'README.rst'
     assert 'mailto:jiri.kuncar@gmail.com' in str(dataset.files[0].creator)
     assert 'mailto:rokroskar@gmail.co' in str(dataset.files[0].creator)
@@ -596,7 +595,7 @@ def test_usage_error_in_add_from_git(runner, client, params, n_urls, message):
 def read_dataset_file_metadata(client, dataset_name, filename):
     """Return metadata from dataset's YAML file."""
     with client.with_dataset(dataset_name) as dataset:
-        assert client.dataset_path(dataset.name).exists()
+        assert client.get_dataset_path(dataset.name).exists()
 
         for file_ in dataset.files:
             if file_.path.endswith(filename):
diff --git a/tests/core/commands/test_dataset.py b/tests/core/commands/test_dataset.py
index 481b054738..bcc4a5842b 100644
--- a/tests/core/commands/test_dataset.py
+++ b/tests/core/commands/test_dataset.py
@@ -180,6 +180,12 @@ def test_dataset_serialization(dataset):
 
 def test_create_dataset_custom_message(project):
     """Test create dataset custom message."""
-    create_dataset('ds1', commit_message='my awesome dataset')
+    create_dataset(
+        'ds1',
+        short_name='',
+        description='',
+        creators=[],
+        commit_message='my awesome dataset'
+    )
     last_commit = Repo('.').head.commit
     assert 'my awesome dataset' == last_commit.message
diff --git a/tests/core/commands/test_serialization.py b/tests/core/commands/test_serialization.py
index a48eec81f2..1c29ec6768 100644
--- a/tests/core/commands/test_serialization.py
+++ b/tests/core/commands/test_serialization.py
@@ -31,7 +31,7 @@ def test_dataset_serialization(client, dataset, data_file):
     """Test Dataset serialization."""
 
     def load_dataset(name):
-        with open(str(client.dataset_path(name))) as f:
+        with open(str(client.get_dataset_path(name))) as f:
             return yaml.safe_load(f)
 
     d_dict = load_dataset('dataset')
@@ -54,7 +54,9 @@ def load_dataset(name):
 def test_dataset_deserialization(client, dataset):
     """Test Dataset deserialization."""
     from renku.core.models.datasets import Dataset
-    dataset_ = Dataset.from_yaml(client.dataset_path('dataset'), client=client)
+    dataset_ = Dataset.from_yaml(
+        client.get_dataset_path('dataset'), client=client
+    )
 
     dataset_types = {
         'created': datetime.datetime,