Ejemplo n.º 1
0
    def setUp(self):
        self.user1 = User.objects.create(username='******',
                                         password='******',
                                         email='*****@*****.**',
                                         last_name='One',
                                         first_name='User')
        self.user2 = User.objects.create(username='******',
                                         email='*****@*****.**',
                                         last_name='Two',
                                         first_name='User')

        self.userprofile1 = UserProfile.objects.create(user=self.user1,
                                                       mnemonic='user1')
        self.userprofile2 = UserProfile.objects.create(user=self.user2,
                                                       mnemonic='user2')

        self.org1 = Organization.objects.create(name='org1', mnemonic='org1')
        self.org2 = Organization.objects.create(name='org2', mnemonic='org2')

        self.source1 = Source(name='source1',
                              mnemonic='source1',
                              full_name='Source One',
                              source_type='Dictionary',
                              public_access=ACCESS_TYPE_EDIT,
                              default_locale='en',
                              supported_locales=['en'],
                              website='www.source1.com',
                              description='This is the first test source')

        kwargs = {'parent_resource': self.org1}
        Source.persist_new(self.source1, self.user1, **kwargs)
        self.source1 = Source.objects.get(id=self.source1.id)

        self.source2 = Source(name='source2',
                              mnemonic='source2',
                              full_name='Source Two',
                              source_type='Reference',
                              public_access=ACCESS_TYPE_VIEW,
                              default_locale='fr',
                              supported_locales=['fr'],
                              website='www.source2.com',
                              description='This is the second test source')
        kwargs = {
            'parent_resource': self.org2,
        }
        Source.persist_new(self.source2, self.user2, **kwargs)
        self.source2 = Source.objects.get(id=self.source2.id)

        self.name = LocalizedText.objects.create(name='Fred', locale='es')
        self.description = LocalizedText.objects.create(name='guapo',
                                                        locale='es')
Ejemplo n.º 2
0
    def create_sources(self, org, user):
        sources = dict()

        kwargs = {'parent_resource': org}

        for source_name in [
                'Locales', 'Classes', 'Datatypes', 'DescriptionTypes',
                'NameTypes', 'MapTypes'
        ]:
            source = None

            if Source.objects.filter(parent_id=org.id,
                                     mnemonic=source_name).count() < 1:
                source = Source(name=source_name,
                                mnemonic=source_name,
                                full_name=source_name,
                                parent=org,
                                created_by=user,
                                default_locale='en',
                                supported_locales=['en'],
                                updated_by=user)
                Source.persist_new(source, user, **kwargs)
            else:
                source = Source.objects.get(parent_id=org.id,
                                            mnemonic=source_name)
            sources[source_name] = source

        return sources
Ejemplo n.º 3
0
    def test_get_latest_version(self):
        source = Source(name='source',
                        mnemonic='source',
                        full_name='Source One',
                        source_type='Dictionary',
                        public_access=ACCESS_TYPE_EDIT,
                        default_locale='en',
                        supported_locales=['en'],
                        website='www.source1.com',
                        description='This is the first test source')
        kwargs = {'parent_resource': self.org1}
        Source.persist_new(source, self.user1, **kwargs)

        concept1 = Concept(
            mnemonic='concept12',
            created_by=self.user1,
            updated_by=self.user1,
            parent=source,
            concept_class='First',
            names=[LocalizedText.objects.create(name='User', locale='es')],
        )
        kwargs = {
            'parent_resource': source,
        }
        Concept.persist_new(concept1, self.user1, **kwargs)
        concept = Concept.objects.get(mnemonic=concept1.mnemonic)
        concept_version1 = ConceptVersion.objects.get(
            versioned_object_id=concept.id)
        self.assertEquals(concept.get_latest_version.id, concept_version1.id)
