fix: user-related metadata (#655)

* fix: explicitly add nested metadata fields

* fix: set the blank node correctly

* chore(tests): add basic dataset serialization tests

* fix: omit "mailto" from email

Author: rokroskar

conftest.py

@@ -182,10 +182,12 @@ def client(project):
 def dataset(client):
     """Create a dataset."""
     with client.with_dataset(name='dataset') as dataset:
-        dataset.author = {
-            'name': 'me',
+        dataset.creator = [{
+            'affiliation': 'xxx',
             'email': 'me@example.com',
-        }
+            '_id': 'me_id',
+            'name': 'me',
+        }]
     return dataset
 
 

renku/models/datasets.py

@@ -128,13 +128,13 @@ def default_id(self):
         """Set the default id."""
         if self.email:
             return 'mailto:{email}'.format(email=self.email)
-        return '_' + str(uuid.uuid4())
+        return '_:{}'.format(str(uuid.uuid4()))
 
     def __attrs_post_init__(self):
         """Finish object initialization."""
         # handle the case where ids were improperly set
         if self._id == 'mailto:None':
-            self._id = '_' + str(uuid.uuid4())
+            self._id = self.default_id()
 
 
 @attr.s
@@ -289,6 +289,10 @@ def _convert_keyword(keywords):
 @jsonld.s(
     type='schema:Dataset',
     context={
+        'added': 'schema:dateCreated',
+        'affiliation': 'schema:affiliation',
+        'alternate_name': 'schema:alternateName',
+        'email': 'schema:email',
         'schema': 'http://schema.org/',
     },
 )
@@ -317,7 +321,7 @@ class Dataset(Entity, CreatorsMixin):
     )
 
     description = jsonld.ib(
-        default=None, context='schema:description', kw_only=True
+        default='', context='schema:description', kw_only=True
     )
 
     identifier = jsonld.ib(

renku/models/provenance/agents.py

@@ -39,17 +39,14 @@ class Person:
     """Represent a person."""
 
     name = jsonld.ib(context='rdfs:label')
-    email = jsonld.ib(context={
-        '@type': '@id',
-        '@id': 'schema:email',
-    })
+    email = jsonld.ib(context='schema:email')
 
     _id = jsonld.ib(context='@id', init=False, kw_only=True)
 
     @_id.default
     def default_id(self):
         """Configure calculated ID."""
-        return self.email
+        return 'mailto:{0}'.format(self.email)
 
     @email.validator
     def check_email(self, attribute, value):
@@ -62,7 +59,7 @@ def from_commit(cls, commit):
         """Create an instance from a Git commit."""
         return cls(
             name=commit.author.name,
-            email='mailto:{0}'.format(commit.author.email),
+            email=commit.author.email,
         )
 
 
@@ -79,7 +76,7 @@ def from_commit(cls, commit):
     slots=True,
 )
 class SoftwareAgent:
-    """Represent a person."""
+    """Represent executed software."""
 
     label = jsonld.ib(context='rdfs:label', kw_only=True)
     was_started_by = jsonld.ib(

tests/test_dataset.py

@@ -24,9 +24,8 @@
 
 import git
 import pytest
-import yaml
 
-from renku.models.datasets import Creator, Dataset, DatasetFile
+from renku.models.datasets import Creator, DatasetFile
 
 
 def _key(client, dataset, filename):
@@ -121,23 +120,6 @@ def test_data_add_recursive(directory_tree, client):
         ) == 'dir2'
 
 
-def dataset_serialization(client, dataset, data_file):
-    """Test deserializing a dataset object."""
-    with open(dataset.path / 'metadata.yml', 'r') as f:
-        source = yaml.safe_load(f)
-
-    dataset = Dataset.from_jsonld(source)
-    assert dataset.path == dataset.path
-
-    d_dict = dataset.to_dict()
-
-    assert all([key in d_dict for key in ('name', 'identifier', 'files')])
-    assert not len(d_dict['files'].values())
-    client.add_data_to_dataset(dataset, [str(data_file)])
-    d_dict = dataset.to_dict()
-    assert len(d_dict['files'].values())
-
-
 def test_git_repo_import(client, dataset, tmpdir, data_repository):
     """Test an import from a git repository."""
     # add data from local repo

tests/test_serialization.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2017-2019- Swiss Data Science Center (SDSC)
+# A partnership between École Polytechnique Fédérale de Lausanne (EPFL) and
+# Eidgenössische Technische Hochschule Zürich (ETHZ).
+#
+# 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.
+"""Serialization tests for renku models."""
+
+import datetime
+
+import yaml
+
+
+def test_dataset_serialization(client, dataset, data_file):
+    """Test Dataset serialization."""
+
+    def load_dataset(name):
+        with open(str(client.dataset_path(name))) as f:
+            return yaml.safe_load(f)
+
+    d_dict = load_dataset('dataset')
+
+    expected_fields = [
+        '_id', '_label', '_project', 'created', 'creator', 'date_published',
+        'description', 'files', 'identifier', 'in_language', 'keywords',
+        'license', 'name', 'path', 'url', 'version'
+    ]
+    for field in expected_fields:
+        assert field in d_dict
+
+    assert not d_dict['files']
+    client.add_data_to_dataset(dataset, [str(data_file)])
+    dataset.to_yaml()
+    d_dict = load_dataset('dataset')
+    assert d_dict['files']
+
+
+def test_dataset_deserialization(client, dataset):
+    """Test Dataset deserialization."""
+    from renku.models.datasets import Dataset
+    dataset_ = Dataset.from_yaml(client.dataset_path('dataset'), client=client)
+
+    dataset_types = {
+        'created': datetime.datetime,
+        'creator': list,
+        'description': str,
+        'files': list,
+        'identifier': str,
+        'keywords': list,
+    }
+
+    for attribute, type_ in dataset_types.items():
+        assert type(dataset_.__getattribute__(attribute)) is type_
+
+    creator_types = {'email': str, '_id': str, 'name': str, 'affiliation': str}
+
+    creator = dataset.creator[0]
+
+    for attribute, type_ in creator_types.items():
+        assert type(creator.get(attribute)) is type_