def setUp(self):
Organization.objects.bulk_create([
Organization(name='org-01'),
Organization(name='org-02'),
Organization(name='org-03'),
])
org_01, org_02, org_03 = Organization.objects.all()
self.org_01, self.org_02, self.org_03 = org_01, org_02, org_03
set_current_org(org_01)
AdminUser.objects.bulk_create([
AdminUser(name='au-01', username='******'),
AdminUser(name='au-02', username='******'),
AdminUser(name='au-03', username='******'),
])
SystemUser.objects.bulk_create([
SystemUser(name='su-01', username='******'),
SystemUser(name='su-02', username='******'),
SystemUser(name='su-03', username='******'),
])
admin_users = AdminUser.objects.all()
Asset.objects.bulk_create([
Asset(hostname='asset-01',
ip='192.168.1.1',
public_ip='192.168.1.1',
admin_user=admin_users[0]),
Asset(hostname='asset-02',
ip='192.168.1.2',
public_ip='192.168.1.2',
admin_user=admin_users[0]),
Asset(hostname='asset-03',
ip='192.168.1.3',
public_ip='192.168.1.3',
admin_user=admin_users[0]),
])
new_user = User.objects.create
new_org_memeber = OrganizationMember.objects.create
u = new_user(name='user-01',
username='******',
email='*****@*****.**')
new_org_memeber(org=org_01, user=u, role=ORG_ROLE.USER)
new_org_memeber(org=org_02, user=u, role=ORG_ROLE.USER)
self.user_01 = u
u = new_user(name='org-admin-01',
username='******',
email='*****@*****.**')
new_org_memeber(org=org_01, user=u, role=ORG_ROLE.ADMIN)
self.org_admin_01 = u
u = new_user(name='org-admin-02',
username='******',
email='*****@*****.**')
new_org_memeber(org=org_02, user=u, role=ORG_ROLE.ADMIN)
self.org_admin_02 = u
def test_create_organization_negative__no_mnemonic(self):
with self.assertRaises(ValidationError):
org = Organization(name='My Organization',
created_by='user1',
updated_by='user1')
org.full_clean()
org.save()
def test_resource_type(self):
org = Organization(mnemonic='org1',
name='My Organization',
created_by='user1',
updated_by='user1')
org.full_clean()
org.save()
self.assertEquals(ORG_OBJECT_TYPE, org.resource_type())
def test_create_organization_positive(self):
self.assertFalse(Organization.objects.filter(mnemonic='org1').exists())
org = Organization(mnemonic='org1',
name='My Organization',
created_by='user1',
updated_by='user1')
org.full_clean()
org.save()
self.assertTrue(Organization.objects.filter(mnemonic='org1').exists())
def create_organization(self, user):
org = None
if Organization.objects.filter(mnemonic='OCL').count() < 1:
org = Organization(mnemonic='OCL', name='Open Concept Lab', company="Open Concept Lab", members=[user.id],
created_by='root', updated_by='root')
org.full_clean()
org.save()
else:
org = Organization.objects.get(mnemonic='OCL')
return org
def test_org_num_members(self):
org = Organization(mnemonic='org1', name='My Organization', created_by='user1', updated_by='user1')
org.full_clean()
org.save()
self.assertEquals(0, org.num_members)
org.members.append(1)
self.assertEquals(1, org.num_members)
org.members.remove(1)
self.assertEquals(0, org.num_members)
def test_public_sources(self):
user = User.objects.create(username='******',
email='*****@*****.**',
last_name='One',
first_name='User')
org = Organization(mnemonic='org1',
name='My Organization',
created_by='user1',
updated_by='user1')
org.full_clean()
org.save()
self.assertEquals(0, org.public_sources)
Source.objects.create(
mnemonic='source1',
parent=org,
name='Source One',
)
self.assertEquals(1, org.public_sources)
org2 = Organization(mnemonic='org2',
name='Your Organization',
created_by='user1',
updated_by='user1')
org2.full_clean()
org2.save()
Source.objects.create(
mnemonic='source1',
parent=org2,
name='Source One',
)
self.assertEquals(1, org.public_sources)
Source.objects.create(
mnemonic='source2',
parent=org,
name='Source Two',
)
self.assertEquals(2, org.public_sources)
def create_organization(self, user, name):
if Organization.objects.filter(mnemonic=name).count() < 1:
org = Organization(mnemonic=name,
name=name,
company=name,
members=[user.id],
created_by='root',
updated_by='root')
org.full_clean()
org.save()
else:
org = Organization.objects.get(mnemonic=name)
return org
def test_organization_delete(self):
org = Organization(mnemonic='org1', name='My Organization', created_by='user1', updated_by='user1')
org.full_clean()
org.save()
org_id = org.id
self.assertTrue(org.is_active)
self.assertTrue(Organization.objects.filter(id=org_id).exists())
org.soft_delete()
self.assertFalse(org.is_active)
self.assertTrue(Organization.objects.filter(id=org_id).exists())
org.delete()
self.assertFalse(Organization.objects.filter(id=org_id).exists())
def restore_object(self, attrs, instance=None):
request_user = self.context['request'].user
mnemonic = attrs.get('mnemonic', None)
if Organization.objects.filter(mnemonic=mnemonic).exists():
self._errors[
'mnemonic'] = 'Organization with mnemonic %s already exists.' % mnemonic
return None
organization = Organization(name=attrs.get('name'), mnemonic=mnemonic)
organization.created_by = request_user
organization.updated_by = request_user
organization.public_access = attrs.get('public_access',
DEFAULT_ACCESS_TYPE)
organization.company = attrs.get('company', None)
organization.website = attrs.get('website', None)
organization.location = attrs.get('location', None)
organization.extras = attrs.get('extras', None)
return organization
def test_create_org_special_characters(self):
# period in mnemonic
org = create_organization(name='test', mnemonic='org.1')
self.assertEquals('org.1', org.mnemonic)
# hyphen in mnemonic
org = create_organization(name='test', mnemonic='org-1')
self.assertEquals('org-1', org.mnemonic)
# underscore in mnemonic
org = create_organization(name='test', mnemonic='org_1')
self.assertEquals('org_1', org.mnemonic)
# all characters in mnemonic
org = create_organization(name='test', mnemonic='org.1_2-3')
self.assertEquals('org.1_2-3', org.mnemonic)
# test validation error
with self.assertRaises(ValidationError):
org = Organization(name='test', mnemonic='org@1')
org.full_clean()
org.save()
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)