Ejemplo n.º 4
0
def create_source(user, validation_schema=None, organization=None):
    suffix = generate_random_string()

    source = Source(
        name="source{0}".format(suffix),
        mnemonic="source{0}".format(suffix),
        full_name="Source {0}".format(suffix),
        source_type='Dictionary',
        public_access=ACCESS_TYPE_EDIT,
        default_locale='en',
        supported_locales=['en'],
        website='www.source.com',
        description='This is a test source',
        custom_validation_schema=validation_schema
    )

    if organization is not None:
        kwargs = {
            'parent_resource': organization
        }
    else:
        kwargs = {
            'parent_resource': create_user_profile(user)
        }

    Source.persist_new(source, user, **kwargs)

    return Source.objects.get(id=source.id)
Ejemplo n.º 5
0
 def restore_object(self, attrs, instance=None):
     source = instance if instance else Source()
     source.mnemonic = attrs.get(self.Meta.lookup_field, source.mnemonic)
     source.name = attrs.get('name', source.name)
     source.full_name = attrs.get('full_name', source.full_name)
     source.description = attrs.get('description', source.description)
     source.source_type = attrs.get('source_type', source.source_type)
     source.custom_validation_schema = attrs.get('custom_validation_schema', source.custom_validation_schema)
     source.public_access = attrs.get('public_access', source.public_access or DEFAULT_ACCESS_TYPE)
     source.default_locale = attrs.get('default_locale', source.default_locale or Common.DEFAULT_LOCALE)
     source.website = attrs.get('website', source.website)
     source.supported_locales = attrs.get('supported_locales').split(',') if attrs.get('supported_locales') else source.supported_locales
     source.extras = attrs.get('extras', source.extras)
     source.external_id = attrs.get('external_id', source.external_id)
     return source
Ejemplo n.º 6
0
    def test_get_head_of_when_head_does_not_exist(self):
        source = Source(name='source2',
                        mnemonic='source2',
                        full_name='Source Two',
                        source_type='Dictionary',
                        public_access=ACCESS_TYPE_EDIT,
                        default_locale='en',
                        supported_locales=['en'],
                        website='www.source2.com',
                        description='This is not the first test source')

        kwargs = {'parent_resource': self.profile}
        Source.persist_new(source, self.user, **kwargs)
        source.get_version_model().objects.get(
            mnemonic='HEAD', versioned_object_id=source.id).delete()
        self.assertIsNone(SourceVersion.get_head_of(source))
Ejemplo n.º 7
0
    def create_source(self, user, org, name):
        kwargs = {'parent_resource': org}

        if Source.objects.filter(parent_id=org.id, mnemonic=name).count() < 1:
            source = Source(name=name,
                            mnemonic=name,
                            full_name=name,
                            parent=org,
                            created_by=user,
                            default_locale='en',
                            supported_locales=['en'],
                            updated_by=user)
            Source.persist_new(source, user, **kwargs)
        else:
            source = Source.objects.get(parent_id=org.id, mnemonic=name)

        return source
Ejemplo n.º 8
0
    def setUp(self):
        self.user = User.objects.create(username='******', email='*****@*****.**', last_name='One', first_name='User')
        self.profile = UserProfile.objects.create(user=self.user, mnemonic='user')
        self.org = Organization.objects.create(name='org', mnemonic='org')

        self.source = Source(name='source',
            mnemonic='source',
            full_name='Source One',
            source_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.source.com',
            description='This is the first test source'
        )

        kwargs = {
            'parent_resource': self.profile
        }
        Source.persist_new(self.source, self.user, **kwargs)
        self.source = Source.objects.get(id=self.source.id)
