Add visibility and naming tests for FittingResult

Author: helenst

weblab/conftest.py

@@ -42,6 +42,13 @@ def add_version(entity,
             populate_entity_cache(entity)
         return commit
 
+    @staticmethod
+    def cached_version(entity, **kwargs):
+        """Add a single commit/version to an entity and return the relevant repocache entry"""
+        assert kwargs.get('cache', True), "Cache must be true for cached version"
+        version = Helpers.add_version(entity, **kwargs)
+        return entity.repocache.get_version(version.sha)
+
     @staticmethod
     def add_fake_version(entity, visibility='private', date=None, message='cache-only commit'):
         """Add a new commit/version only in the cache, not in git."""
@@ -154,6 +161,19 @@ def public_protocol(helpers):
     return protocol
 
 
+@pytest.fixture
+def public_fittingspec(helpers):
+    fittingspec = recipes.fittingspec.make()
+    helpers.add_version(fittingspec, visibility='public')
+    return fittingspec
+
+
+@pytest.fixture
+def public_dataset(helpers):
+    dataset = recipes.dataset.make(visibility='public')
+    return dataset
+
+
 @pytest.fixture
 def moderated_model(helpers):
     model = recipes.model.make()
@@ -331,3 +351,17 @@ def my_dataset_with_file(logged_in_user, helpers, public_protocol, client):
     )
     yield dataset
     dataset.delete()
+
+
+@pytest.fixture
+def fittingresult_version(public_model, public_protocol, public_fittingspec, public_dataset):
+    return recipes.fittingresult_version.make(
+        status='SUCCESS',
+        fittingresult__model=public_model,
+        fittingresult__model_version=public_model.repocache.latest_version,
+        fittingresult__protocol=public_protocol,
+        fittingresult__protocol_version=public_protocol.repocache.latest_version,
+        fittingresult__fittingspec=public_fittingspec,
+        fittingresult__fittingspec_version=public_fittingspec.repocache.latest_version,
+        fittingresult__dataset=public_dataset,
+    )

weblab/core/recipes.py

@@ -30,6 +30,10 @@
 cached_protocol_version = Recipe('CachedProtocolVersion')
 cached_protocol_tag = Recipe('CachedProtocolTag')
 
+cached_fittingspec = Recipe('CachedFittingSpec')
+cached_fittingspec_version = Recipe('CachedFittingSpecVersion')
+cached_fittingspec_tag = Recipe('CachedFittingSpecTag')
+
 experiment = Recipe(
     'Experiment',
     model=foreign_key(model),
@@ -51,3 +55,16 @@
 
 dataset_file = Recipe('DatasetFile',
                       dataset=foreign_key(dataset))
+
+fittingresult = Recipe(
+    'FittingResult',
+    model=foreign_key(model),
+    model_version=foreign_key(cached_model_version),
+    protocol=foreign_key(protocol),
+    protocol_version=foreign_key(cached_protocol_version),
+    fittingspec=foreign_key(fittingspec),
+    fittingspec_version=foreign_key(cached_fittingspec_version),
+    dataset=foreign_key(dataset),
+)
+
+fittingresult_version = Recipe('FittingResultVersion', fittingresult=foreign_key(fittingresult))

weblab/fitting/models.py

@@ -10,6 +10,7 @@
     ProtocolEntity,
 )
 from experiments.models import Runnable
+from repocache.models import CachedModelVersion, CachedProtocolVersion, CachedFittingSpecVersion
 
 
 class FittingSpec(Entity):
@@ -75,13 +76,9 @@ class FittingResult(UserCreatedModelMixin, models.Model):
     model = models.ForeignKey(ModelEntity, related_name='model_fitting_results')
     protocol = models.ForeignKey(ProtocolEntity, related_name='protocol_fitting_results')
 
