def setUp(self):
self.view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.leadership = LeadershipFactory.create(
user=self.user,
group=self.group
)
self.staff_user = UserFactory.create(is_staff=True)
self.provider = ProviderFactory.create()
self.identity = IdentityFactory.create(
provider=self.provider,
created_by=self.user)
self.quota = QuotaFactory.create()
self.allocation = AllocationFactory.create()
IdentityMembershipFactory.create(
member=self.group,
identity=self.identity,
quota=self.quota
)
factory = APIRequestFactory()
url = reverse('api:v2:identity-detail', args=(self.identity.id,))
self.request = factory.get(url)
force_authenticate(self.request, user=self.user)
self.response = self.view(self.request, pk=self.identity.id)
def setUp(self):
self.list_view = ViewSet.as_view({'get': 'list'})
self.detailed_view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.staff_user = UserFactory.create(is_staff=True)
self.provider = ProviderFactory.create()
self.quota = QuotaFactory.create()
self.identity = IdentityFactory.create(
provider=self.provider, quota=self.quota, created_by=self.user
)
IdentityMembershipFactory.create(
member=self.group,
identity=self.identity,
)
factory = APIRequestFactory()
detail_url = reverse(
'api:v2:identity-detail', args=(self.identity.id, )
)
self.detail_request = factory.get(detail_url)
list_url = reverse('api:v2:identity-list')
self.list_request = factory.get(list_url)
def setUp(self):
self.list_view = ViewSet.as_view({'get': 'list'})
self.detailed_view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user_without_sources = UserFactory.create(username='******')
self.user_with_sources = UserFactory.create(username='******')
self.user = self.user_with_sources
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user_without_sources,
provider=self.provider)
self.user_identity = IdentityFactory.create_identity(
created_by=self.user_with_sources,
provider=self.provider)
self.allocation_source_1 = AllocationSourceFactory.create(name='TG-TRA110001',
compute_allowed=1000)
self.allocation_source_2 = AllocationSourceFactory.create(name='TG-TRA220002',
compute_allowed=2000)
self.allocation_source_3 = AllocationSourceFactory.create(name='TG-TRA330003',
compute_allowed=3000)
UserAllocationSourceFactory.create(user=self.user_with_sources, allocation_source=self.allocation_source_1)
UserAllocationSourceFactory.create(user=self.user_with_sources, allocation_source=self.allocation_source_2)
def create_an_instance(user=None, ip_address=None):
# This method should be replaced when the InstanceFactory can create an
# instance w/o requiring any arguments
import uuid
from api.tests.factories import (
UserFactory, InstanceFactory, ProviderMachineFactory, IdentityFactory,
ProviderFactory)
from django.utils import timezone
if not user:
user = UserFactory.create()
staff_user = UserFactory.create(is_staff=True, is_superuser=True)
provider = ProviderFactory.create()
user_identity = IdentityFactory.create_identity(
created_by=user,
provider=provider)
staff_user_identity = IdentityFactory.create_identity(
created_by=staff_user,
provider=provider)
machine = ProviderMachineFactory.create_provider_machine(staff_user, staff_user_identity)
start_date = timezone.now()
return InstanceFactory.create(
name="",
provider_alias=uuid.uuid4(),
source=machine.instance_source,
ip_address=ip_address,
created_by=user,
created_by_identity=user_identity,
start_date=start_date)
def setUp(self):
self.permissions = CanEditOrReadOnly()
self.user = UserFactory.create()
self.admin = UserFactory.create(is_staff=True)
self.creator = UserFactory.create()
self.anonymous_user = AnonymousUserFactory.create()
self.obj = mock.Mock()
self.obj.created_by = self.creator
self.request = mock.Mock()
self.view= mock.Mock()
def setUp(self):
self.view = UserViewSet.as_view({'get': 'list'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.staff_user = UserFactory.create(is_staff=True)
factory = APIRequestFactory()
url = reverse('api:v2:atmosphereuser-list')
self.request = factory.get(url)
force_authenticate(self.request, user=self.user)
self.response = self.view(self.request)
def setUp(self):
self.view = ViewSet.as_view({'get': 'list'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.staff_user = UserFactory.create(is_staff=True)
self.image = ImageFactory.create(created_by=self.user)
factory = APIRequestFactory()
url = reverse('api:v2:application-list')
self.request = factory.get(url)
force_authenticate(self.request, user=self.user)
self.response = self.view(self.request)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.create(owner=self.group)
self.not_user = UserFactory.create()
self.not_group = GroupFactory.create(name=self.not_user.username)
self.view = ProjectViewSet.as_view({"delete": "destroy"})
self.factory = APIRequestFactory()
self.url = reverse("api:v2:project-detail", args=(self.project.id,))
self.request = self.factory.delete(self.url)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.create(owner=self.group)
user2 = UserFactory.create()
group2 = GroupFactory.create(name=user2.username)
ProjectFactory.create(owner=group2)
self.view = ProjectViewSet.as_view({'get': 'retrieve'})
factory = APIRequestFactory()
url = reverse('api:v2:project-detail', args=(self.project.id,))
self.request = factory.get(url)
def setUp(self):
self.view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.staff_user = UserFactory.create(is_staff=True)
self.quota = QuotaFactory.create()
factory = APIRequestFactory()
url = reverse('api:v2:quota-detail', args=(self.quota.id,))
self.request = factory.get(url)
force_authenticate(self.request, user=self.user)
self.response = self.view(self.request, pk=self.quota.id)
def setUp(self):
self.tag = TagFactory.build()
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.staff_user = UserFactory.create(is_staff=True)
self.factory = APIRequestFactory()
self.url = reverse('api:v2:tag-list')
self.request = self.factory.post(self.url, {
'name': self.tag.name,
'description': self.tag.description
})
self.view = TagViewSet.as_view({'post': 'create'})
def setUp(self):
self.view = ViewSet.as_view({'get': 'list'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.staff_user = UserFactory.create(is_staff=True)
self.provider_type = ProviderTypeFactory.create()
factory = APIRequestFactory()
url = reverse('api:v2:providertype-list')
self.request = factory.get(url)
force_authenticate(self.request, user=self.user)
self.response = self.view(self.request)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.create(owner=self.group)
user2 = UserFactory.create()
group2 = GroupFactory.create(name=user2.username)
ProjectFactory.create(owner=group2)
self.view = ProjectViewSet.as_view({"get": "list"})
factory = APIRequestFactory()
url = reverse("api:v2:project-list")
self.request = factory.get(url)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.staff_user = UserFactory.create(is_staff=True)
factory = APIRequestFactory()
self.list_view = UserViewSet.as_view({'get': 'list'})
self.detail_view = UserViewSet.as_view({'get': 'retrieve'})
detail_url = reverse(self.url_route + '-detail', args=(self.user.id,))
list_url = reverse(self.url_route + '-list')
self.detail_request = factory.get(detail_url)
self.list_request = factory.get(list_url)
def test_create_event(self):
event_count = EventTable.objects.count()
self.assertEqual(event_count, 0)
user = UserFactory.create()
alloc_src = AllocationSource.objects.create(
name='DefaultAllocation', compute_allowed=1000
) # UUID assigned by default.
UserAllocationSource.objects.create(
user=user, allocation_source=alloc_src
)
event_payload = {
'allocation_source_id': str(alloc_src.uuid),
'compute_used':
100.00, # 100 hours used ( a number, not a string!)
'global_burn_rate': 2.00, # 2 hours used each hour
}
new_event = EventTable.create_event(
name='allocation_source_snapshot',
payload=event_payload,
entity_id=str(alloc_src.uuid)
)
event_count = EventTable.objects.count()
self.assertEqual(event_count, 2)
events = EventTable.objects.all()
self.assertEqual(new_event, events[1])
self.assertEqual(events[0].name, 'allocation_source_threshold_met')
self.assertEqual(events[0].entity_id, str(alloc_src.uuid))
self.assertEqual(
events[0].payload, {
'actual_value': 10,
'allocation_source_id': str(alloc_src.uuid),
'threshold': 10
}
)
def create_admin_and_two_regular_users(context):
context.client = Client()
user = UserFactory.create(username='******', is_staff=True, is_superuser=True)
user.set_password('lenards')
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.admin_user = user
context.client.login(username='******', password='******')
user_1 = UserFactory.create(username='******')
context.user_1 = user_1
user_2 = UserFactory.create(username='******')
context.user_2 = user_2
def __init__(self):
self.user = UserFactory.create()
provider_type = ProviderType(name='Test_%s' % self.user.username)
provider_type.save()
platform_type = PlatformType(
name='test-platform-%s' % self.user.username
)
platform_type.save()
provider = Provider(
location='BIO5', type=provider_type, virtualization=platform_type
)
provider.save()
active_status = InstanceStatus.objects.filter(name='active').last()
if not active_status:
active_status = InstanceStatus(name='active')
active_status.save()
suspended_status = InstanceStatus.objects.filter(name='suspended'
).last()
if not suspended_status:
suspended_status = InstanceStatus(name='suspended')
suspended_status.save()
self.provider = provider
self.active_status = active_status
self.suspended_status = suspended_status
def test_image_and_instance_scripts_are_included(self):
user = UserFactory.create()
instance = InstanceFactory.create(created_by=user)
# Create/add instance script
instance_script = BootScriptRawTextFactory.create(
created_by=user, wait_for_deploy=True
)
instance.scripts.add(instance_script)
# Create/add image script
image_script = BootScriptRawTextFactory.create(
created_by=user, wait_for_deploy=True
)
application_version = instance.source.providermachine.application_version
application_version.boot_scripts.add(image_script)
# Mock out ansible_deployment to verify its called with both image and
# instance scripts
with mock.patch(
'service.deploy.ansible_deployment'
) as ansible_deployment:
from service.deploy import user_deploy
user_deploy(
instance.ip_address, user.username, instance.provider_alias
)
kwargs = ansible_deployment.call_args[1]
script_titles = {
s['name']
for s in kwargs['extra_vars']['DEPLOY_SCRIPTS']
}
self.assertIn(instance_script.get_title_slug(), script_titles)
self.assertIn(image_script.get_title_slug(), script_titles)
def setUp(self):
factory = APIRequestFactory()
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user, provider=self.provider
)
self.private_image = ImageFactory.create(
created_by=self.user, private=True
)
self.private_version = ApplicationVersionFactory.create_version(
self.user, self.user_identity, application=self.private_image
)
self.private_machine = ProviderMachineFactory.create_provider_machine(
self.user,
self.user_identity,
application=self.private_image,
version=self.private_version
)
self.staff_user = UserFactory.create(is_staff=True)
self.staff_user_identity = IdentityFactory.create_identity(
created_by=self.staff_user, provider=self.provider
)
self.public_image = ImageFactory.create(
created_by=self.staff_user, private=False
)
self.public_version = ApplicationVersionFactory.create_version(
self.staff_user,
self.staff_user_identity,
application=self.public_image
)
self.public_machine = ProviderMachineFactory.create_provider_machine(
self.staff_user,
self.staff_user_identity,
application=self.public_image,
version=self.public_version
)
self.list_view = ViewSet.as_view({'get': 'list'})
list_url = reverse(self.url_route + '-list')
self.list_request = factory.get(list_url)
self.detail_view = ViewSet.as_view({'get': 'retrieve'})
detail_url = reverse(self.url_route + '-detail', args=(self.user.id, ))
self.detail_request = factory.get(detail_url)
def setUp(self):
self.view = UserViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
factory = APIRequestFactory()
url = reverse('api:v2:atmosphereuser-detail', args=(self.user.id,))
self.request = factory.get(url)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.username = "******"
self.password = "******"
self.user = UserFactory.create(username=self.username)
self.user.set_password(self.password)
self.user.save()
self.auth_url = "/auth"
def setUp(self):
self.tag = TagFactory.create()
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.staff_user = UserFactory.create(is_staff=True)
self.updated_tag_data = {
'name': 'new-tag-name',
'description': 'new tag description'
}
self.factory = APIRequestFactory()
self.url = reverse('api:v2:tag-detail', args=(self.tag.id,))
self.request = self.factory.put(self.url, {
'name': self.updated_tag_data['name'],
'description': self.updated_tag_data['description']
})
self.view = TagViewSet.as_view({'put': 'update'})
def test_validate_account(self, cassette):
"""Test for a valid account based on the business logic assigned by Jetstream"""
from jetstream.plugins.auth.validation import XsedeProjectRequired
jetstream_auth_plugin = XsedeProjectRequired()
user = UserFactory.create(username='******')
with freezegun.freeze_time('2016-09-15T05:00:00Z'):
is_jetstream_valid = jetstream_auth_plugin.validate_user(user)
self.assertTrue(is_jetstream_valid)
assert_cassette_playback_length(cassette, 2)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.build(owner=self.group)
self.view = ProjectViewSet.as_view({"post": "create"})
self.factory = APIRequestFactory()
self.url = reverse("api:v2:project-list")
self.request = self.factory.post(self.url, {"name": self.project.name, "description": self.project.description})
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.group.user_set.add(self.user)
self.provider = ProviderFactory.create(location="mock location", type__name="mock")
self.view = TokenUpdateViewSet.as_view({'post': 'create'})
self.identity_view = IdentityViewSet.as_view({'get': 'retrieve'})
self.credentials_view = CredentialViewSet.as_view({'get': 'list'})
self.token_uuid = "test-token-1234-debug"
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.staff_user = UserFactory.create(is_staff=True)
self.platform_type = PlatformTypeFactory.create()
factory = APIRequestFactory()
self.detail_view = ViewSet.as_view({'get': 'retrieve'})
detail_url = reverse(
self.url_route+'-detail', args=(self.platform_type.id,))
self.detail_request = factory.get(detail_url)
self.list_view = ViewSet.as_view({'get': 'list'})
list_url = reverse(
self.url_route+'-list')
self.list_request = factory.get(list_url)
def setUp(self):
self.view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.image = ImageFactory.create(created_by=self.user)
factory = APIRequestFactory()
url = reverse('api:v2:application-detail', args=(self.user.id,))
self.request = factory.get(url)
def test_user_allocation_source_assigned(self):
new_allocation_source = {
'source_id': str(uuid.uuid4()),
'name': 'TestAllocationSourceAssociateScenario',
'compute_allowed': 50000
}
new_event = EventTable.create_event(name='allocation_source_created',
payload=new_allocation_source,
entity_id=new_allocation_source['source_id'])
user = UserFactory.create()
new_user_allocation_source = {
'source_id': new_allocation_source['source_id'],
'username': user.username
}
# Make sure no allocation_source_assigned event for this user and source exists
event_count_before = EventTable.objects.filter(
name='user_allocation_source_assigned',
payload__username=user.username,
payload__source_id=new_user_allocation_source['source_id']
).count()
self.assertEqual(event_count_before, 0)
# Make sure that no Allocation Source and User combination exists
user_allocation_source_count_before = UserAllocationSource.objects.filter(
allocation_source__source_id=new_user_allocation_source['source_id'],
user=user).count()
self.assertEqual(user_allocation_source_count_before, 0)
# Add an event 'allocation_source_created' with our test source name
new_event = EventTable.create_event(name='user_allocation_source_assigned',
payload=new_user_allocation_source,
entity_id=new_user_allocation_source['username'])
# Make sure we added the event successfully
event_count_after = EventTable.objects.filter(
name='user_allocation_source_assigned',
payload__username=user.username,
payload__source_id=new_user_allocation_source['source_id']
).count()
self.assertEqual(event_count_after, 1)
# Make sure that there is now an Allocation Source with the test name
user_allocation_source_count_after = UserAllocationSource.objects.filter(
allocation_source__source_id=new_user_allocation_source['source_id'],
user=user).count()
self.assertEqual(user_allocation_source_count_after, 1)
user_allocation_source = UserAllocationSource.objects.filter(
allocation_source__source_id=new_user_allocation_source['source_id'],
user=user).first()
self.assertEqual(user_allocation_source.allocation_source.compute_allowed,
new_allocation_source['compute_allowed'])
self.assertEqual(user_allocation_source.allocation_source.source_id, new_allocation_source['source_id'])
self.assertEqual(user_allocation_source.allocation_source.name, new_allocation_source['name'])
def create_admin_and_two_regular_users(context):
context.client = Client()
user = UserFactory.create(
username='******', is_staff=True, is_superuser=True
)
user.set_password('lenards')
user.save()
with modify_settings(
AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}
):
context.admin_user = user
context.client.login(username='******', password='******')
user_1 = UserFactory.create(username='******')
context.user_1 = user_1
user_2 = UserFactory.create(username='******')
context.user_2 = user_2
def create_user_with_username(context, username):
context.client = Client()
user = UserFactory.create(username=username, is_staff=False, is_superuser=False)
user.set_password(username)
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.user = user
context.client.login(username=username, password=username)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.group.user_set.add(self.user)
self.provider = ProviderFactory.create(location="mock location",
type__name="mock")
self.view = TokenUpdateViewSet.as_view({'post': 'create'})
self.identity_view = IdentityViewSet.as_view({'get': 'retrieve'})
self.credentials_view = CredentialViewSet.as_view({'get': 'list'})
self.token_uuid = "test-token-1234-debug"
def create_user_with_username(context, username):
context.client = Client()
user = UserFactory.create(username=username, is_staff=False, is_superuser=False)
user.set_password(username)
user.save()
with modify_settings(AUTHENTICATION_BACKENDS={
'prepend': 'django.contrib.auth.backends.ModelBackend',
'remove': ['django_cyverse_auth.authBackends.MockLoginBackend']
}):
context.user = user
context.client.login(username=username, password=username)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.create(owner=self.group)
self.not_user = UserFactory.create()
self.not_group = GroupFactory.create(name=self.not_user.username)
self.not_project = ProjectFactory.create(owner=self.not_group)
self.updated_project_data = {"name": "updated name", "description": "updated description"}
self.factory = APIRequestFactory()
self.url = reverse("api:v2:project-detail", args=(self.project.id,))
self.request = self.factory.put(
self.url,
{"name": self.updated_project_data["name"], "description": self.updated_project_data["description"]},
)
self.view = ProjectViewSet.as_view({"put": "update"})
def setUp(self):
self.view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.staff_user = UserFactory.create(is_staff=True)
self.provider = ProviderFactory.create()
self.identity = IdentityFactory.create(provider=self.provider,
created_by=self.user)
self.quota = QuotaFactory.create()
self.allocation = AllocationFactory.create()
IdentityMembershipFactory.create(member=self.group,
identity=self.identity,
quota=self.quota)
factory = APIRequestFactory()
url = reverse('api:v2:identity-detail', args=(self.identity.id, ))
self.request = factory.get(url)
force_authenticate(self.request, user=self.user)
self.response = self.view(self.request, pk=self.identity.id)
def setUp(self):
factory = APIRequestFactory()
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user, provider=self.provider)
self.private_image = ImageFactory.create(created_by=self.user,
private=True)
self.private_version = ApplicationVersionFactory.create_version(
self.user, self.user_identity, application=self.private_image)
self.private_machine = ProviderMachineFactory.create_provider_machine(
self.user,
self.user_identity,
application=self.private_image,
version=self.private_version)
self.staff_user = UserFactory.create(is_staff=True)
self.staff_user_identity = IdentityFactory.create_identity(
created_by=self.staff_user, provider=self.provider)
self.public_image = ImageFactory.create(created_by=self.staff_user,
private=False)
self.public_version = ApplicationVersionFactory.create_version(
self.staff_user,
self.staff_user_identity,
application=self.public_image)
self.public_machine = ProviderMachineFactory.create_provider_machine(
self.staff_user,
self.staff_user_identity,
application=self.public_image,
version=self.public_version)
self.list_view = ViewSet.as_view({'get': 'list'})
list_url = reverse(self.url_route + '-list')
self.list_request = factory.get(list_url)
self.detail_view = ViewSet.as_view({'get': 'retrieve'})
detail_url = reverse(self.url_route + '-detail', args=(self.user.id, ))
self.detail_request = factory.get(detail_url)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.build(owner=self.group)
self.view = ProjectViewSet.as_view({'post': 'create'})
self.factory = APIRequestFactory()
self.url = reverse('api:v2:project-list')
self.request = self.factory.post(
self.url, {
'name': self.project.name,
'description': self.project.description
})
def allocation_source_is_assigned_to_users(context):
context.users = []
for row in context.table:
number_of_users = int(
row['number of users assigned to allocation source'])
context.number_of_users = number_of_users
for i in range(number_of_users):
user = UserFactory.create(date_joined=context.current_time)
context.users.append(user)
UserAllocationSource.objects.create(
allocation_source=context.allocation_source, user=user)
assert (len(
UserAllocationSource.objects.filter(
user=user, allocation_source=context.allocation_source)) > 0)
def test_get_tacc_username_api_problem(self, cassette):
"""Make sure we don't return the Atmosphere username when we have trouble connecting to the TAS API.
It should fail.
TODO: Figure out how to handle it gracefully.
"""
from jetstream.allocation import TASAPIDriver
tas_driver = TASAPIDriver()
tas_driver.clear_cache()
self.assertDictEqual(tas_driver.username_map, {})
user = UserFactory.create(username='******')
tacc_username = tas_driver.get_tacc_username(user)
self.assertIsNone(tacc_username)
self.assertDictEqual(tas_driver.username_map, {})
assert_cassette_playback_length(cassette, 1)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.project = ProjectFactory.create(owner=self.group)
self.not_user = UserFactory.create()
self.not_group = GroupFactory.create(name=self.not_user.username)
self.not_project = ProjectFactory.create(owner=self.not_group)
self.updated_project_data = {
'name': 'updated name',
'description': 'updated description'
}
self.factory = APIRequestFactory()
self.url = reverse('api:v2:project-detail', args=(self.project.id, ))
self.request = self.factory.put(
self.url, {
'name': self.updated_project_data['name'],
'description': self.updated_project_data['description']
})
self.view = ProjectViewSet.as_view({'put': 'update'})
def test_get_version(self):
"""
Test a sucessful response and shape
"""
user_a = UserFactory.create()
view = self.view_set.as_view({'get': 'list'})
request = APIRequestFactory().get("")
force_authenticate(request, user=user_a)
response = view(request)
self.assertEquals(response.status_code, 200)
data = response.data
keys = ['git_sha', 'git_sha_abbrev', 'commit_date', 'git_branch']
for key in keys:
self.assertIn(key, data)
self.assertIsNotNone(data[key])
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user,
provider=self.provider)
self.size = SizeFactory.create(provider=self.provider,
cpu=10,
disk=20,
root=0,
mem=126)
self.view = SizeViewSet.as_view({'get': 'list'})
factory = APIRequestFactory()
url = reverse('api:v2:size-list')
self.request = factory.get(url)
def create_get_request(user=None, instance=None, query_params=None):
if not query_params:
query_params = {}
if not user:
user = UserFactory.create()
if not instance:
ip_address = "{}.{}.{}.{}".format(random.randint(1, 255),
random.randint(1, 255),
random.randint(1, 255),
random.randint(1, 255))
instance = create_an_instance(user=user, ip_address=ip_address)
view = WebTokenView.as_view()
# Construct url
base_url = reverse('api:v2:web_token', args=(instance.provider_alias, ))
encoded_params = urllib.urlencode(query_params)
url = "{}?{}".format(base_url, encoded_params)
request = APIRequestFactory().get(url)
force_authenticate(request, user=user)
return view(request, pk=instance.provider_alias)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.access_token = create_access_token(
self.user, "Test Token 1", issuer="Testing"
)
factory = APIRequestFactory()
self.create_view = AccessTokenViewSet.as_view({'post': 'create'})
self.create_request = factory.post(
self.url_route, {'name': 'Test Token Creation'}
)
self.invalid_create_request = factory.post(
self.url_route, {'name': {
'Not': 'A String'
}}, format='json'
)
self.list_view = AccessTokenViewSet.as_view({'get': 'list'})
self.list_request = factory.get(self.url_route)
self.delete_view = AccessTokenViewSet.as_view({'delete': 'destroy'})
self.delete_request = factory.delete(
'{}/{}'.format(self.url_route, self.access_token.id)
)
self.edit_view = AccessTokenViewSet.as_view({'put': 'update'})
self.edit_request = factory.put(
'{}/{}'.format(self.url_route, self.access_token.id),
{'name': 'Test Token New Name'}
)
self.invalid_edit_request = factory.put(
'{}/{}'.format(self.url_route, self.access_token.id),
{'name': {
'Not': 'A String'
}},
format='json'
)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create(username='******')
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user, provider=self.provider)
self.group = Group.objects.get(name=self.user)
self.project = ProjectFactory.create(owner=self.group)
self.machine = ProviderMachineFactory.create_provider_machine(
self.user, self.user_identity)
self.active_instance = InstanceFactory.create(
name="Instance in active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=timezone.now())
self.view = ProjectInstanceViewSet.as_view({'get': 'list'})
factory = APIRequestFactory()
url = reverse('api:v2:projectinstance-list')
url_proj = "?project__id=" + str(self.project.id)
url += url_proj
self.request = factory.get(url)
def setUp(self):
self.list_view = InstanceViewSet.as_view({'get': 'list'})
self.detailed_view = InstanceViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create(username='******')
self.admin_user = UserFactory.create(username='******', is_superuser=True, is_staff=True)
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user,
provider=self.provider)
self.admin_identity = IdentityFactory.create_identity(
provider=self.provider,
created_by=self.admin_user)
self.machine = ProviderMachineFactory.create_provider_machine(self.user, self.user_identity)
self.active_instance = InstanceFactory.create(
name="Instance in active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=timezone.now())
self.networking_instance = InstanceFactory.create(
name="Instance in networking",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=timezone.now())
self.deploying_instance = InstanceFactory.create(
name="Instance in deploying",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=timezone.now())
self.deploy_error_instance = InstanceFactory.create(
name="Instance in deploy_error",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=timezone.now())
active = InstanceStatusFactory.create(name='active')
networking = InstanceStatusFactory.create(name='networking')
deploying = InstanceStatusFactory.create(name='deploying')
deploy_error = InstanceStatusFactory.create(name='deploy_error')
InstanceHistoryFactory.create(
status=deploy_error,
activity="",
instance=self.deploy_error_instance
)
InstanceHistoryFactory.create(
status=deploying,
activity="",
instance=self.deploying_instance
)
InstanceHistoryFactory.create(
status=active,
activity="",
instance=self.active_instance
)
InstanceHistoryFactory.create(
status=networking,
activity="",
instance=self.networking_instance
)
def test_user_allocation_source_assigned(self):
new_allocation_source = {
'source_id': str(uuid.uuid4()),
'name': 'TestAllocationSourceAssociateScenario',
'compute_allowed': 50000
}
new_event = EventTable.create_event(
name='allocation_source_created',
payload=new_allocation_source,
entity_id=new_allocation_source['source_id'])
user = UserFactory.create()
new_user_allocation_source = {
'source_id': new_allocation_source['source_id'],
'username': user.username
}
# Make sure no allocation_source_assigned event for this user and source exists
event_count_before = EventTable.objects.filter(
name='user_allocation_source_assigned',
payload__username=user.username,
payload__source_id=new_user_allocation_source['source_id']).count(
)
self.assertEqual(event_count_before, 0)
# Make sure that no Allocation Source and User combination exists
user_allocation_source_count_before = UserAllocationSource.objects.filter(
allocation_source__source_id=new_user_allocation_source[
'source_id'],
user=user).count()
self.assertEqual(user_allocation_source_count_before, 0)
# Add an event 'allocation_source_created' with our test source name
new_event = EventTable.create_event(
name='user_allocation_source_assigned',
payload=new_user_allocation_source,
entity_id=new_user_allocation_source['username'])
# Make sure we added the event successfully
event_count_after = EventTable.objects.filter(
name='user_allocation_source_assigned',
payload__username=user.username,
payload__source_id=new_user_allocation_source['source_id']).count(
)
self.assertEqual(event_count_after, 1)
# Make sure that there is now an Allocation Source with the test name
user_allocation_source_count_after = UserAllocationSource.objects.filter(
allocation_source__source_id=new_user_allocation_source[
'source_id'],
user=user).count()
self.assertEqual(user_allocation_source_count_after, 1)
user_allocation_source = UserAllocationSource.objects.filter(
allocation_source__source_id=new_user_allocation_source[
'source_id'],
user=user).first()
self.assertEqual(
user_allocation_source.allocation_source.compute_allowed,
new_allocation_source['compute_allowed'])
self.assertEqual(user_allocation_source.allocation_source.source_id,
new_allocation_source['source_id'])
self.assertEqual(user_allocation_source.allocation_source.name,
new_allocation_source['name'])
def setUp(self):
self.user = UserFactory.create(username='******')
Activity.objects.create(user=self.user)
def test_delete_with_other_user_403s(self):
UserFactory.create(username='******')
self.client.login(username='******', password='******')
response = self.client.get(reverse('api:delete_activity', args=[1]))
assert response.status_code == 403
self.assertTemplateUsed('403.html')
def setUp(self):
self.list_view = ViewSet.as_view({'get': 'list'})
self.detailed_view = ViewSet.as_view({'get': 'retrieve'})
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create(username='******')
self.staff_user = UserFactory.create(username='******', is_staff=True, is_superuser=True)
self.provider = ProviderFactory.create()
self.user_identity = IdentityFactory.create_identity(
created_by=self.user,
provider=self.provider)
self.staff_user_identity = IdentityFactory.create_identity(
created_by=self.staff_user,
provider=self.provider)
self.machine = ProviderMachineFactory.create_provider_machine(self.staff_user, self.staff_user_identity)
self.application = self.machine.application_version.application
start_date = timezone.now()
self.active_instance = InstanceFactory.create(
name="Instance went active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.staff_user,
created_by_identity=self.staff_user_identity,
start_date=start_date)
self.networking_instance = InstanceFactory.create(
name="Instance stuck in networking",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.staff_user,
created_by_identity=self.staff_user_identity,
start_date=start_date)
self.deploying_instance = InstanceFactory.create(
name="Instance stuck in deploying",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.staff_user,
created_by_identity=self.staff_user_identity,
start_date=start_date)
self.deploy_error_instance = InstanceFactory.create(
name="Instance stuck in deploy_error",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.staff_user,
created_by_identity=self.staff_user_identity,
start_date=start_date)
self.status_build = InstanceStatusFactory.create(name='build')
self.status_suspended = InstanceStatusFactory.create(name='suspended')
self.status_active = InstanceStatusFactory.create(name='active')
self.status_networking = InstanceStatusFactory.create(name='networking')
self.status_deploying = InstanceStatusFactory.create(name='deploying')
self.status_deploy_error = InstanceStatusFactory.create(name='deploy_error')
# Adding two minutes to simulate the passage of time.
delta_time = timezone.timedelta(minutes=2)
# Simulate 'Deploy error'
InstanceHistoryFactory.create(
status=self.status_build,
activity="",
instance=self.deploy_error_instance,
start_date=start_date,
)
InstanceHistoryFactory.create(
status=self.status_networking,
activity="",
instance=self.deploy_error_instance,
start_date=start_date + delta_time,
)
InstanceHistoryFactory.create(
status=self.status_deploying,
activity="",
instance=self.deploy_error_instance,
start_date=start_date + delta_time*2,
)
InstanceHistoryFactory.create(
status=self.status_deploy_error,
activity="",
instance=self.deploy_error_instance,
start_date=start_date + delta_time*3,
)
# Simulate 'stuck in networking'
InstanceHistoryFactory.create(
status=self.status_build,
activity="",
instance=self.networking_instance,
start_date=start_date,
)
InstanceHistoryFactory.create(
status=self.status_networking,
activity="",
instance=self.networking_instance,
start_date=start_date + delta_time,
)
# Simulate 'stuck in deploying'
InstanceHistoryFactory.create(
status=self.status_build,
activity="",
instance=self.deploying_instance,
start_date=start_date + delta_time,
)
InstanceHistoryFactory.create(
status=self.status_networking,
activity="",
instance=self.deploying_instance,
start_date=start_date + delta_time,
)
InstanceHistoryFactory.create(
status=self.status_deploying,
activity="",
instance=self.deploying_instance,
start_date=start_date + delta_time,
)
# Simulate going to active
InstanceHistoryFactory.create(
status=self.status_build,
activity="",
instance=self.active_instance,
start_date=start_date,
)
InstanceHistoryFactory.create(
status=self.status_networking,
activity="",
instance=self.active_instance,
start_date=start_date + delta_time,
)
InstanceHistoryFactory.create(
status=self.status_deploying,
activity="",
instance=self.active_instance,
start_date=start_date + delta_time*2,
)
InstanceHistoryFactory.create(
status=self.status_active,
activity="",
instance=self.active_instance,
start_date=start_date + delta_time*3,
)
get_application_metrics(self.application)
def test_fields_exist_as_expected(self):
a = Activity(user=UserFactory.create())
a.save()
assert a.modified is not None
assert a.created is not None
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.view = ReportingViewSet.as_view({'get': 'list'})
def setUp(self):
self.user = UserFactory.create()
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create(username='******')
self.provider = ProviderFactory.create(type__name='mock')
self.user_identity = IdentityFactory.create_identity(
created_by=self.user, provider=self.provider)
self.machine = ProviderMachineFactory.create_provider_machine(
self.user, self.user_identity)
start_date = timezone.now()
self.active_instance = InstanceFactory.create(
name="Instance in active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=start_date)
self.size_small = SizeFactory.create(provider=self.provider,
cpu=2,
disk=20,
root=0,
mem=128)
self.status_active = InstanceStatusFactory.create(name='active')
delta_time = timezone.timedelta(minutes=2)
InstanceHistoryFactory.create(status=self.status_active,
size=self.size_small,
activity="",
instance=self.active_instance,
start_date=start_date + delta_time * 3)
self.view = InstanceViewSet.as_view({'post': 'actions'})
self.url = reverse('api:v2:instance-list')
self.url += "/" + str(self.active_instance.provider_alias) + "/actions"
self.mock_driver = get_esh_driver(self.user_identity)
self.mock_driver.add_core_instance(self.active_instance)
start_date_second = timezone.now()
self.active_instance_second = InstanceFactory.create(
name="Instance in active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=start_date_second)
delta_time = timezone.timedelta(minutes=2)
self.size_small = SizeFactory.create(provider=self.provider,
cpu=2,
disk=20,
root=0,
mem=128)
self.size_large = SizeFactory.create(provider=self.provider,
cpu=4,
disk=40,
root=0,
mem=256)
InstanceHistoryFactory.create(status=self.status_active,
size=self.size_small,
activity="",
instance=self.active_instance_second,
start_date=start_date_second +
delta_time * 3)
self.mock_driver.add_core_instance(self.active_instance_second)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create(username='******')
self.provider = ProviderFactory.create(type__name='mock')
self.user_identity = IdentityFactory.create_identity(
created_by=self.user, provider=self.provider
)
self.machine = ProviderMachineFactory.create_provider_machine(
self.user, self.user_identity
)
start_date = timezone.now()
self.active_instance = InstanceFactory.create(
name="Instance in active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=start_date
)
self.size_small = SizeFactory.create(
provider=self.provider, cpu=2, disk=20, root=0, mem=128
)
self.status_active = InstanceStatusFactory.create(name='active')
delta_time = timezone.timedelta(minutes=2)
InstanceHistoryFactory.create(
status=self.status_active,
size=self.size_small,
activity="",
instance=self.active_instance,
start_date=start_date + delta_time * 3
)
self.view = InstanceViewSet.as_view({'post': 'actions'})
self.url = reverse('api:v2:instance-list')
self.url += "/" + str(self.active_instance.provider_alias) + "/actions"
self.mock_driver = get_esh_driver(self.user_identity)
self.mock_driver.add_core_instance(self.active_instance)
start_date_second = timezone.now()
self.active_instance_second = InstanceFactory.create(
name="Instance in active",
provider_alias=uuid.uuid4(),
source=self.machine.instance_source,
created_by=self.user,
created_by_identity=self.user_identity,
start_date=start_date_second
)
delta_time = timezone.timedelta(minutes=2)
self.size_small = SizeFactory.create(
provider=self.provider, cpu=2, disk=20, root=0, mem=128
)
self.size_large = SizeFactory.create(
provider=self.provider, cpu=4, disk=40, root=0, mem=256
)
InstanceHistoryFactory.create(
status=self.status_active,
size=self.size_small,
activity="",
instance=self.active_instance_second,
start_date=start_date_second + delta_time * 3
)
self.mock_driver.add_core_instance(self.active_instance_second)
self.allocation_source_1 = AllocationSourceFactory.create(
name='TEST_INSTANCE_ALLOCATION_SOURCE_01', compute_allowed=1000
)
UserAllocationSource.objects.create(
allocation_source=self.allocation_source_1, user=self.user
)
UserAllocationSnapshot.objects.create(
allocation_source=self.allocation_source_1,
user=self.user,
burn_rate=1,
compute_used=0
)
AllocationSourceSnapshot.objects.create(
allocation_source=self.allocation_source_1,
compute_used=0,
compute_allowed=168,
global_burn_rate=1
)
InstanceAllocationSourceSnapshot.objects.update_or_create(
instance=self.active_instance,
allocation_source=self.allocation_source_1
)
def setUp(self):
self.anonymous_user = AnonymousUserFactory()
self.user = UserFactory.create()
self.group = GroupFactory.create(name=self.user.username)
self.membership = GroupMembershipFactory.create(user=self.user,
group=self.group,
is_leader=True)
self.group.user_set.add(self.user)
self.project = ProjectFactory.create(owner=self.group,
created_by=self.user)
self.enddated_instance = InstanceFactory.create(
created_by=self.user,
end_date=timezone.now(),
project=self.project)
self.user2 = UserFactory.create()
self.group2 = GroupFactory.create(name=self.user2.username)
self.membership2 = GroupMembershipFactory.create(user=self.user2,
group=self.group2,
is_leader=True)
self.group2.user_set.add(self.user2)
self.project2 = ProjectFactory.create(owner=self.group2,
created_by=self.user2)
self.not_user = UserFactory.create()
self.not_group = GroupFactory.create(name=self.not_user.username)
self.not_membership = GroupMembershipFactory.create(
user=self.not_user, group=self.not_group, is_leader=True)
self.not_group.user_set.add(self.not_user)
self.not_project = ProjectFactory.create(owner=self.not_group,
created_by=self.not_user)
self.unsaved_project = ProjectFactory.build(owner=self.group,
created_by=self.user)
list_url = reverse('api:v2:project-list')
detail_url = reverse('api:v2:project-detail', args=(self.project.id, ))
self.create_view = ProjectViewSet.as_view({'post': 'create'})
self.delete_view = ProjectViewSet.as_view({'delete': 'destroy'})
self.detail_view = ProjectViewSet.as_view({'get': 'retrieve'})
self.list_view = ProjectViewSet.as_view({'get': 'list'})
self.update_view = ProjectViewSet.as_view({'patch': 'partial_update'})
self.factory = APIRequestFactory()
self.bad_create_request = self.factory.post(list_url)
self.create_request = self.factory.post(
list_url, {
'name': self.unsaved_project.name,
'description': self.unsaved_project.description,
'owner': self.group.name
})
self.delete_request = self.factory.delete(detail_url)
self.detail_request = self.factory.get(detail_url)
self.list_request = self.factory.get(list_url)
self.updated_project_data = {
'name': 'updated name',
'description': 'updated description'
}
self.update_request = self.factory.patch(detail_url,
self.updated_project_data)