Ejemplo n.º 9
0
    def test_collections_version_ids(self):
        kwargs = {
            'parent_resource': self.userprofile1
        }

        collection = Collection(
            name='collection2',
            mnemonic='collection2',
            full_name='Collection Two',
            collection_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.collection2.com',
            description='This is the second test collection'
        )
        Collection.persist_new(collection, self.user1, **kwargs)

        source = Source(
            name='source',
            mnemonic='source',
            full_name='Source One',
            source_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.source1.com',
            description='This is the first test source'
        )
        kwargs = {
            'parent_resource': self.org1
        }
        Source.persist_new(source, self.user1, **kwargs)

        (concept1, errors) = create_concept(mnemonic='concept12', user=self.user1, source=source)
        (from_concept, errors) = create_concept(mnemonic='fromConcept', user=self.user1, source=source)
        (to_concept, errors) = create_concept(mnemonic='toConcept', user=self.user1, source=source)

        mapping = Mapping(
            map_type='Same As',
            from_concept=from_concept,
            to_concept=to_concept,
            external_id='mapping',
        )
        kwargs = {
            'parent_resource': source,
        }

        Mapping.persist_new(mapping, self.user1, **kwargs)

        mapping = Mapping.objects.filter()[1]
        mapping_reference = '/orgs/org1/sources/source/mappings/' + mapping.id + '/'

        references = [mapping_reference]

        collection.expressions = references
        collection.full_clean()
        collection.save()

        mapping_version = MappingVersion.objects.filter()[0]
        collection_version = CollectionVersion(
            name='version1',
            mnemonic='version1',
            versioned_object=collection,
            released=True,
            created_by=self.user1,
            updated_by=self.user1,
            mappings=[mapping_version.id]
        )
        collection_version.full_clean()
        collection_version.save()

        self.assertEquals(mapping_version.collection_version_ids, [collection_version.id])
Ejemplo n.º 10
0
    def setUp(self):
        super(MappingBaseTest, self).setUp()
        self.user1 = User.objects.create_user(
            username='******',
            email='*****@*****.**',
            password='******',
            last_name='One',
            first_name='User'
        )
        self.user2 = User.objects.create_user(
            username='******',
            email='*****@*****.**',
            password='******',
            last_name='Two',
            first_name='User'
        )

        self.userprofile1 = UserProfile.objects.create(user=self.user1, mnemonic='user1')
        self.userprofile2 = UserProfile.objects.create(user=self.user2, mnemonic='user2')

        self.org1 = Organization.objects.create(name='org1', mnemonic='org1')
        self.org2 = Organization.objects.create(name='org2', mnemonic='org2')
        add_user_to_org(self.userprofile2, self.org2)

        self.source1 = Source(
            name='source1',
            mnemonic='source1',
            full_name='Source One',
            source_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.source1.com',
            description='This is the first test source',
        )
        kwargs = {
            'parent_resource': self.userprofile1
        }
        Source.persist_new(self.source1, self.user1, **kwargs)
        self.source1 = Source.objects.get(id=self.source1.id)

        self.source2 = Source(
            name='source2',
            mnemonic='source2',
            full_name='Source Two',
            source_type='Reference',
            public_access=ACCESS_TYPE_VIEW,
            default_locale='fr',
            supported_locales=['fr'],
            website='www.source2.com',
            description='This is the second test source',
        )
        kwargs = {
            'parent_resource': self.org2,
        }
        Source.persist_new(self.source2, self.user1, **kwargs)
        self.source2 = Source.objects.get(id=self.source2.id)

        self.name = LocalizedText.objects.create(name='Fred', locale='en', type='FULLY_SPECIFIED')

        (self.concept1, errors) = create_concept(mnemonic='concept1', user=self.user1, source=self.source1, names=[self.name], descriptions=[self.name])
        (self.concept2, errors) = create_concept(mnemonic='concept2', user=self.user1, source=self.source1, names=[self.name], descriptions=[self.name])
        (self.concept3, errors) = create_concept(mnemonic='concept3', user=self.user1, source=self.source2, names=[self.name], descriptions=[self.name])
        (self.concept4, errors) = create_concept(mnemonic='concept4', user=self.user1, source=self.source2, names=[self.name], descriptions=[self.name])
