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)