Exemplo n.º 1
0
    def test_source_version_delete(self):
        source = SourceFactory(version=HEAD)
        concept = ConceptFactory(mnemonic='concept1',
                                 version=HEAD,
                                 sources=[source],
                                 parent=source)

        self.assertTrue(source.is_latest_version)
        self.assertEqual(concept.sources.count(), 1)

        version1 = SourceFactory.build(name='version1',
                                       version='v1',
                                       mnemonic=source.mnemonic,
                                       organization=source.organization)
        Source.persist_new_version(version1, source.created_by)
        source.refresh_from_db()

        self.assertEqual(concept.sources.count(), 2)
        self.assertTrue(version1.is_latest_version)
        self.assertFalse(source.is_latest_version)

        source_versions = Source.objects.filter(
            mnemonic=source.mnemonic,
            version='v1',
        )
        self.assertTrue(source_versions.exists())
        self.assertEqual(version1.concepts.count(), 1)

        version1.delete()
        source.refresh_from_db()

        self.assertFalse(
            Source.objects.filter(
                version='v1',
                mnemonic=source.mnemonic,
            ).exists())
        self.assertTrue(source.is_latest_version)
        self.assertEqual(concept.sources.count(), 1)

        with self.assertRaises(ValidationError) as ex:
            source.delete()

        self.assertEqual(ex.exception.message_dict, {
            'detail': ['Cannot delete only version.'],
        })
Exemplo n.º 2
0
    def test_user_active_inactive_should_affect_children(self):
        user = UserProfileFactory(is_active=True)
        source = SourceFactory(user=user, is_active=True)
        collection = CollectionFactory(user=user, is_active=True)

        user.is_active = False
        user.save()
        source.refresh_from_db()
        collection.refresh_from_db()

        self.assertFalse(user.is_active)
        self.assertFalse(source.is_active)
        self.assertFalse(collection.is_active)

        user.is_active = True
        user.save()
        source.refresh_from_db()
        collection.refresh_from_db()

        self.assertTrue(user.is_active)
        self.assertTrue(source.is_active)
        self.assertTrue(collection.is_active)
Exemplo n.º 3
0
    def test_org_active_inactive_should_affect_children(self):
        org = OrganizationFactory(is_active=True)
        source = SourceFactory(organization=org, is_active=True)
        collection = CollectionFactory(organization=org, is_active=True)

        org.is_active = False
        org.save()
        source.refresh_from_db()
        collection.refresh_from_db()

        self.assertFalse(org.is_active)
        self.assertFalse(source.is_active)
        self.assertFalse(collection.is_active)

        org.is_active = True
        org.save()
        source.refresh_from_db()
        collection.refresh_from_db()

        self.assertTrue(org.is_active)
        self.assertTrue(source.is_active)
        self.assertTrue(collection.is_active)
Exemplo n.º 4
0
    def test_persist_new_version(self):
        source = SourceFactory(version=HEAD)
        concept = ConceptFactory(mnemonic='concept1', parent=source)

        self.assertEqual(source.concepts_set.count(), 1)  # parent-child
        self.assertEqual(source.concepts.count(), 1)
        self.assertEqual(concept.sources.count(), 1)
        self.assertTrue(source.is_latest_version)

        version1 = SourceFactory.build(name='version1',
                                       version='v1',
                                       mnemonic=source.mnemonic,
                                       organization=source.organization)
        Source.persist_new_version(version1, source.created_by)
        source.refresh_from_db()

        self.assertFalse(source.is_latest_version)
        self.assertEqual(source.concepts_set.count(), 1)  # parent-child
        self.assertEqual(source.concepts.count(), 1)
        self.assertTrue(version1.is_latest_version)
        self.assertEqual(version1.concepts.count(), 1)
        self.assertEqual(version1.concepts_set.count(), 0)  # no direct child