Ejemplo n.º 11
0
    def test_collections_ids(self):
        kwargs = {
            'parent_resource': self.userprofile1
        }

        collection = Collection(
            name='collection2',
            mnemonic='collection2',
            full_name='Collection Two',
            collection_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.collection2.com',
            description='This is the second test collection'
        )
        Collection.persist_new(collection, self.user1, **kwargs)

        source = Source(
            name='source',
            mnemonic='source',
            full_name='Source One',
            source_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.source1.com',
            description='This is the first test source'
        )
        kwargs = {
            'parent_resource': self.org1
        }
        Source.persist_new(source, self.user1, **kwargs)

        (concept1, errors) = create_concept(mnemonic='concept12', user=self.user1, source=source)
        (from_concept, errors) = create_concept(mnemonic='fromConcept', user=self.user1, source=source)
        (to_concept, errors) = create_concept(mnemonic='toConcept', user=self.user1, source=source)

        mapping = Mapping(
            map_type='Same As',
            from_concept=from_concept,
            to_concept=to_concept,
            external_id='mapping',
        )
        kwargs = {
            'parent_resource': source,
        }

        Mapping.persist_new(mapping, self.user1, **kwargs)
        initial_mapping_version = MappingVersion.objects.get(versioned_object_id=mapping.id)
        new_mapping_version = MappingVersion.for_mapping(mapping)
        new_mapping_version.mnemonic = 98
        new_mapping_version.save()

        from_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(mnemonic=from_concept.mnemonic).mnemonic + '/'
        concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(mnemonic=concept1.mnemonic).mnemonic + '/'
        mapping = Mapping.objects.filter()[1]
        references = [concept1_reference, from_concept_reference, mapping.uri, initial_mapping_version.uri]

        collection.expressions = references
        collection.full_clean()
        collection.save()
        self.assertEquals(initial_mapping_version.collection_ids, [collection.id])
        self.assertEquals(new_mapping_version.collection_ids, [collection.id])
Ejemplo n.º 12
0
    def test_collections_version_ids(self):
        kwargs = {'parent_resource': self.userprofile1}

        collection = Collection(
            name='collection2',
            mnemonic='collection2',
            full_name='Collection Two',
            collection_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.collection2.com',
            description='This is the second test collection')
        Collection.persist_new(collection, self.user1, **kwargs)

        source = Source(name='source',
                        mnemonic='source',
                        full_name='Source One',
                        source_type='Dictionary',
                        public_access=ACCESS_TYPE_EDIT,
                        default_locale='en',
                        supported_locales=['en'],
                        website='www.source1.com',
                        description='This is the first test source')
        kwargs = {'parent_resource': self.org1}
        Source.persist_new(source, self.user1, **kwargs)

        concept1 = Concept(
            mnemonic='concept12',
            created_by=self.user1,
            updated_by=self.user1,
            parent=source,
            concept_class='First',
            names=[LocalizedText.objects.create(name='User', locale='es')],
        )
        kwargs = {
            'parent_resource': source,
        }
        Concept.persist_new(concept1, self.user1, **kwargs)

        another_concept = Concept(
            mnemonic='anotherConcept',
            created_by=self.user1,
            updated_by=self.user1,
            parent=source,
            concept_class='First',
            names=[LocalizedText.objects.create(name='User', locale='es')],
        )
        kwargs = {
            'parent_resource': source,
        }
        Concept.persist_new(another_concept, self.user1, **kwargs)

        another_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
            mnemonic=another_concept.mnemonic).mnemonic + '/'
        concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
            mnemonic=concept1.mnemonic).mnemonic + '/'

        references = [concept1_reference, another_concept_reference]

        collection.expressions = references
        collection.full_clean()
        collection.save()

        concept_version = ConceptVersion.objects.get(
            versioned_object_id=Concept.objects.get(
                mnemonic=another_concept.mnemonic).id)

        version = CollectionVersion.for_base_object(collection, 'version1')
        kwargs = {}
        CollectionVersion.persist_new(version, **kwargs)
        self.assertEquals(
            concept_version.collection_version_ids,
            [CollectionVersion.objects.get(mnemonic='version1').id])