-    # Note that we can't use a ForeignKey here, because versions of models, protocols & fitting
-    # specs are not stored in the DB - they are just commits in the associated git repo.
-    # We could link to the repocache tables, but those aren't guaranteed to exist or be permanent.
-    # So instead we store the full git SHA as a string.
-    fittingspec_version = models.CharField(max_length=50)
-    model_version = models.CharField(max_length=50)
-    protocol_version = models.CharField(max_length=50)
+    model_version = models.ForeignKey(CachedModelVersion, default=None, null=False, related_name='model_ver_fitres')
+    protocol_version = models.ForeignKey(CachedProtocolVersion, default=None, null=False, related_name='pro_ver_fitres')
+    fittingspec_version = models.ForeignKey(CachedFittingSpecVersion, default=None, null=False, related_name='fit_ver_fitres')
 
     class Meta:
         unique_together = ('fittingspec', 'dataset', 'model', 'protocol',
@@ -102,16 +99,10 @@ def name(self):
     @property
     def visibility(self):
         return get_joint_visibility(
-            self.fittingspec.get_version_visibility(
-                self.fittingspec_version,
-                default=self.fittingspec.DEFAULT_VISIBILITY),
+            self.fittingspec_version.visibility,
             self.dataset.visibility,
-            self.model.get_version_visibility(
-                self.model_version,
-                default=self.model.DEFAULT_VISIBILITY),
-            self.protocol.get_version_visibility(
-                self.protocol_version,
-                default=self.protocol.DEFAULT_VISIBILITY),
+            self.model_version.visibility,
+            self.protocol_version.visibility,
         )
 
     @property
@@ -148,18 +139,18 @@ def latest_version(self):
     @property
     def nice_model_version(self):
         """Use tags to give a nicer representation of the commit id"""
-        return self.model.nice_version(self.model_version)
+        return self.model_version.nice_version()
 
     @property
     def nice_protocol_version(self):
         """Use tags to give a nicer representation of the commit id"""
-        return self.protocol.nice_version(self.protocol_version)
+        return self.protocol_version.nice_version()
 
     @property
     def latest_result(self):
         try:
             return self.latest_version.status
-        except FittingResultVersion.DoesNotExist:
+        except Runnable.DoesNotExist:
             return ''
 
 

weblab/fitting/tests/test_models.py

@@ -1,10 +1,14 @@
+from datetime import date
+
 import pytest
 from django.db.utils import IntegrityError
 from django.shortcuts import get_object_or_404
 from guardian.shortcuts import assign_perm
 
 from core import recipes
+from datasets.models import Dataset
 from repocache.models import CachedFittingSpec
+from repocache.populate import populate_entity_cache
 
 
 @pytest.mark.django_db
@@ -86,3 +90,161 @@ def test_get_repocache(self):
         assert CachedFittingSpec.objects.count() == 1
         spec.delete()
         assert CachedFittingSpec.objects.count() == 0
+
+
+@pytest.mark.django_db
+class TestFittingResult:
+    def test_name(self, helpers):
+        model = recipes.model.make(name='my model')
+        protocol = recipes.protocol.make(name='my protocol')
+        dataset = recipes.dataset.make(name='my dataset')
+        fittingspec = recipes.fittingspec.make(name='my fitting spec')
+
+        model_version = helpers.add_version(model, tag_name='v1')
+        protocol_version = helpers.add_version(protocol, tag_name='v2')
+        fittingspec_version = helpers.add_version(fittingspec, tag_name='v3')
+
+        fitres = recipes.fittingresult.make(
+            model=model,
+            model_version=model.repocache.get_version(model_version.sha),
+            protocol=protocol,
+            protocol_version=protocol.repocache.get_version(protocol_version.sha),
+            fittingspec=fittingspec,
+            fittingspec_version=fittingspec.repocache.get_version(fittingspec_version.sha),
+            dataset=dataset,
+        )
+
+        assert str(fitres) == fitres.name == 'Fit my model to my dataset using my fitting spec'
+
+    def test_latest_version(self):
+        v1 = recipes.fittingresult_version.make(created_at=date(2017, 1, 2))
+        v2 = recipes.fittingresult_version.make(fittingresult=v1.fittingresult, created_at=date(2017, 1, 3))
+
+        assert v1.fittingresult.latest_version == v2
+        assert not v1.is_latest
+        assert v2.is_latest
+
+    def test_latest_result(self):
+        ver = recipes.fittingresult_version.make(created_at=date(2017, 1, 2), status='FAILED')
+
+        assert ver.fittingresult.latest_result == 'FAILED'
+
+    def test_latest_result_empty_if_no_versions(self):
+        fitres = recipes.fittingresult.make()
+
+        assert fitres.latest_result == ''
+
+    def test_nice_versions(self, fittingresult_version):
+        fitres = fittingresult_version.fittingresult
+
+        assert fitres.nice_model_version == fitres.model.repocache.latest_version.sha[:8] + '...'
+        assert fitres.nice_protocol_version == fitres.protocol.repocache.latest_version.sha[:8] + '...'
+
+        fitres.model.repo.tag('v1')
+        populate_entity_cache(fitres.model)
+        assert fitres.nice_model_version == 'v1'
+
+        fitres.protocol.repo.tag('v2')
+        populate_entity_cache(fitres.protocol)
+
+        assert fitres.nice_protocol_version == 'v2'
+
+    def test_visibility(self, helpers):
+        model = recipes.model.make()
+        protocol = recipes.protocol.make()
+        ds1 = recipes.dataset.make(visibility='private')
+        ds2 = recipes.dataset.make(visibility='public')
+        fittingspec = recipes.fittingspec.make()
+
+        mv1 = helpers.cached_version(model, visibility='private')
+        mv2 = helpers.cached_version(model, visibility='public')
+        pv1 = helpers.cached_version(protocol, visibility='private')
+        pv2 = helpers.cached_version(protocol, visibility='public')
+        fv1 = helpers.cached_version(fittingspec, visibility='private')
+        fv2 = helpers.cached_version(fittingspec, visibility='public')
+
+        # all public
+        assert recipes.fittingresult.make(
+            model=model, model_version=mv2,
+            protocol=protocol, protocol_version=pv2,
+            fittingspec=fittingspec, fittingspec_version=fv2,
+            dataset=ds2,
+        ).visibility == 'public'
+
+        # all private
+        assert recipes.fittingresult.make(
+            model=model, model_version=mv1,
+            protocol=protocol, protocol_version=pv1,
+            fittingspec=fittingspec, fittingspec_version=fv1,
+            dataset=ds1,
+        ).visibility == 'private'
+
+        # model private version => private
+        assert recipes.fittingresult.make(
+            model=model, model_version=mv1,
+            protocol=protocol, protocol_version=pv2,
+            fittingspec=fittingspec, fittingspec_version=fv2,
+            dataset=ds2,
+        ).visibility == 'private'
+
+        # protocol private version => private
+        assert recipes.fittingresult.make(
+            model=model, model_version=mv2,
+            protocol=protocol, protocol_version=pv1,
+            fittingspec=fittingspec, fittingspec_version=fv2,
+            dataset=ds2,
+        ).visibility == 'private'
+
+        # fitting spec private version => private
+        assert recipes.fittingresult.make(
+            model=model, model_version=mv2,
+            protocol=protocol, protocol_version=pv2,
+            fittingspec=fittingspec, fittingspec_version=fv1,
+            dataset=ds2,
+        ).visibility == 'private'
+
+        # dataset private version => private
+        assert recipes.fittingresult.make(
+            model=model, model_version=mv2,
+            protocol=protocol, protocol_version=pv2,
+            fittingspec=fittingspec, fittingspec_version=fv2,
+            dataset=ds1,
+        ).visibility == 'private'
+
+    def test_viewers(self, helpers, user):
+        helpers.add_permission(user, 'create_model')
+        helpers.add_permission(user, 'create_protocol')
+        helpers.add_permission(user, 'create_fittingspec')
+        helpers.add_permission(user, 'create_dataset', model=Dataset)
+
+        model = recipes.model.make()
+        protocol = recipes.protocol.make()
+        fittingspec = recipes.fittingspec.make()
+        # Datasets do not currently support collaborators
+        # (https://github.com/ModellingWebLab/WebLab/issues/247)
+        # so test with a public dataset for now
+        dataset = recipes.dataset.make(visibility='public')
+        mv = helpers.cached_version(model, visibility='private')
+        pv = helpers.cached_version(protocol, visibility='private')
+        fv = helpers.cached_version(fittingspec, visibility='private')
+
+        fr = recipes.fittingresult.make(
+            model=model, model_version=mv,
+            protocol=protocol, protocol_version=pv,
+            fittingspec=fittingspec, fittingspec_version=fv,
+            dataset=dataset,
+        )
+        assert user not in fr.viewers
+        assert not fr.is_visible_to_user(user)
+
+        fr.model.add_collaborator(user)
+        assert user not in fr.viewers
+        assert not fr.is_visible_to_user(user)
+
+        fr.protocol.add_collaborator(user)
+        assert user not in fr.viewers
+        assert not fr.is_visible_to_user(user)
+
+        fr.fittingspec.add_collaborator(user)
+        assert user in fr.viewers
+        assert fr.is_visible_to_user(user)