def test_bossrequest_init_coordinateframe(self):
"""
Test initialization of requests from the meta data service with a valid collection and experiment and dataset
"""
# create the request
url = '/' + version + '/meta/col1/exp1/channel1/?key=mkey'
expected_col = 'col1'
expected_exp = 'exp1'
expected_channel = 'channel1'
expected_coord = 'cf1'
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = BossMeta().initialize_request(request)
drfrequest.version = version
# Create the request dict
request_args = {
"user": self.user,
"method": request.method,
"service": "meta",
"version": version,
"collection_name": expected_col,
"experiment_name": expected_exp,
"channel_name": expected_channel,
"key": "mkey",
}
ret = BossRequest(drfrequest, request_args)
# Data model objects
self.assertEqual(ret.get_collection(), expected_col)
self.assertEqual(ret.get_experiment(), expected_exp)
self.assertEqual(ret.get_channel(), expected_channel)
# Check coordinate frame
self.assertEqual(ret.get_coordinate_frame(), expected_coord)
def test_deleted_submission_not_in_chart_endpoint(self):
data = {'field_name': 'gender'}
request = self.factory.get('/charts', data)
force_authenticate(request, user=self.user)
response = self.view(
request,
pk=self.xform.id,
format='html'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(sum([i['count'] for i in response.data['data']]), 3)
# soft delete one instance
inst = self.xform.instances.all()[0]
inst.set_deleted(timezone.now())
response = self.view(
request,
pk=self.xform.id,
format='html'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(sum([i['count'] for i in response.data['data']]), 2)
def post(self, user, data=None):
if user.is_anonymous and not User.objects.filter(
display_name='AnonymousUser').exists():
UserFactory.create(display_name='AnonymousUser')
if data is None:
data = {
'name': 'A test image',
'description': 'Test image description',
'file': get_image()
}
url = reverse(
'api:project_media',
kwargs={
'project_id': self.project.id,
'contribution_id': self.contribution.id
}
)
request = self.factory.post(url, data)
force_authenticate(request, user)
view = AllContributionsMediaAPIView.as_view()
return view(
request,
project_id=self.project.id,
contribution_id=self.contribution.id
).render()
def test_bossrequest_channel_not_found(self):
"""
Test initialization of requests with a channel that does not exist
"""
# create the request
url = '/' + version + '/meta/col1/exp1/channel2/?key=mkey'
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = BossMeta().initialize_request(request)
drfrequest.version = version
# Create the request dict
request_args = {
"user": self.user,
"method": request.method,
"service": "meta",
"version": version,
"collection_name": "col1",
"experiment_name": "exp1",
"channel_name": "channel2",
"key": "mkey",
"value": None
}
try:
BossRequest(drfrequest,request_args)
except BossError as err:
assert err.args[0] == 404
def get_request(self,method='GET', authed=True):
request_method=getattr(self.factory,method.lower())
request=request_method("")
if authed:
force_authenticate(request, self.test_user)
return request
def test_basic_resource_get_iso_level_isotropic(self):
"""Test get iso level isotropic
Returns:
None
"""
url = '/' + version + '/cutout/col1/exp_iso/channel1/0/0:5/0:6/0:2/'
# Create the request
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = Cutout().initialize_request(request)
drfrequest.version = version
request_args = {
"service": "cutout",
"collection_name": "col1",
"experiment_name": "exp_iso",
"channel_name": "channel1",
"resolution": 0,
"x_args": "0:5",
"y_args": "0:6",
"z_args": "0:2",
"time_args": None
}
req = BossRequest(drfrequest, request_args)
resource = BossResourceDjango(req)
self.assertEqual(resource.get_isotropic_level(), 0)
def test_basic_resource_get_downsampled_extent_dims_isotropic(self):
"""Test downsample extent isotropic
Returns:
None
"""
url = '/' + version + '/cutout/col1/exp_iso/channel1/0/0:5/0:6/0:2/'
# Create the request
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = Cutout().initialize_request(request)
drfrequest.version = version
request_args = {
"service": "cutout",
"collection_name": "col1",
"experiment_name": "exp_iso",
"channel_name": "channel1",
"resolution": 0,
"x_args": "0:5",
"y_args": "0:6",
"z_args": "0:2",
"time_args": None
}
req = BossRequest(drfrequest, request_args)
resource = BossResourceDjango(req)
extent_dims = resource.get_downsampled_extent_dims()
self.assertEqual(len(extent_dims), 8)
self.assertEqual(extent_dims[0], [2000, 5000, 200])
self.assertEqual(extent_dims[1], [1000, 2500, 100])
self.assertEqual(extent_dims[3], [250, 625, 25])
def get_request(self, user=None, data=None):
request = APIRequestFactory().post('/', data)
if user:
force_authenticate(request, user=user)
return Request(request)
def test_duplicate_wrong_parameters(self):
request = factory.post(reverse('resolwe-api:data-duplicate'), format='json')
force_authenticate(request, self.contributor)
response = self.duplicate_viewset(request)
self.assertEqual(response.data['detail'], "`ids` parameter is required")
request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': 1}, format='json')
force_authenticate(request, self.contributor)
response = self.duplicate_viewset(request)
self.assertEqual(response.data['detail'], "`ids` parameter not a list")
request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': []}, format='json')
force_authenticate(request, self.contributor)
response = self.duplicate_viewset(request)
self.assertEqual(response.data['detail'], "`ids` parameter is empty")
request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': ['a']}, format='json')
force_authenticate(request, self.contributor)
response = self.duplicate_viewset(request)
self.assertEqual(response.data['detail'], "`ids` parameter contains non-integers")
request = factory.post(reverse('resolwe-api:data-duplicate'), {'ids': [0]}, format='json')
force_authenticate(request, self.contributor)
response = self.duplicate_viewset(request)
self.assertEqual(response.data['detail'], "Data objects with the following ids not found: 0")
def test_create_issuer_authenticated(self):
view = IssuerList.as_view()
request = factory.post(
'/v1/issuer/issuers',
json.dumps(example_issuer_props),
content_type='application/json'
)
force_authenticate(request, user=get_user_model().objects.get(pk=1))
response = view(request)
self.assertEqual(response.status_code, 201)
# assert that name, description, url, etc are set properly in response badge object
badge_object = response.data.get('json')
self.assertEqual(badge_object['url'], example_issuer_props['url'])
self.assertEqual(badge_object['name'], example_issuer_props['name'])
self.assertEqual(badge_object['description'], example_issuer_props['description'])
self.assertEqual(badge_object['email'], example_issuer_props['email'])
self.assertIsNotNone(badge_object.get('id'))
self.assertIsNotNone(badge_object.get('@context'))
# assert that the issuer was published to and fetched from the cache
with self.assertNumQueries(0):
slug = response.data.get('slug')
response = self.client.get('/v1/issuer/issuers/{}'.format(slug))
self.assertEqual(response.status_code, 200)
def test_create_issuer_image_500x300_resizes_to_400x400(self):
view = IssuerList.as_view()
with open(os.path.join(os.path.dirname(__file__), 'testfiles',
'500x300.png'), 'r') as badge_image:
issuer_fields_with_image = {
'name': 'Awesome Issuer',
'description': 'An issuer of awe-inspiring credentials',
'url': 'http://example.com',
'email': '*****@*****.**',
'image': badge_image,
}
request = factory.post('/v1/issuer/issuers',
issuer_fields_with_image,
format='multipart')
force_authenticate(request,
user=get_user_model().objects.get(pk=1))
response = view(request)
self.assertEqual(response.status_code, 201)
badge_object = response.data.get('json')
derived_slug = badge_object['id'].split('/')[-1]
new_issuer = Issuer.objects.get(slug=derived_slug)
image_width, image_height = \
get_image_dimensions(new_issuer.image.file)
self.assertEqual(image_width, 400)
self.assertEqual(image_height, 400)
def test_request_tile_init_tileargs_time(self):
"""
Test initialization of timesample arguments with a single time
:return:
"""
url = '/' + version + '/tile/col1/exp1/channel1/xy/512/2/0/0/1/1/'
# Create the request dict
request_args = {
"service": "tile",
"collection_name": "col1",
"experiment_name": "exp1",
"channel_name": "channel1",
"orientation": "xy",
"tile_size": 512,
"resolution": 2,
"x_args": "0",
"y_args": "0",
"z_args": "1",
"time_args": "1"
}
# Create the request
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = Tile().initialize_request(request)
drfrequest.version = version
ret = BossRequest(drfrequest, request_args)
time = ret.get_time()
self.assertEqual(time, range(1, 2))
def test_request_tile_invalid_orientation(self):
"""
Test initialization of tile arguments for a invalid tile request. Unrecognized orientation
:return:
"""
url = '/' + version + '/tile/col1/exp1/channel1/xe/512/2/0/1/1/1/'
# Create the request dict
request_args = {
"service": "tile",
"collection_name": "col1",
"experiment_name": "exp1",
"channel_name": "channel1",
"orientation": "xe",
"tile_size": 512,
"resolution": 2,
"x_args": "0",
"y_args": "0",
"z_args": "1",
"time_args": "1"
}
# Create the request
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = Tile().initialize_request(request)
drfrequest.version = version
with self.assertRaises(BossError):
BossRequest(drfrequest, request_args)
def test_list_response_contains_expected_fields(self):
force_authenticate(self.list_request, user=self.user)
response = self.list_view(self.list_request)
data = response.data.get('results')
self.assertTrue(data, "Response contained no results")
project_data = data[0]
self.assertEquals(response.status_code, 200)
self.assertEquals(
len(project_data), EXPECTED_FIELD_COUNT,
"Number of fields does not match (%s != %s)" %
(len(project_data), EXPECTED_FIELD_COUNT)
)
self.assertEquals(project_data['id'], self.project.id)
self.assertIn('url', project_data)
self.assertEquals(project_data['name'], self.project.name)
self.assertEquals(project_data['description'], self.project.description)
self.assertIn('created_by', project_data)
self.assertIn('owner', project_data)
self.assertIn('users', project_data)
self.assertIn('leaders', project_data)
self.assertIn('uuid', project_data)
self.assertIn('instances', project_data)
self.assertIn('volumes', project_data)
self.assertIn('images', project_data)
self.assertIn('links', project_data)
self.assertIn('start_date', project_data)
self.assertIn('end_date', project_data)
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 test_multiple_polygonsets_for_one_grader_distinct(self):
grader = UserFactory()
grader.groups.add(
Group.objects.get(name=settings.RETINA_GRADERS_GROUP_NAME)
)
polygon_sets = [
self.annotation_set.polygonset1,
PolygonAnnotationSetFactory(
grader=grader, image=self.annotation_set.polygonset1.image
),
PolygonAnnotationSetFactory(
grader=grader, image=self.annotation_set.polygonset1.image
),
]
force_authenticate(self.request, user=self.retina_admin)
response = self.view(self.request, **self.kwargs)
graders = (
get_user_model()
.objects.filter(
polygonannotationset__in=polygon_sets,
groups__name=settings.RETINA_GRADERS_GROUP_NAME,
)
.distinct()
)
expected_response = UserSerializer(graders, many=True).data
expected_response.sort(key=lambda k: k["id"])
assert response.status_code == status.HTTP_200_OK
response.data.sort(key=lambda k: k["id"])
assert response.data == expected_response
def test_permissions(self):
# First user
request = factory.post('', {}, format='json')
force_authenticate(request, self.user_1)
response = self.test_viewset(request)
response = sorted(response.data, key=lambda obj: obj['name'])
self.assertEqual(len(response), 2)
self.assertEqual(response[0]['name'], 'Object name 1')
self.assertEqual(response[1]['name'], 'Object name 3')
# Second user
request = factory.post('', {}, format='json')
force_authenticate(request, self.user_2)
response = self.test_viewset(request)
response = sorted(response.data, key=lambda obj: obj['name'])
self.assertEqual(len(response), 2)
self.assertEqual(response[0]['name'], 'Object name 2')
self.assertEqual(response[1]['name'], 'Object name 3')
# Public user
request = factory.post('', {}, format='json')
response = self.test_viewset(request)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['name'], 'Object name 3')
def test_retina_grader(self):
force_authenticate(
self.request, user=self.annotation_set.polygonset1.grader
)
response = self.view(self.request, **self.kwargs)
assert response.status_code == status.HTTP_403_FORBIDDEN
def test_multiple_graders_some_retina_grader(self):
graders = (
UserFactory(),
UserFactory(),
UserFactory(),
UserFactory(),
UserFactory(),
)
polygon_sets = [self.annotation_set.polygonset1]
for index, grader in enumerate(graders):
if index % 2 == 0:
grader.groups.add(
Group.objects.get(name=settings.RETINA_GRADERS_GROUP_NAME)
)
polygon_sets.append(
PolygonAnnotationSetFactory(
grader=grader, image=self.annotation_set.polygonset1.image
)
)
force_authenticate(self.request, user=self.retina_admin)
response = self.view(self.request, **self.kwargs)
graders = get_user_model().objects.filter(
polygonannotationset__in=polygon_sets,
groups__name=settings.RETINA_GRADERS_GROUP_NAME,
)
expected_response = UserSerializer(graders, many=True).data
expected_response.sort(key=lambda k: k["id"])
assert response.status_code == status.HTTP_200_OK
response.data.sort(key=lambda k: k["id"])
assert response.data == expected_response
def test_bounding_box_service_invalid_channel_type(self):
"""
Test initialization of cutout requests for the datamodel
:return:
"""
url = '/' + version + '/boundingbox/col1/exp1/channel1/0/10'
col = 'col1'
exp = 'exp1'
channel = 'channel1'
# Create the request
request = self.rf.get(url)
force_authenticate(request, user=self.user)
drfrequest = Reserve().initialize_request(request)
drfrequest.version = version
# Create the request dict
request_args = {
"service": "boundingbox",
"version": version,
"collection_name": col,
"experiment_name": exp,
"channel_name": channel,
"resolution": 0,
"id": 10
}
with self.assertRaises(BossError):
ret = BossRequest(drfrequest, request_args)
def test(self):
admin = UserF.create()
project = ProjectF(add_admins=[admin])
observation = ObservationFactory.create(**{
'project': project
})
comment = CommentFactory.create()
factory = APIRequestFactory()
request = factory.post(
'/api/projects/%s/observations/%s/comments/' %
(project.id, observation.id),
{
'text': 'Response to a comment',
'respondsto': comment.id
}
)
force_authenticate(request, user=admin)
view = AllContributionsCommentsAPIView.as_view()
response = view(
request,
project_id=project.id,
observation_id=observation.id
).render()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
json.loads(response.content).get('error'),
'The comment you try to respond to is not a comment to the '
'observation.'
)
def test_get_game_data_player(self):
"""
Should return game session data for authenticated user upon GET
request to /play/<session_id>/ag
Should only return when its that users turn to play.
"""
test_session = GameSession.objects.get(id=1)
test_session.set_turn_data(test_json_data_global, "V")
factory = APIRequestFactory()
user = User.objects.get(username='******')
view = GameREST.as_view()
url = 'play/' + str(test_session.id) + '/ag/'
request = factory.get(url)
force_authenticate(request, user=user)
response = view(request, test_session.id)
self.assertEqual(response.data['turn_data'], test_json_data_global)
# This test is not the user that should play next
user2 = User.objects.get(username='******')
request2 = factory.get(url)
force_authenticate(request2, user=user2)
response2 = view(request2, test_session.id)
self.assertEqual(response2.data['detail'],
'You do not have permission to perform this action.')
def post(self, user, data=None):
if data is None:
data = {
'name': 'A test image',
'description': 'Test image description',
'file': get_image()
}
url = reverse(
'api:grouping_media',
kwargs={
'project_id': self.project.id,
'grouping_id': self.grouping.id,
'contribution_id': self.contribution.id
}
)
request = self.factory.post(url, data)
force_authenticate(request, user)
view = GroupingContributionsMediaApiView.as_view()
return view(
request,
project_id=self.project.id,
grouping_id=self.grouping.id,
contribution_id=self.contribution.id
).render()
def test_remove_lookupvalue_from_not_existing_field(self):
lookup_value = LookupValueFactory()
url = reverse(
'ajax:category_lookupvalues_detail',
kwargs={
'project_id': self.project.id,
'category_id': self.active_type.id,
'field_id': 45455,
'value_id': lookup_value.id
}
)
request = self.factory.delete(url)
force_authenticate(request, user=self.admin)
view = FieldLookupsUpdate.as_view()
response = view(
request,
project_id=self.project.id,
category_id=self.active_type.id,
field_id=45455,
value_id=lookup_value.id
).render()
self.assertEqual(response.status_code, 404)
def test_remove_not_exisiting_lookupvalue(self):
lookup_field = LookupFieldFactory(**{
'category': self.active_type
})
url = reverse(
'ajax:category_lookupvalues_detail',
kwargs={
'project_id': self.project.id,
'category_id': self.active_type.id,
'field_id': lookup_field.id,
'value_id': 65645445444
}
)
request = self.factory.delete(url)
force_authenticate(request, user=self.admin)
view = FieldLookupsUpdate.as_view()
response = view(
request,
project_id=self.project.id,
category_id=self.active_type.id,
field_id=lookup_field.id,
value_id=65645445444
).render()
self.assertEqual(response.status_code, 404)
def test_add_lookupvalue_with_admin(self):
lookup_field = LookupFieldFactory(**{
'category': self.active_type
})
url = reverse(
'ajax:category_lookupvalues',
kwargs={
'project_id': self.project.id,
'category_id': self.active_type.id,
'field_id': lookup_field.id
}
)
request = self.factory.post(url, {'name': 'Ms. Piggy'})
force_authenticate(request, user=self.admin)
view = FieldLookups.as_view()
response = view(
request,
project_id=self.project.id,
category_id=self.active_type.id,
field_id=lookup_field.id
).render()
self.assertEqual(response.status_code, 201)
self.assertEqual(len(lookup_field.lookupvalues.all()), 1)
def test_remove_lookupvalue_with_admin(self):
lookup_field = LookupFieldFactory(**{
'category': self.active_type
})
lookup_value = LookupValueFactory(**{
'field': lookup_field
})
url = reverse(
'ajax:category_lookupvalues_detail',
kwargs={
'project_id': self.project.id,
'category_id': self.active_type.id,
'field_id': lookup_field.id,
'value_id': lookup_value.id
}
)
request = self.factory.delete(url)
force_authenticate(request, user=self.admin)
view = FieldLookupsUpdate.as_view()
response = view(
request,
project_id=self.project.id,
category_id=self.active_type.id,
field_id=lookup_field.id,
value_id=lookup_value.id
).render()
self.assertEqual(response.status_code, 204)
self.assertEqual(
len(lookup_field.lookupvalues.filter(status='active')), 0
)
def test_authenticated_or_scoped_permission_allow(self):
self.access_token.scope = 'scope1'
self.access_token.save()
# correct token and correct scope
auth = self._create_authorization_header(self.access_token.token)
response = self.client.get("/oauth2-authenticated-or-scoped-test/", HTTP_AUTHORIZATION=auth)
self.assertEqual(response.status_code, 200)
auth = self._create_authorization_header("fake-token")
# incorrect token but authenticated
factory = APIRequestFactory()
request = factory.get("/oauth2-authenticated-or-scoped-test/")
request.auth = auth
force_authenticate(request, self.test_user)
response = AuthenticatedOrScopedView.as_view()(request)
self.assertEqual(response.status_code, 200)
# correct token but not authenticated
request = factory.get("/oauth2-authenticated-or-scoped-test/")
request.auth = auth
self.access_token.scope = 'scope1'
self.access_token.save()
force_authenticate(request, token=self.access_token)
response = AuthenticatedOrScopedView.as_view()(request)
self.assertEqual(response.status_code, 200)
def test_reorder_with_false_field(self):
url = reverse(
'ajax:category_fields_reorder',
kwargs={
'project_id': self.category.project.id,
'category_id': self.category.id
}
)
data = [
self.field_4.id, self.field_0.id, self.field_2.id, self.field_1.id,
655123135135
]
request = self.factory.post(
url, json.dumps({'order': data}), content_type='application/json')
force_authenticate(request, user=self.category.project.creator)
view = FieldsReorderView.as_view()
response = view(
request,
project_id=self.category.project.id,
category_id=self.category.id
).render()
self.assertEqual(response.status_code, 400)
fields = self.category.fields.all()
self.assertTrue(fields.ordered)
self.assertEqual(fields[0].order, 0)
self.assertEqual(fields[1].order, 0)
self.assertEqual(fields[2].order, 0)
self.assertEqual(fields[3].order, 0)
self.assertEqual(fields[4].order, 0)
def test_post_first_turn(self):
"""
Post output of game return back to django.
Authenticated user on their turn only.
Same url as get: /play/<session_id>/ag
"""
test_session = GameSession.objects.get(id=1)
test_session.set_turn_data(test_json_data_global, "V")
factory = APIRequestFactory()
user = User.objects.get(username='******')
view = GameREST.as_view()
url = 'play/' + str(test_session.id) + '/ag/'
request = factory.post(url, {'virus_player': '{"test": 1}',
'health_player': '{"test2": 2}',
'starting_from': 'india',
'testing': True,
'choice_outcome': '{"test3": 3}',
'virus_tech': '{"dog": 1}',
'health_tech': '{"cat": 2}',
'change': '{"frog": "monkey"}'
}, format='json')
force_authenticate(request, user=user)
response = view(request, test_session.id)
# for the tests, reload the session from the DB
test_session = GameSession.objects.get(id=1)
self.assertNotEqual(response.data, test_json_data_global)
self.assertEqual(response.data, 'complete')
self.assertEqual(test_session.turn_data, '{"dog": "india"}')
self.assertEqual(test_session.next_to_play, 'H')
def test_list_is_visible_to_authenticated_user(self):
force_authenticate(self.list_request, user=self.user)
response = self.list_view(self.list_request)
self.assertEquals(response.status_code, 200)
def as_privileged(self, request):
force_authenticate(request, self.privileged_user.role)
return request
def as_superuser(self, request):
force_authenticate(request, self.superuser.role)
return request
def test_comments_view_success_status_code(self):
url = reverse('api:comments')
request = self.factory.get(url)
force_authenticate(request, user=self.user)
response = self.view(request)
self.assertEquals(response.status_code, status.HTTP_200_OK)
def test_get_list_admin(self):
force_authenticate(self.request, self.admin)
response = self.list_view(self.request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_is_visible_to_authenticated_user(self):
force_authenticate(self.detail_request, user=self.user)
response = self.detail_view(self.detail_request,
pk=self.platform_type.id)
self.assertEquals(response.status_code, 200)
def test_is_not_public(self):
force_authenticate(self.detail_request, user=self.anonymous_user)
response = self.detail_view(self.detail_request,
pk=self.platform_type.id)
self.assertEquals(response.status_code, 403)
def test_init(self):
DateDim.objects.preload_year(year=2019)
TimeDim.objects.preload_times()
email = fake.email()
password = fake.password()
self.user = Account.objects.create_user(email=email, password=password)
assert self.user is not None, "User was not created"
self.doctor = self.user.create_doctor_profile()
assert self.doctor is not None, "Doctor Profile was not created"
email = fake.email()
password = fake.password()
self.user4 = Account.objects.create_user(email=email,
password=password)
assert self.user4 is not None, "User 4 was not created"
self.doctor2 = self.user4.create_doctor_profile()
assert self.doctor2 is not None, "Doctor Profile 2 was not created"
email = fake.email()
password = fake.password()
self.user2 = Account.objects.create_user(email=email,
password=password)
assert self.user2 is not None, "User 2 was not created"
self.receptionist = self.user2.create_receptionist_profile()
assert self.receptionist is not None, "Receptionist Profile 1 was not created"
email = fake.email()
password = fake.password()
self.user3 = Account.objects.create_user(email=email,
password=password)
assert self.user3 is not None, "User 3 was not created"
self.receptionist2 = self.user3.create_receptionist_profile()
assert self.receptionist2 is not None, "Receptionist Profile 2 was not created"
email = fake.email()
password = fake.password()
self.user5 = Account.objects.create_user(email=email,
password=password)
assert self.user5 is not None, "User 5 was not created"
email = fake.email()
password = fake.password()
self.user6 = Account.objects.create_user(email=email,
password=password)
assert self.user6 is not None, "User 6 was not created"
self.mi_type = MedicalInstitutionType.objects.create(name='Hospital')
assert self.mi_type is not None, "Type was not created"
m1_name = fake.name()
self.mi = MedicalInstitution.objects.create(name=m1_name,
type=self.mi_type,
added_by=self.user)
assert self.mi, f"{m1_name} not created: {self.mi}"
self.mi2 = MedicalInstitution.objects.create(name=fake.name(),
type=self.mi_type,
added_by=self.user6)
assert self.mi, f"{self.mi2.name} not created: {self.mi2}"
d1_mi1 = self.doctor.connect_medical_institution(
medical_institution=self.mi)
assert d1_mi1, f"Connection between {self.doctor} and {self.mi} not created"
d1_r1 = self.doctor.connect_receptionist(
medical_institution=self.mi, receptionist=self.receptionist)
assert d1_r1, f"Connection between {self.doctor} and {self.receptionist} at {self.mi} not created"
self.s1r, self.s1m, self.s1s = self.doctor.create_schedule(
medical_institution=self.mi,
start_time='8:00',
end_time='11:00',
start_date='2019-12-01',
end_date='2019-12-31',
days='Monday^Tuesday')
assert self.s1r, f"Schedule not created for {self.doctor} at {self.mi}"
self.a1res, self.a1, self.a1status = self.user5.base_profile(
).create_appointment(doctor_id=self.doctor.id,
medical_institution_id=self.mi.id,
day='2019-12-02',
time_start='9:00',
time_end='9:30',
appointment_type='checkup')
assert self.a1, f"{self.a1status}: {self.user5} appointment with {self.doctor} at {self.mi} on 2019-12-02 not created: {self.a1}"
# /fixtures
# should pass: same doctor
request = factory.get(
'/', {
'doctor_id': self.doctor.id,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentList.as_view()(request)
assert len(
response.data
) == 1, f"Expected len(1), got {len(response.data)}: {response.data}"
assert response.status_code == 200, f"Response: {response.data}^ Expected 200, got {response.status_code}"
# should pass: same doctor
request = factory.get('/', {
'doctor_id': self.doctor.id,
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 200, f"Response: {response.data}^ Expected 200, got {response.status_code}"
assert len(
response.data
) == 1, f"Expected len(1), got {len(response.data)}: {response.data}"
# should pass: valid receptionist for doctor
request = factory.get(
'/', {
'doctor_id': self.doctor.id,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 200, f"Response: {response.data}^ Expected 200, got {response.status_code}"
assert len(
response.data
) == 1, f"Expected len(1), got {len(response.data)}: {response.data}"
# should fail: invalid receptionist for doctor
request = factory.get(
'/', {
'doctor_id': self.doctor.id,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.receptionist2.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 403, f"Response: {response.data}^ Expected 403, got {response.status_code}"
# should fail: different doctor
request = factory.get(
'/', {
'doctor_id': self.doctor2.id,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 401, f"Response: {response.data}^ Expected 401, got {response.status_code}"
# should fail: not a doctor
request = factory.get(
'/', {
'doctor_id': 3245,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 404, f"Response: {response.data}^ Expected 404, got {response.status_code}"
# should fail: wrong mi
request = factory.get(
'/', {
'doctor_id': self.doctor.id,
'medical_institution': 235325,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 404, f"Response: {response.data}^ Expected 404, got {response.status_code}"
# should fail: wrong mi
request = factory.get(
'/', {
'doctor_id': self.doctor.id,
'medical_institution': self.mi2.id,
'day_start': '2019-12-01',
'day_end': '2019-12-31',
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentList.as_view()(request)
assert response.status_code == 404, f"Response: {response.data}^ Expected 404, got {response.status_code}"
# should pass: doctor -> pending
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'pending'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: doctor -> queueing
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'queueing'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: doctor -> in_progress
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'in_progress'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: doctor -> finishing
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'finishing'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: doctor -> done
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'done'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: doctor -> cancelled_by_doctor
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'cancelled_by_doctor'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: doctor -> rescheduled_by_doctor
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'rescheduled_by_doctor'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
#######################################################################
# patient
#######################################################################
# should pass: patient -> pending
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'pending'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: patient -> queueing
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'queueing'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should fail: patient -> in_progress
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'in_progress'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: patient -> finishing
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'finishing'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: patient -> done
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'done'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: patient -> cancelled_by_doctor
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'cancelled_by_doctor'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: patient -> rescheduled_by_doctor
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'rescheduled_by_doctor'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should succeed: patient -> cancelled_by_patient
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'cancelled_by_patient'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should succeed: patient -> rescheduled_by_patient
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'rescheduled_by_patient'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should fail: doctor -> cancelled_by_patient
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'cancelled_by_patient'
})
force_authenticate(request, user=self.doctor.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: receptionist -> rescheduled_by_patient
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'rescheduled_by_patient'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: receptionist -> cancelled_by_patient
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'cancelled_by_patient'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: receptionist -> rescheduled_by_patient
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'rescheduled_by_patient'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: invalid appointment
request = factory.get('/', {
'appointment_id': 42121,
'queue_status': 'pending'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 404, f"Expected 404, got {response.status_code}: {response.data}"
# should fail: invalid status
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'pendingasdg'
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should fail: no status
request = factory.get('/', {
'appointment_id': self.a1.id,
})
force_authenticate(request, user=self.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 400, f"Expected 400, got {response.status_code}: {response.data}"
#######################################################################
# receptionist
#######################################################################
# should pass: receptionist -> pending
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'pending'
})
force_authenticate(request, user=self.user5)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should pass: receptionist -> queueing
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'queueing'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should succeed: receptionist -> in_progress
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'in_progress'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should succeed: receptionist -> finishing
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'finishing'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should fail: receptionist -> done
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'done'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 403, f"Expected 403, got {response.status_code}: {response.data}"
# should succeed: receptionist -> cancelled_by_doctor
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'cancelled_by_doctor'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
# should succeed: receptionist -> rescheduled_by_doctor
request = factory.get('/', {
'appointment_id': self.a1.id,
'queue_status': 'rescheduled_by_doctor'
})
force_authenticate(request, user=self.receptionist.user)
response = ApiPatientAppointmentUpdateStatus.as_view()(request)
assert response.status_code == 200, f"Expected 200, got {response.status_code}: {response.data}"
def _augment_request(self, request, user: User, session_key: str) -> None:
if user:
force_authenticate(request, user=user)
request.session = FakeSession(session_key)
def test_list_is_not_public(self):
force_authenticate(self.list_request, user=self.anonymous_user)
response = self.list_view(self.list_request)
self.assertEquals(response.status_code, 403)
def test_is_visible_to_authenticated_user(self):
force_authenticate(self.request, user=self.user)
response = self.view(self.request, pk=self.identity.id)
self.assertEquals(response.status_code, 200)
def test_post_order(self):
# Define an user
user = User.objects.get(username='******')
# Delete all orders from this user
order = Order.objects.filter(user=user)
order.delete()
# Post API - creating orders - Wrong product code
factory = APIRequestFactory()
request = factory.post('api/v1/order', {
"consume_location" : "T",
"products" : [
{
"product" : -1,
"attribute" : 1,
"quantity" : 2
},
{
"product" : 4,
"quantity" : 3
}
]
}, format='json')
force_authenticate(request, user=user)
view = OrderApi.as_view()
response = view(request)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, 'Passed an invalid Product ID')
order = Order.objects.filter(user=user)
self.assertEqual(len(order),0, 'Order should be empty')
detail = {
"consume_location" : "T",
"products" : [
{
"product" : 1,
"attribute" : 1,
"quantity" : 2
},
{
"product" : 4,
"quantity" : 3
}
]
}
# Create an order
request = factory.post('api/v1/order', detail, format='json')
force_authenticate(request, user=user)
view = OrderApi.as_view()
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK, 'The order should created successfully')
# Try to create a new order
request = factory.post('api/v1/order', detail, format='json')
force_authenticate(request, user=user)
view = OrderApi.as_view()
response = view(request)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, 'The user cannot create a new waiting order')
# Start order to create a new one
order = Order.objects.get(user=user, status__description='Waiting')
order.status = StatusOrder.objects.get(description='Preparation')
order.save()
request = factory.post('api/v1/order', detail, format='json')
force_authenticate(request, user=user)
view = OrderApi.as_view()
response = view(request)
self.assertEqual(response.status_code, status.HTTP_200_OK, 'The order should created successfully')
order = Order.objects.filter(user=user, status__description='Waiting')
self.assertEqual(len(order),1, 'Order should be not empty')
order = Order.objects.filter(user=user)
self.assertEqual(len(order), 2, 'Orders should be more than one')
def test_wf_module_data_versions(self):
text1 = 'just pretend this is json'
text2 = 'and this is a later version'
# nothing ever stored
nothing = self.wfmodule1.retrieve_data()
self.assertIsNone(nothing)
# save and recover data
ver1 = self.wfmodule1.store_data(text1)
self.wfmodule1.set_stored_data_version(ver1)
self.wfmodule1.save()
self.wfmodule1.refresh_from_db()
textout = self.wfmodule1.retrieve_data()
self.assertEqual(textout, text1)
firstver = self.wfmodule1.get_stored_data_version()
# create another version
secondver = self.wfmodule1.store_data(text2)
self.wfmodule1.set_stored_data_version(secondver)
self.assertNotEqual(firstver, secondver)
textout = self.wfmodule1.retrieve_data()
self.assertEqual(textout, text2)
# change the version back
self.wfmodule1.set_stored_data_version(firstver)
textout = self.wfmodule1.retrieve_data()
self.assertEqual(textout, text1)
# invalid version string should error
with self.assertRaises(ValueError):
self.wfmodule1.set_stored_data_version('foo')
# list versions
verlist = self.wfmodule1.list_stored_data_versions()
self.assertListEqual(
verlist,
[firstver, secondver]) # sorted by creation date, ascending
# but like, none of this should have created versions on any other wfmodule
self.assertEqual(self.wfmodule2.list_stored_data_versions(), [])
# retrieve version list through the API
response = self.client.get('/api/wfmodules/%d/dataversion' %
self.wfmodule1.id)
self.assertIs(response.status_code, status.HTTP_200_OK)
versiondata = {"versions": [firstver, secondver], "selected": firstver}
responsedata = json.loads(response.content.decode('UTF-8'))
self.assertEqual(responsedata, versiondata)
# set the version back to latest through API.
# using factory.patch as trouble getting client.patch to work (400 -- authentication?)
# More or less the same thing, but does skip urls.py
request = self.factory.patch(
'/api/wfmodules/%d/dataversion' % self.wfmodule1.id,
{'selected': secondver})
force_authenticate(request, user=self.user)
response = wfmodule_dataversion(request, pk=self.wfmodule1.id)
self.assertIs(response.status_code, status.HTTP_204_NO_CONTENT)
self.wfmodule1.refresh_from_db()
self.assertEqual(self.wfmodule1.get_stored_data_version(), secondver)
def post_response(self, body: dict) -> HttpResponse:
"""Helper function that return response form /cars/ endpoint with authenticated user"""
request = self.request_factory.post(self.endpoint, body)
force_authenticate(request=request, user=self.user)
response = self.view(request)
return response
def _call_post_travels(self, payload, user=False):
request = self.factory.post('/api/v1/travel', payload, 'json')
if user:
force_authenticate(request, user=user)
return self.TravelView(request)
def test_is_not_public(self):
force_authenticate(self.request, user=self.anonymous_user)
response = self.view(self.request, pk=self.identity.id)
self.assertEquals(response.status_code, 403)
def _call_travel_update(self, travel_id, field_update):
request = self.factory.patch('/api/v1/travel/{}'.format(travel_id), field_update)
force_authenticate(request, user=self.user_with_3_travels)
return self.TravelView(request, travel_id=travel_id)
def test_start_downsample_get_status_and_check_data(self):
"""A large complex test that verifies all the pluming for downsample.
Does not validate data integrity, but does make sure data exists at different levels and iso vs. aniso."""
self.dbsetup.insert_downsample_data()
# Post some data to the channel
test_mat = np.random.randint(1, 254, (16, 1024, 1024))
test_mat = test_mat.astype(np.uint8)
h = test_mat.tobytes()
bb = blosc.compress(h, typesize=8)
factory = APIRequestFactory()
request = factory.post(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/0/0:1024/0:1024/0:16/',
bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='0',
x_range='0:1024',
y_range='0:1024',
z_range='0:16',
t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Wait for data to be written
request = factory.get(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/0/0:1024/0:1024/0:16/',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='0',
x_range='0:1024',
y_range='0:1024',
z_range='0:16',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
# Trigger downsample
factory = APIRequestFactory()
request = factory.post('/' + version +
'/downsample/col1/exp_ds_aniso/channel1/',
content_type='application/json')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Downsample.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Make Sure status has changed
factory = APIRequestFactory()
request = factory.get('/' + version +
'/downsample/col1/exp_ds_aniso/channel1/',
content_type='application/json')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Downsample.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["num_hierarchy_levels"], 5)
self.assertEqual(response.data["status"], "IN_PROGRESS")
for _ in range(0, 30):
# Make request
response = Downsample.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
if response.data["status"] != "IN_PROGRESS":
break
time.sleep(2)
# Verify now downsampled
response = Downsample.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["num_hierarchy_levels"], 5)
self.assertEqual(response.data["status"], "DOWNSAMPLED")
# Get data at res 1 and verify it's non-zero
request = factory.get(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/1/0:512/0:512/0:16/',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='1',
x_range='0:512',
y_range='0:512',
z_range='0:16',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
raw_data = blosc.decompress(response.content)
data_mat_res1_aniso = np.fromstring(raw_data, dtype=np.uint8)
data_mat_res1_aniso = np.reshape(data_mat_res1_aniso, (16, 512, 512),
order='C')
# Make sure not blank
self.assertGreater(data_mat_res1_aniso.sum(), 100)
# Get data at res 1 with iso flag and verify it's non-zero and the same as without flag
request = factory.get(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/1/0:512/0:512/0:16/?iso=true',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='1',
x_range='0:512',
y_range='0:512',
z_range='0:16',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
raw_data = blosc.decompress(response.content)
data_mat_res1_iso = np.fromstring(raw_data, dtype=np.uint8)
data_mat_res1_iso = np.reshape(data_mat_res1_iso, (16, 512, 512),
order='C')
# Make sure not blank
self.assertGreater(data_mat_res1_iso.sum(), 100)
np.testing.assert_array_equal(data_mat_res1_iso, data_mat_res1_aniso)
# Get data at res 4 with iso flag and verify it's non-zero and DIFFERENT than without flag
request = factory.get(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/4/0:256/0:256/0:8/?iso=false',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='4',
x_range='0:256',
y_range='0:256',
z_range='0:8',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
raw_data = blosc.decompress(response.content)
data_mat_res4_aniso = np.fromstring(raw_data, dtype=np.uint8)
data_mat_res4_aniso = np.reshape(data_mat_res4_aniso, (8, 256, 256),
order='C')
# Make sure not blank
self.assertGreater(data_mat_res4_aniso.sum(), 1)
# Get data at res 4 with iso flag and verify it's non-zero and DIFFERENT than without flag
request = factory.get(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/4/0:256/0:256/0:8/?iso=true',
accepts='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='4',
x_range='0:256',
y_range='0:256',
z_range='0:8',
t_range=None).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
raw_data = blosc.decompress(response.content)
data_mat_res4_iso = np.fromstring(raw_data, dtype=np.uint8)
data_mat_res4_iso = np.reshape(data_mat_res4_iso, (8, 256, 256),
order='C')
# Make sure not blank
self.assertGreater(data_mat_res4_iso.sum(), 1)
self.assertRaises(AssertionError, np.testing.assert_array_equal,
data_mat_res4_aniso, data_mat_res4_iso)
# Post data, invalidating the downsample operation
request = factory.post(
'/' + version +
'/cutout/col1/exp_ds_aniso/channel1/0/0:1024/0:1024/0:16/',
bb,
content_type='application/blosc')
# log in user
force_authenticate(request, user=self.user)
# Make request
response = Cutout.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1',
resolution='0',
x_range='0:1024',
y_range='0:1024',
z_range='0:16',
t_range=None)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Verify now NOT downsampled
request = factory.get('/' + version +
'/downsample/col1/exp_ds_aniso/channel1/',
content_type='application/json')
# log in user
force_authenticate(request, user=self.user)
response = Downsample.as_view()(request,
collection='col1',
experiment='exp_ds_aniso',
channel='channel1').render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["num_hierarchy_levels"], 5)
self.assertEqual(response.data["status"], "NOT_DOWNSAMPLED")
def get_request_factory(self):
request = self.factory.get('test')
force_authenticate(request, user=self.user, token=self.token)
return request
def _call_get_travels(self, user=False):
request = self.factory.get('/api/v1/travel')
if user:
force_authenticate(request, user=user)
return self.TravelView(request)
def test_logout(self):
request = self.factory.post('/auth/logout')
force_authenticate(request, user=self.user)
response = AuthenticationController.logout(request)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def _test_authenticated(self, data):
request = self.create_post_request(data)
force_authenticate(request, user=self.user)
response = self.view_func(request)
return response
def test_add_to_reading_list_status(self, mock_add_to_reading_list, mock_update_add_to_reading_list_status):
request = self.factory.post(self.add_reading, {'link': self.to_add_link})
force_authenticate(request, user=self.test_user)
handle_add_to_reading_list(request)
mock_update_add_to_reading_list_status.assert_called_with(self.test_user, self.to_add_link, 100)
def post_request_factory(self, data):
request = self.factory.post('', data=data, format='json')
force_authenticate(request, user=self.user, token=self.token)
return request
def test_permission_required(self):
"""
Test that user requires permission to access the API Endpoint
"""
user = mommy.make('auth.User')
# Cant Delete
client = mommy.make('main.Client')
# pylint: disable=no-member
self.assertTrue(Client.objects.filter(pk=client.id).exists())
view = ClientViewSet.as_view({'delete': 'destroy'})
request = self.factory.delete('/client/{id}'.format(id=client.id))
force_authenticate(request, user)
response = view(request=request, pk=client.id)
self.assertEqual(response.status_code, 403)
self.assertEqual('You shall not pass.',
str(response.data[0]['detail']))
# Cant Update
data = {
'name': "Solair",
}
view = ClientViewSet.as_view({'patch': 'partial_update'})
request = self.factory.patch('/tasks/{id}'.format(id=client.id),
data=data)
force_authenticate(request, user)
response = view(request=request, pk=client.id)
self.assertEqual(response.status_code, 403)
self.assertEqual('You shall not pass.',
str(response.data[0]['detail']))
# Cant Create
data = {'name': 'Flux Company'}
view = ClientViewSet.as_view({'post': 'create'})
request = self.factory.post('/tasks', data)
force_authenticate(request, user)
response = view(request=request)
self.assertEqual(response.status_code, 403)
self.assertEqual('You shall not pass.',
str(response.data[0]['detail']))
# Cant List
mommy.make('main.Client', name='Solair')
mommy.make('main.CLient', name='Generic', _quantity=7)
view = ClientViewSet.as_view({'get': 'list'})
request = self.factory.get('/client')
force_authenticate(request, user)
response = view(request=request)
self.assertEqual(response.status_code, 403)
self.assertEqual('You shall not pass.',
str(response.data[0]['detail']))
# Cant Retrieve
client = mommy.make('main.Client', name='Bob')
view = ClientViewSet.as_view({'get': 'retrieve'})
request = self.factory.get('/client/{id}'.format(id=client.id))
force_authenticate(request, user)
response = view(request=request, pk=client.id)
self.assertEqual(response.status_code, 403)
self.assertEqual('You shall not pass.',
str(response.data[0]['detail']))
def test_archive(self):
request = self.factory.post(self.archive_item,
{'link': 'https://www.google.com'})
force_authenticate(request, user=self.test_user)
response = unarchive(request)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_GameInfo(self):
robber = mixer.blend('catan.Hexe', level=1, index=2)
board = Board.objects.create(name='Colonos')
game1 = Game.objects.create(name='Juego', board=board, robber=robber)
user1 = mixer.blend(User, username='******', password='******')
user2 = mixer.blend(User, username='******', password='******')
player1 = mixer.blend('catan.Player',
username=user1,
game=game1,
colour='yellow',
development_cards=1,
resources_cards=2,
turn=1)
player2 = mixer.blend('catan.Player',
username=user2,
game=game1,
colour='green',
turn=2,
development_cards=1,
resources_cards=2)
current_turn = mixer.blend('catan.Current_Turn',
game=game1,
user=user1)
resource1 = mixer.blend('catan.Resource',
owner=player1,
game=game1,
name='wool',
last_gained=True)
building = mixer.blend('catan.Building',
name="settlement",
owner=player2,
level=2,
index=6,
game=game1)
road = mixer.blend('catan.Road',
owner=player1,
game=game1,
level_1=1,
level_2=1,
index_1=2,
index_2=1)
path = reverse('GameInfo', kwargs={'pk': 1})
request = RequestFactory().get(path)
force_authenticate(request, user=self.user, token=self.token)
view = GameInfo.as_view()
response = view(request, pk=1)
expected_data = {
'robber': {
'level': 1,
'index': 2
},
'current_turn': {
'user': '******',
'dice': [1, 1]
},
'winner':
None,
'players': [{
'username':
'******',
'colour':
'yellow',
'victory_points':
0,
'resources_cards':
1,
'development_cards':
0,
'roads': [[{
'level': 1,
'index': 2
}, {
'level': 1,
'index': 1
}]],
'last_gained': ['wool'],
'settlements': [],
'cities': []
}, {
'username': '******',
'colour': 'green',
'victory_points': 0,
'resources_cards': 0,
'development_cards': 0,
'roads': [],
'last_gained': [],
'settlements': [{
'level': 2,
'index': 6
}],
'cities': []
}]
}
assert response.data == expected_data
assert response.status_code == 200
def authed_request(access_token, request_factory):
request = request_factory.get("/")
force_authenticate(request, token=access_token.token)
return request
def _augment_request(self, request, user):
force_authenticate(request, user)
request.session = FakeSession()
def test_get_project_unauthorized(self):
request = UnauthorizedListProjectsViewTest.factory.get('/web/projects/{0}'.format(1))
force_authenticate(request, user=self.user, token=self.user.auth_token)
response = UnauthorizedListProjectsViewTest.project_details_view(request, project_id=1)
self.assertEquals(status.HTTP_403_FORBIDDEN, response.status_code)