Ejemplo n.º 13
0
    def create_sources(self, org, user):
        sources = dict()
        source = None

        kwargs = {'parent_resource': org}

        if Source.objects.filter(parent_id=org.id,
                                 mnemonic='Locales').count() < 1:
            source = Source(name='Locales',
                            mnemonic='Locales',
                            full_name='Locales',
                            parent=org,
                            created_by=user,
                            updated_by=user)
            Source.persist_new(source, user, **kwargs)

        else:
            source = Source.objects.get(parent_id=org.id, mnemonic='Locales')
        sources['Locales'] = source

        if Source.objects.filter(parent_id=org.id,
                                 mnemonic='Classes').count() < 1:
            source = Source(name='Classes',
                            mnemonic='Classes',
                            full_name='Classes',
                            parent=org,
                            created_by=user,
                            updated_by=user)
            Source.persist_new(source, user, **kwargs)

        else:
            source = Source.objects.get(parent_id=org.id, mnemonic='Classes')
        sources['Classes'] = source

        if Source.objects.filter(parent_id=org.id,
                                 mnemonic='Datatypes').count() < 1:
            source = Source(name='Datatypes',
                            mnemonic='Datatypes',
                            full_name='Datatypes',
                            parent=org,
                            created_by=user,
                            updated_by=user)
            Source.persist_new(source, user, **kwargs)

        else:
            source = Source.objects.get(parent_id=org.id, mnemonic='Datatypes')
        sources['Datatypes'] = source

        if Source.objects.filter(parent_id=org.id,
                                 mnemonic='DescriptionTypes').count() < 1:
            source = Source(name='DescriptionTypes',
                            mnemonic='DescriptionTypes',
                            full_name='DescriptionTypes',
                            parent=org,
                            created_by=user,
                            updated_by=user)
            Source.persist_new(source, user, **kwargs)

        else:
            source = Source.objects.get(parent_id=org.id,
                                        mnemonic='DescriptionTypes')
        sources['DescriptionTypes'] = source

        if Source.objects.filter(parent_id=org.id,
                                 mnemonic='NameTypes').count() < 1:
            source = Source(name='NameTypes',
                            mnemonic='NameTypes',
                            full_name='NameTypes',
                            parent=org,
                            created_by=user,
                            updated_by=user)
            Source.persist_new(source, user, **kwargs)

        else:
            source = Source.objects.get(parent_id=org.id, mnemonic='NameTypes')
        sources['NameTypes'] = source

        print sources

        return sources
Ejemplo n.º 14
0
    def test_collections_version_ids(self):
        kwargs = {'parent_resource': self.userprofile1}

        collection = Collection(
            name='collection2',
            mnemonic='collection2',
            full_name='Collection Two',
            collection_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.collection2.com',
            description='This is the second test collection')
        Collection.persist_new(collection, self.user1, **kwargs)

        source = Source(name='source',
                        mnemonic='source',
                        full_name='Source One',
                        source_type='Dictionary',
                        public_access=ACCESS_TYPE_EDIT,
                        default_locale='en',
                        supported_locales=['en'],
                        website='www.source1.com',
                        description='This is the first test source')
        kwargs = {'parent_resource': self.org1}
        Source.persist_new(source, self.user1, **kwargs)

        concept1 = Concept(
            mnemonic='concept12',
            created_by=self.user1,
            updated_by=self.user1,
            parent=source,
            concept_class='First',
            names=[LocalizedText.objects.create(name='User', locale='es')],
        )
        kwargs = {
            'parent_resource': source,
        }
        Concept.persist_new(concept1, self.user1, **kwargs)

        fromConcept = Concept(
            mnemonic='fromConcept',
            created_by=self.user1,
            updated_by=self.user1,
            parent=source,
            concept_class='First',
            names=[LocalizedText.objects.create(name='User', locale='es')],
        )
        kwargs = {
            'parent_resource': source,
        }
        Concept.persist_new(fromConcept, self.user1, **kwargs)

        toConcept = Concept(
            mnemonic='toConcept',
            created_by=self.user1,
            updated_by=self.user1,
            parent=source,
            concept_class='First',
            names=[LocalizedText.objects.create(name='User', locale='es')],
        )
        kwargs = {
            'parent_resource': source,
        }
        Concept.persist_new(toConcept, self.user1, **kwargs)

        mapping = Mapping(
            map_type='Same As',
            from_concept=fromConcept,
            to_concept=toConcept,
            external_id='mapping',
        )
        kwargs = {
            'parent_resource': source,
        }

        Mapping.persist_new(mapping, self.user1, **kwargs)

        from_concept_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
            mnemonic=fromConcept.mnemonic).mnemonic + '/'
        concept1_reference = '/orgs/org1/sources/source/concepts/' + Concept.objects.get(
            mnemonic=concept1.mnemonic).mnemonic + '/'
        mapping = Mapping.objects.filter()[1]
        mapping_reference = '/orgs/org1/sources/source/mappings/' + mapping.id + '/'

        references = [
            concept1_reference, from_concept_reference, mapping_reference
        ]

        collection.expressions = references
        collection.full_clean()
        collection.save()

        self.assertEquals(mapping.collection_version_ids, [
            Collection.objects.get(mnemonic=collection.mnemonic).get_head().id
        ])
Ejemplo n.º 15
0
    def setUp(self):
        self.user1 = User.objects.create_user(username='******',
                                              email='*****@*****.**',
                                              password='******',
                                              last_name='One',
                                              first_name='User')
        self.user2 = User.objects.create_user(username='******',
                                              email='*****@*****.**',
                                              password='******',
                                              last_name='Two',
                                              first_name='User')

        self.userprofile1 = UserProfile.objects.create(user=self.user1,
                                                       mnemonic='user1')
        self.userprofile2 = UserProfile.objects.create(user=self.user2,
                                                       mnemonic='user2')

        self.org1 = Organization.objects.create(name='org1', mnemonic='org1')
        self.org2 = Organization.objects.create(name='org2', mnemonic='org2')
        add_user_to_org(self.userprofile2, self.org2)

        self.source1 = Source(
            name='source1',
            mnemonic='source1',
            full_name='Source One',
            source_type='Dictionary',
            public_access=ACCESS_TYPE_EDIT,
            default_locale='en',
            supported_locales=['en'],
            website='www.source1.com',
            description='This is the first test source',
        )
        kwargs = {'parent_resource': self.userprofile1}
        Source.persist_new(self.source1, self.user1, **kwargs)
        self.source1 = Source.objects.get(id=self.source1.id)

        self.source2 = Source(
            name='source2',
            mnemonic='source2',
            full_name='Source Two',
            source_type='Reference',
            public_access=ACCESS_TYPE_VIEW,
            default_locale='fr',
            supported_locales=['fr'],
            website='www.source2.com',
            description='This is the second test source',
        )
        kwargs = {
            'parent_resource': self.org2,
        }
        Source.persist_new(self.source2, self.user1, **kwargs)
        self.source2 = Source.objects.get(id=self.source2.id)

        self.name = LocalizedText.objects.create(name='Fred', locale='en')

        self.concept1 = Concept(
            mnemonic='concept1',
            updated_by=self.user1,
            parent=self.source1,
            concept_class='First',
            names=[self.name],
        )
        kwargs = {
            'parent_resource': self.source1,
        }
        Concept.persist_new(self.concept1, self.user1, **kwargs)

        self.concept2 = Concept(
            mnemonic='concept2',
            updated_by=self.user1,
            parent=self.source1,
            concept_class='Second',
            names=[self.name],
        )
        kwargs = {
            'parent_resource': self.source1,
        }
        Concept.persist_new(self.concept2, self.user1, **kwargs)

        self.concept3 = Concept(
            mnemonic='concept3',
            updated_by=self.user1,
            parent=self.source2,
            concept_class='Third',
            names=[self.name],
        )
        kwargs = {
            'parent_resource': self.source2,
        }
        Concept.persist_new(self.concept3, self.user1, **kwargs)

        self.concept4 = Concept(
            mnemonic='concept4',
            updated_by=self.user2,
            parent=self.source2,
            concept_class='Fourth',
            names=[self.name],
        )
        kwargs = {
            'parent_resource': self.source2,
        }
        Concept.persist_new(self.concept4, self.user1, **kwargs)
Ejemplo n.º 16
0
    def test_delete_organization_with_sources_and_collections(self):
        org = Organization(mnemonic='org1',
                           name='My Organization',
                           created_by=self.user,
                           updated_by=self.user)
        org.full_clean()
        org.save()
        org_id = org.id

        org = Organization.objects.get(id=org.id)
        user1 = UserProfile.objects.get(mnemonic=self.user.username)
        org.members.append(user1.id)
        user1.organizations.append(org.id)
        org.save()
        user1.save()

        source = Source(name='source1',
                        mnemonic='source1',
                        full_name='Source One',
                        parent=org,
                        created_by=self.user,
                        updated_by=self.user)
        source.full_clean()
        source.save()

        source2 = Source(name='source2',
                         mnemonic='source2',
                         full_name='Source Two',
                         parent=org,
                         created_by=self.user,
                         updated_by=self.user)
        source2.full_clean()
        source2.save()

        source_version = SourceVersion(
            name='version1',
            mnemonic='version1',
            versioned_object=source2,
            released=True,
            created_by=self.user,
            updated_by=self.user,
        )
        source_version.full_clean()
        source_version.save()

        source_version2 = SourceVersion(
            name='version2',
            mnemonic='version2',
            versioned_object=source2,
            released=True,
            created_by=self.user,
            updated_by=self.user,
        )
        source_version2.full_clean()
        source_version2.save()

        collection = Collection.objects.create(name='collection1',
                                               mnemonic='collection1',
                                               created_by=self.user,
                                               updated_by=self.user,
                                               parent=org,
                                               external_id='EXTID1')

        collection_version = CollectionVersion(
            name='version1',
            mnemonic='version1',
            versioned_object=collection,
            released=True,
            created_by='user1',
            updated_by='user1',
        )
        collection_version.full_clean()
        collection_version.save()

        collection_version2 = CollectionVersion(
            name='version2',
            mnemonic='version2',
            versioned_object=collection,
            released=True,
            created_by=self.user,
            updated_by=self.user,
        )
        collection_version2.full_clean()
        collection_version2.save()

        collection2 = Collection.objects.create(name='collection2',
                                                mnemonic='collection2',
                                                created_by=self.user,
                                                updated_by=self.user,
                                                parent=org,
                                                external_id='EXTID2')

        self.assertTrue(Organization.objects.filter(id=org_id).exists())

        self.assertTrue(Source.objects.filter(id=source.id).exists())
        self.assertTrue(Source.objects.filter(id=source2.id).exists())

        self.assertTrue(
            SourceVersion.objects.filter(id=source_version.id).exists())
        self.assertTrue(
            SourceVersion.objects.filter(id=source_version2.id).exists())

        self.assertTrue(Collection.objects.filter(id=collection.id).exists())
        self.assertTrue(Collection.objects.filter(id=collection2.id).exists())

        self.assertTrue(
            CollectionVersion.objects.filter(
                id=collection_version.id).exists())
        self.assertTrue(
            CollectionVersion.objects.filter(
                id=collection_version2.id).exists())

        org.delete()
        self.assertFalse(Organization.objects.filter(id=org.id).exists())

        self.assertFalse(Source.objects.filter(id=source.id).exists())
        self.assertFalse(Source.objects.filter(id=source2.id).exists())

        self.assertFalse(
            SourceVersion.objects.filter(id=source_version.id).exists())
        self.assertFalse(
            SourceVersion.objects.filter(id=source_version2.id).exists())

        self.assertFalse(Collection.objects.filter(id=collection.id).exists())
        self.assertFalse(Collection.objects.filter(id=collection2.id).exists())

        self.assertFalse(
            CollectionVersion.objects.filter(
                id=collection_version.id).exists())
        self.assertFalse(
            CollectionVersion.objects.filter(
                id=collection_version2.id).exists())

        #should not delete member user
        self.assertTrue(
            UserProfile.objects.filter(mnemonic=self.user.username).exists())
        #should delete org from organizations on user
        self.assertFalse(org_id in UserProfile.objects.get(
            mnemonic=self.user.username).organizations)