class TestUpdateLink(TestCase): def setUp(self): super().setUp() self.client = Client() data = {'title': 'Django', 'url': 'https://github.com/django/django', 'tags': ['Web Framework', 'Python']} resp = self.client.post('/links/', content_type='application/json', data=json.dumps(data)) self.link = json.loads(resp.content.decode()) def test_update(self): data = {'title': 'Flask', 'url': 'https://github.com/mitsuhiko/flask'} pk = self.link['id'] resp = self.client.patch('/links/{}/'.format(pk), content_type='application/json', data=json.dumps(data)) obj = json.loads(resp.content.decode()) assert resp.status_code == 202 assert obj['title'] == data['title'] assert obj['url'] == data['url'] def test_update_with_bad_params(self): data = {'name': 'Flask'} pk = self.link['id'] resp = self.client.patch('/links/{}/'.format(pk), content_type='application/json', data=json.dumps(data)) assert resp.status_code == 400
class TestCategoryAPI(TestCase): def setUp(self): self.client = Client() self.client.login(username=create_test_user(password="******"), password="******") def test_list(self): category = create_test_category() self.assertEqual(1, Category.objects.count()) _, content = _get_json(reverse("category-list")) self.assertEqual(1, content["count"]) self.assertEqual(category.name, content["results"][0]["name"]) self.assertEqual(category.arxiv_code, content["results"][0]["arxiv_code"]) self.assertEqual(category.parent, content["results"][0]["parent"]) def test_post(self): """Categories can online be added by openreview (fixtures) itself.""" response = self.client.post(reverse("category-list")) self.assertEqual(response.status_code, 405, "POST should not be allowed (405 = METHOD NOT ALLOWED)") def test_put(self): response = self.client.put(reverse("category-list")) self.assertEqual(response.status_code, 405, "PUT should not be allowed (405 = METHOD NOT ALLOWED)") def test_patch(self): response = self.client.patch(reverse("category-list")) self.assertEqual(response.status_code, 405, "PATCH should not be allowed (405 = METHOD NOT ALLOWED)") def test_delete(self): response = self.client.patch(reverse("category-list")) self.assertEqual(response.status_code, 405, "DELETE should not be allowed (405 = METHOD NOT ALLOWED)")
def test__update_entry_by_api(self): c = Client() # First create response_create = c.post('/test/?type=json',{ "charfield": "test3", "numberfield": 10, "datefield": "2016-01-01" }) # Then update response = c.patch('/test/1/', "{\"charfield\": \"test1\"}", content_type='application/json') # Check it was successful self.assertEquals(response.status_code, 200) # Get test model test = [ x for x in self.loader.model_classes if x.__name__ == 'test'][0] # Create new entry queryset q = test.objects.all().filter(charfield='test1') # check if is there only one this record self.assertEqual(len(q), 1) # check modules fields self.assertEqual(q[0].charfield, 'test1') self.assertEqual(q[0].numberfield, 10) self.assertEqual(q[0].datefield, date(2016, 1, 1))
class ProjectTestCases(TestCase): @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def setUp(self): self.client = Client() @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def test_create_project(self): u = ElementalUser(password="******", username="******", trusted=True) u.save() self.client.login(username="******", password="******") data = {"data": "fake_testing_data_create", "name": "my_project", "thumbnail": "thumb"} response = self.client.post(reverse("api:project-create"), data) self.assertEqual(response.status_code, 201) try: project = Project.objects.get(data="fake_testing_data_create") except: project = None self.assertIsNotNone(project) @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def test_create_project_fail(self): u = ElementalUser(password="******", username="******") u.save() self.client.login(username="******", password="******") data = {"data": "fake_testing_data_create_fail", "name": "my_project", "thumbnail": "thumb"} response = self.client.post(reverse("api:project-create"), data) self.assertEqual(response.status_code, 403) try: project = Project.objects.get(data="fake_testing_data_create_fail") except: project = None self.assertIsNone(project) @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def test_update_project(self): u = ElementalUser(password="******", username="******") u.save() self.client.login(username="******", password="******") project = Project(name="name", user=u, data="fake_data") project.save() data = {"data": "new_data"} data = json.dumps(data) response = self.client.patch( reverse("api:project-data", args=[project.id]), data, content_type="application/json" ) try: project = Project.objects.get(data="new_data") except: project = None self.assertIsNotNone(project)
class AutoMakerEndpointTestCase(TestCase): def setUp(self): self.auto_makers = [] for i in range(3): self.auto_makers.append(factories.AutoMakerFactory()) self.c = Client() self.list_url = reverse('api:automaker-list') def test_call_get_on_list_return_all_items(self): response = self.c.get(self.list_url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.json()), 3) def test_call_post_must_create_an_item(self): data = {'name': 'Gurgel Awesome'} response = self.c.post(self.list_url, data=data) self.assertEqual(response.status_code, 201) models.AutoMaker.objects.get(name=data['name']) def test_call_patch_must_update_an_item(self): automaker = self.auto_makers[0] data = {'name': 'Gurgel Awesome'} item_url = reverse('api:automaker-detail', args=[automaker.id]) response = self.c.patch(item_url, data=json.dumps(data), content_type='application/json') self.assertEqual(response.status_code, 200, response.json()) automaker.refresh_from_db() self.assertEqual(automaker.name, 'Gurgel Awesome') def test_call_delete_must_delete_an_item(self): automaker = self.auto_makers[0] item_url = reverse('api:automaker-detail', args=[automaker.id]) response = self.c.delete(item_url) self.assertEquals(response.status_code, 204) self.assertIsNone( models.AutoMaker.objects.filter(id=automaker.id).first())
def test_done(self, client: Client) -> None: """Test whether done process works correctly when invoked correctly.""" client, headers, user = setup_user_client(client) submission = create_submission(claimed_by=user) create_transcription(submission, user) data = {"username": user.username} result = client.patch( reverse("submission-done", args=[submission.id]), json.dumps(data), content_type="application/json", **headers, ) submission.refresh_from_db() assert result.status_code == status.HTTP_201_CREATED assert submission.claimed_by == user assert submission.completed_by == user assert result.json()["original_id"] == submission.original_id
def test_approve_param_false(self, client: Client) -> None: """Verify that reverting the approval works correctly.""" client, headers, user = setup_user_client(client) submission = create_submission(id=3, approved=True) assert submission.approved data = {"approved": False} result = client.patch(reverse("submission-approve", args=[submission.id]), json.dumps(data), content_type="application/json", **headers) submission.refresh_from_db() assert result.status_code == status.HTTP_200_OK assert not submission.approved
class AvailableTestCase(TestCase): fixtures = ['scooters.json'] def setUp(self): self.base_url = '/api/v1/scooters/available/' self.client = Client() def test_regular_get_request_works(self): resp = self.client.get(self.base_url) self.assertEqual(resp.status_code, 200) resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20') self.assertEqual(len(resp.json()), 1) def test_only_get_requests_are_allowed(self): resp = self.client.post(self.base_url) self.assertEqual(resp.status_code, 405) resp = self.client.patch(self.base_url) self.assertEqual(resp.status_code, 405) resp = self.client.delete(self.base_url) self.assertEqual(resp.status_code, 405) def test_only_available_scooters_are_returned(self): resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20') self.assertEqual(len(resp.json()), 1) scooter = Scooter.get_scooter_by_id(resp.json()[0]['id']) self.assertIsNotNone(scooter) scooter.reserve() resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20') self.assertEqual(len(resp.json()), 0) def test_response_has_correct_fields(self): resp = self.client.get(self.base_url + '?lat=1.0&lon=1.0&radius=20') fields = list(resp.json()[0].keys()) self.assertEqual(fields, ['id', 'lat', 'lng']) def test_invalid_params(self): resp = self.client.get(self.base_url + '?lat=a&lon=1.0&radius=20') self.assertEqual(resp.status_code, 422)
def test_approve_param_true(self, client: Client) -> None: """Verify that approving a submission works with parameters.""" client, headers, user = setup_user_client(client) submission = create_submission(id=3) assert not submission.removed_from_queue data = {"approved": True} result = client.patch(reverse("submission-approve", args=[submission.id]), json.dumps(data), content_type="application/json", **headers) submission.refresh_from_db() assert result.status_code == status.HTTP_200_OK assert submission.approved
def test_get_token_after_token_set(self): token = models.Game.objects.get(id=1).auth_token client = Client() response = client.get(reverse("aimmo/game_token", kwargs={"id": 1})) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(token, response.json()["token"]) new_token = "aaaaaaaaaaa" response = client.patch( reverse("aimmo/game_token", kwargs={"id": 1}), json.dumps({"token": new_token}), content_type="application/json", ) # Token starts as empty, as long as it is empty, we can make more GET requests response = client.get( reverse("aimmo/game_token", kwargs={"id": 1}), HTTP_GAME_TOKEN=new_token ) self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_patch_updates_category(self, user_client: Client): initial_category: Category = CategoryFactory() new_category: Category = CategoryFactory(name="Personal") initial_content: Content = ContentFactory(category=initial_category) data: Dict[str, Any] = { "title": "Title2", "body": "Body text", "category": {"name": new_category.name}, } response = user_client.patch( reverse("panel:content_api", kwargs={"pk": str(initial_content.id)}), data=data, content_type="application/json", ) assert response.status_code == status.HTTP_200_OK, response.content assert Content.objects.count() == 1 assert Content.objects.first().category == new_category
def test_update(self): client = Client() data = { 'place_type': '테스트타입', 'metro_region': '테스트광역시', 'local_region': '테스트구', 'road_address': '수정테스트로 1', 'name': '수정테스트' } response = client.patch('/place/1', json.dumps(data), content_type='application/json') self.assertEquals(response.json(), {"message": "PLACE_UPDATED"}) self.assertEquals(response.status_code, 200) self.assertEquals(Place.objects.get(id=1).road_address, '수정테스트로 1') self.assertEquals(Place.objects.get(id=1).name, '수정테스트')
def test_get_patch_user_with_no_userprofile(self): u = User(id=23333) u.save() self.assertEqual(hasattr(u, 'userprofile'), False) client = Client() tester_login(client=client) response = client.get(user_detail_url(23333)) self.assertEqual(response.status_code, 200) # 能够正确访问 response = client.patch(user_detail_url(23333), data={"about": "I'm 23333"}, content_type='application/json') self.assertEqual(response.status_code, 200) u = User.objects.get(id=23333) self.assertEqual(hasattr(u, 'userprofile'), True) # Patch 操作创建了 userProfile self.assertEqual(u.userprofile.about, "I'm 23333")
def test_user_token__issued_at_revoke__invalid(create_user, login_user): token = "JWT " + login_user c = Client(HTTP_AUTHORIZATION=token) jwt_revocation_dt = datetime.utcnow() + timedelta(days=1) _ = c.patch( reverse("users-detail", kwargs={"pk": create_user["id"]}), content_type="application/json", data=json.dumps( {"issued_at": jwt_revocation_dt.strftime('%Y-%m-%d %H:%M:%S%z')}), ) response = c.post( reverse("users-token-verify"), content_type="application/json", data=json.dumps({"token": token}), ) assert response.status_code == status.HTTP_400_BAD_REQUEST
def test_change_mylist_name_success(self): client = Client() headers = { 'HTTP_Authorization': self.access_token, 'HTTP_Character': self.character_id } mylist_id = self.mylist_id mylist = {'new_name': '재밌는 노래들'} response = client.patch(f'/storage/mylist/{mylist_id}', json.dumps(mylist), content_type='application/json', **headers) self.assertEqual(response.status_code, 200) self.assertEqual(response.json(), {'MESSAGE': 'SUCCESS'})
def test_authority_not_authorized(francoralite_context): url_prefix = francoralite_context.URL_PREFIX client = Client() # Back (écriture) response = client.patch(url_prefix + '/api/authority/1') assert response.status_code == 403 assert response.json().get( 'detail') == 'You do not have permission to perform this action.' # Front (lecture) response = client.get(url_prefix + '/authority/edit/1') assert response.status_code == 403 assert _('Accès interdit.') in response.content.decode('utf8') # Front (écriture) response = client.post(url_prefix + '/authority/edit/1') assert response.status_code == 403 assert _('Accès interdit.') in response.content.decode('utf8')
class BoardsApiTestCase(TestCase): def setUp(self): self.client = Client() self.test_board = Boards.objects.create(name='test') def test_get_board(self): response = self.client.get(f'/api/boards/{self.test_board.id}') self.assertEqual(response.status_code, 200) self.assertEqual(response.json(), { 'id': self.test_board.id, 'name': 'test', 'bg_color': 'cadetblue' }) def test_get_boards_list(self): Boards.objects.create(name='test_2') response = self.client.get('/api/boards') self.assertEqual(response.status_code, 200) self.assertEqual(len(response.json()), 2) def test_create_board(self): response = self.client.post('/api/boards', {'name': 'test'}) self.assertEqual(response.status_code, 201) self.assertEqual(response.json(), { "id": 2, "name": "test", "bg_color": "cadetblue" }) def test_update_board(self): response = self.client.patch(f'/api/boards/{self.test_board.id}', { 'id': self.test_board.id, 'name': 'lalka' }) self.assertEqual(response.status_code, 200) self.test_board.refresh_from_db() self.assertEqual(self.test_board.name, 'lalka') def test_delete_board(self): response = self.client.delete(f'/api/boards/{self.test_board.id}') self.assertEqual(response.status_code, 204) self.assertFalse(Boards.objects.filter(id=self.test_board.id).exists())
class CollectionsUnauthorizeEndpointTestCase(StacBaseTestCase): def setUp(self): # pylint: disable=invalid-name self.client = Client() self.collection_factory = CollectionFactory() self.collection = self.collection_factory.create_sample().model self.maxDiff = None # pylint: disable=invalid-name def test_unauthorized_collection_put_patch(self): # make sure POST fails for anonymous user: # a post with the absolute valid minimum sample = self.collection_factory.create_sample(sample='collection-2') # make sure PUT fails for anonymous user: sample = self.collection_factory.create_sample( name=self.collection.name, sample='collection-2' ) response = self.client.put( f"/{STAC_BASE_V}/collections/{self.collection.name}", data=sample.get_json('put'), content_type='application/json' ) self.assertStatusCode(401, response, msg="Unauthorized put was permitted.") # make sure PATCH fails for anonymous user: response = self.client.patch( f"/{STAC_BASE_V}/collections/{self.collection.name}", data=sample.get_json('patch'), content_type='application/json' ) self.assertStatusCode(401, response, msg="Unauthorized patch was permitted.") def test_unauthorized_collection_delete(self): path = f'/{STAC_BASE_V}/collections/{self.collection.name}' response = self.client.delete(path) # Collection delete is not implemented (and currently not foreseen). # Status code here is 401, as user is unauthorized for write requests. # If logged-in, it should be 405, as DELETE for collections is not # implemented. self.assertStatusCode( 401, response, msg="unauthorized and unimplemented collection delete was permitted." )
def test_done_random_checks( self, client: Client, settings: SettingsWrapper, probability: float, gamma: int, message: bool, tor_url: [str, None], trans_url: [str, None], ) -> None: """Test whether the random checks for the done process are invoked correctly.""" # Mock both the gamma property and the random.random function. with patch("authentication.models.BlossomUser.gamma", new_callable=PropertyMock) as mock, patch( "api.views.submission._is_returning_transcriber", return_value=False), patch("random.random", lambda: probability): mock.return_value = gamma # Mock the Slack client to catch the sent messages by the function under test. slack_client.chat_postMessage = MagicMock() client, headers, user = setup_user_client(client) submission = create_submission(tor_url=tor_url, claimed_by=user) create_transcription(submission, user, url=trans_url) result = client.patch( reverse("submission-done", args=[submission.id]), json.dumps({"username": user.username}), content_type="application/json", **headers, ) slack_message = ( f"Please check the following transcription of u/{user.username}: " f"{trans_url if trans_url else tor_url}.") assert result.status_code == status.HTTP_201_CREATED if message: assert (call( channel=settings.SLACK_TRANSCRIPTION_CHECK_CHANNEL, text=slack_message, ) in slack_client.chat_postMessage.call_args_list) else: assert slack_client.chat_postMessage.call_count == 0
def test_wrong_attributes_doesnt_update_and_returns_error(self): orm_person = ORMPerson.objects.create(username='******') orm_auth_token = ORMAuthToken.objects.create(person=orm_person) experience = ORMExperience.objects.create(title='Exp', author=orm_person) orm_scene = ORMScene.objects.create(title='T', description='', latitude=1, longitude=2, experience_id=experience.id) client = Client() auth_headers = { 'HTTP_AUTHORIZATION': 'Token {}'.format(orm_auth_token.access_token), } response = client.patch( reverse('scene', args=[orm_scene.id]), urllib.parse.urlencode({ "title": "", "description": "Some description", "latitude": 0.3, "longitude": 1.2, "experience_id": experience.id }), content_type='application/x-www-form-urlencoded', **auth_headers) assert not ORMScene.objects.filter( title='', description='Some description', latitude=0.3, longitude=1.2, experience_id=experience.id).exists() body = json.loads(response.content) assert body == { 'error': { 'source': 'title', 'code': 'wrong_size', 'message': 'Title must be between 1 and 30 chars' } }
def test_nsfw_no_change(self, client: Client) -> None: """Verify that setting a submission NSFW twice doesn't change anything.""" client, headers, user = setup_user_client(client) submission = create_submission(id=3, nsfw=True) assert submission.nsfw data = {} result = client.patch( reverse("submission-nsfw", args=[submission.id]), json.dumps(data), content_type="application/json", **headers ) submission.refresh_from_db() assert result.status_code == status.HTTP_200_OK assert submission.nsfw
class ReaderUpdateViewTestCase(TestCase): def setUp(self): self.c = Client() @patch('Django.readers.views.ReaderUpdateUseCase') def test_repository_update(self, mocked_use_case): updated_reader = Reader.from_dict({ 'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33', 'full_name': 'John Doe', 'reg_date': '2015-01-01' }) mocked_use_case().execute.return_value = ro.ResponseSuccess( updated_reader) response = self.c.patch('/readers/1/', {"full_name": "John Doe"}) self.assertEqual(response.status_code, 200) self.assertEqual( json.loads(json.dumps(updated_reader, cls=readers.ReaderEncoder)), json.loads(response.content.decode('utf-8')))
def test_update_a_tweet_should_raise_a_401_unauthorized_error(): c = Client() response = c.post( reverse("tweets-list"), content_type="application/json", data=json.dumps({"name": TWEET_NAME, "content": TWEET_CONTENT}), ) assert response.status_code == status.HTTP_201_CREATED body = response.json() response = c.patch( reverse("tweets-detail", kwargs={"pk": body["id"]}), content_type="application/json", data=json.dumps({"name": TWEET_NAME, "content": TWEET_CONTENT}), ) assert response.status_code == status.HTTP_401_UNAUTHORIZED
def test_modifies_and_returns_experience(self): orm_experience = ORMExperience.objects.create(title='T', description='') client = Client() response = client.patch( reverse('experience', args=[orm_experience.id]), urllib.parse.urlencode({"description": "New description"}), content_type='application/x-www-form-urlencoded') body = json.loads(response.content) updated_experience = ORMExperience.objects.get( id=orm_experience.id, title='T', description='New description') assert updated_experience is not None assert body == { 'id': str(orm_experience.id), 'title': 'T', 'description': 'New description', 'picture': None, }
def test_nsfw_param_false(self, client: Client) -> None: """Verify that marking a submission as NSFW can be reversed.""" client, headers, user = setup_user_client(client) submission = create_submission(id=3, nsfw=True) assert submission.nsfw data = {"nsfw": False} result = client.patch( reverse("submission-nsfw", args=[submission.id]), json.dumps(data), content_type="application/json", **headers ) submission.refresh_from_db() assert result.status_code == status.HTTP_200_OK assert not submission.nsfw
def send_patch(self, user_string="user_1", do_auth=True, enforce_csrf_checks=False, *args, **kwargs): """ Send a PATCH request to the configured URL endpoint on behalf of the given user. :param user_string: The user to send the request as. :param do_auth: Whether or not to log the user in if the view requires authentication. :param enforce_csrf_checks: Whether or not to enforce CSRF checks in the HTTP client. :param args: Positional arguments for client.patch. :param kwargs: Keyword arguments for client.patch. :return: The HTTP response. """ client = Client(enforce_csrf_checks=enforce_csrf_checks) if self.requires_auth and do_auth: user = SaFaker.get_user(user_string) client.force_login(user) return client.patch( self.get_url_path(user=user_string), data=self.get_patch_data(user=user_string), *args, **kwargs )
def test_bulk_update(self): client = Client() data = [ {'parameter': Parameter.objects.create(name='a').id, 'user': 1}, {'parameter': Parameter.objects.create(name='b').id, 'user': 1}, ] response = client.post("/answers/", data=json.dumps(data), content_type='application/json') results = json.loads(response.content) data = [ {'id': results[0]['id'], 'parameter': Parameter.objects.create(name='a').id, 'user': 1}, {'id': results[1]['id'], 'parameter': Parameter.objects.create(name='b').id, 'user': 1}, ] response = client.patch("/answers/", data=json.dumps(data), content_type='application/json') results = json.loads(response.content) print results
def test_api(self): """ Test HTTP responses for API """ c = Client() ## /api/image response codes ## get image: OK self.assertEqual( c.get(f"/api/images/{self.test['image_id']}").status_code, 200) ## post, put, patch, image: MethodNotAllowed self.assertEqual( c.post(f"/api/images/{self.test['image_id']}").status_code, 405) self.assertEqual( c.put(f"/api/images/{self.test['image_id']}").status_code, 405) self.assertEqual( c.patch(f"/api/images/{self.test['image_id']}").status_code, 405) ## get image-1: NotFound self.assertEqual( c.get(f"/api/images/{self.test['image_id']-1}").status_code, 404)
def test_modifies_and_returns_scene(self): orm_person = ORMPerson.objects.create(username='******') orm_auth_token = ORMAuthToken.objects.create(person=orm_person) experience = ORMExperience.objects.create(title='Exp', author=orm_person) orm_scene = ORMScene.objects.create(title='T', description='', latitude=1, longitude=2, experience_id=experience.id) client = Client() auth_headers = { 'HTTP_AUTHORIZATION': 'Token {}'.format(orm_auth_token.access_token), } response = client.patch( reverse('scene', args=[orm_scene.id]), urllib.parse.urlencode({ "description": "New description", "latitude": 0.3, "longitude": 1.2 }), content_type='application/x-www-form-urlencoded', **auth_headers) body = json.loads(response.content) updated_scene = ORMScene.objects.get(id=orm_scene.id, title='T', description='New description', experience_id=experience.id) assert updated_scene is not None assert body == { 'id': str(orm_scene.id), 'title': 'T', 'description': 'New description', 'picture': None, 'latitude': 0.3, 'longitude': 1.2, 'experience_id': str(experience.id), }
def test_remove_reverting_approval(self, client: Client) -> None: """Verify that removing the submission reverts an approval.""" client, headers, user = setup_user_client(client) submission = create_submission(id=3, approved=True) assert not submission.removed_from_queue assert submission.approved data = {} result = client.patch(reverse("submission-remove", args=[submission.id]), json.dumps(data), content_type="application/json", **headers) submission.refresh_from_db() assert result.status_code == status.HTTP_200_OK assert submission.removed_from_queue assert not submission.approved
def test_claim_with_other_completed_claim(self, client: Client) -> None: """Test whether a user can claim a submission when another claim has been completed. The claim limit should not consider submissions that are already completed. """ client, headers, user = setup_user_client(client) create_submission(claimed_by=user, completed_by=user) submission = create_submission() data = {"username": user.username} result = client.patch( reverse("submission-claim", args=[submission.id]), data, content_type="application/json", **headers, ) submission.refresh_from_db() assert result.status_code == status.HTTP_201_CREATED assert result.json()["id"] == submission.id assert submission.claimed_by == user
def test_update_case_system_via_api(self): c = Client() self.assertEqual(Case.objects.get(id=self.case1.pk).case_name, self.case1.case_name) response = c.patch( '/api/case/%s/' % self.case1.pk, { # "role": 1, # "task": [ # { # "role": 2, # "task_name": "task_via_api_test" # } # ], "case_name": "case_via_api_test_update", }, content_type='application/json' ) self.assertEqual(response.status_code, 200) self.assertEqual(Case.objects.get(id=self.case1.pk).case_name, 'case_via_api_test_update')
def test_patch_with_invalid_value(self): field_and_invalid_example = [ ['id', self.activity.id], ['url', 'a' * 10000], ] client = Client() client.force_login(self.superuser) id = self.activity.link.first().id for field, example in field_and_invalid_example: response = client.patch(activity_link_detail_url(id), data={field: example}, content_type='application/json') if field == 'id': self.assertEqual(self.activity.link.first().url, 'https://uestc-msc.com/') else: self.assertEqual(response.status_code, 400, f"{field}={example}") # 返回 400 response = client.get(activity_link_detail_url(id)) self.assertNotEqual(response.json()[field], example) # GET 的数据并没有被修改
def testGetPatchDeleteQuest(self): user = User.objects.get(email='*****@*****.**') c = Client() c.force_login(user) respGet = c.get('/api/v1/bases/%s/questions/%s/' % (str(self.base.base_id), str(self.quest0.pk))) self.assertEqual(respGet.status_code, 200) serializer = QuestionSerializer(self.quest0) self.assertEqual(serializer.data, respGet.data) respPatch = c.patch('/api/v1/bases/%s/questions/%s/' % (str(self.base.base_id), str(self.quest0.pk)), data=json.dumps({ 'qtype': 1, 'text': 'New Text' }), content_type='application/json') self.assertEqual(respPatch.status_code, 200) self.assertEqual(respPatch.data['qtype'], 1) respDelete = c.delete('/api/v1/bases/%s/questions/%s/' % (str(self.base.base_id), str(self.quest0.pk))) self.assertEqual(respDelete.status_code, 204)
def test_report_already_removed(self, client: Client) -> None: """Verify that reporting an already removed submission doesn't do anything.""" slack_client.chat_postMessage = MagicMock() client, headers, user = setup_user_client(client) submission = create_submission(id=3, removed_from_queue=True) assert submission.removed_from_queue data = {"reason": "Violation of ALL the rules"} result = client.patch(reverse("submission-report", args=[submission.id]), json.dumps(data), content_type="application/json", **headers) submission.refresh_from_db() assert result.status_code == status.HTTP_201_CREATED assert submission.removed_from_queue assert slack_client.chat_postMessage.call_count == 0
class BookReturnViewTestCase(TestCase): def setUp(self): self.c = Client() @patch('Django.books.views.BookReturnUseCase') def test_repository_return(self, mocked_use_case): updated_book = Book.from_dict({'code': '3251a5bd-86be-428d-8ae9-6e51a8048c33', 'title': 'Fahrenheit 451', 'author': 'Ray Bradbury', 'year': 1984, 'language': 'English', 'is_available': True, 'reader': None }) mocked_use_case().execute.return_value = ro.ResponseSuccess(updated_book) response = self.c.patch('/books/1/', {"reader": None, 'action': 'take'}) self.assertEqual(response.status_code, 200) self.assertEqual(json.loads(json.dumps(updated_book, cls=books.BookEncoder)), json.loads(response.content.decode('utf-8')))
def test_api_patch_delete(self): client = Client() response = client.patch( "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk), content_type='application/json', data=json.dumps({ "aaa": { "value": None, "label": "new label", "type": "bool", }}), ) self.current_jack_dict.pop('aaa') response = client.get( "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk), content_type='application/json', ) self.assertJSONEqual( response.content, json.dumps(self.current_jack_dict), )
def test_api_patch_overwrite(self): client = Client() response = client.patch( "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk), content_type='application/json', data=json.dumps({ "aaa": { "value": "True", "label": "new label", "type": "bool", }}), ) self.current_jack_dict['aaa']['value'] = 'True' self.current_jack_dict['aaa']['label'] = 'new label' response = client.get( "%s%s/" % (RestAPITestCase.API_BASE, self.jack_pk), content_type='application/json', ) self.assertJSONEqual( response.content, json.dumps(self.current_jack_dict), )
class RootViewTestCase(CorvidTestCase): def setUp(self): super().setUpTheme() self.client = Client() def tearDown(self): super().tearDownTheme() def test_not_logged_in_redirect(self): response = self.client.get('/') self.assertEqual(response.status_code, 302) self.assertIn('/login/', response.url) def test_logged_in_go_to_home(self): self.assertTrue(self.client.login(username=self.admin_user.username, password=self.admin_password)) response = self.client.get('/') self.assertEqual(response.status_code, 302) self.assertIn('/home/', response.url) def test_other_response_types_500(self): self.assertTrue(self.client.login(username=self.admin_user.username, password=self.admin_password)) response = self.client.post('/') self.assertEqual(response.status_code, 500) response = self.client.put('/') self.assertEqual(response.status_code, 500) response = self.client.head('/') self.assertEqual(response.status_code, 500) response = self.client.delete('/') self.assertEqual(response.status_code, 500) response = self.client.patch('/') self.assertEqual(response.status_code, 500)
class TestUserDetailSerializer(unittest.TestCase): def setUp(self): self.user = User.objects.create_user('test4') self.token = Token.objects.get(user=self.user).key self.client = Client() def test_update(self): user_data = { 'email': '*****@*****.**', 'first_name': 'test4', 'last_name': 'test4', } header = {'HTTP_AUTHORIZATION': 'Token {}'.format(self.token)} user_data = encode_multipart('BoUnDaRyStRiNg', user_data) content_type = 'multipart/form-data; boundary=BoUnDaRyStRiNg' response = self.client.patch(reverse_lazy('user-detail', kwargs={'username': '******'}), user_data, content_type, **header) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(User.objects.get(username='******').email, '*****@*****.**') self.assertEqual(User.objects.get(username='******').first_name, 'test4') self.assertEqual(User.objects.get(username='******').last_name, 'test4')
class VehicleModelEndpointTestCase(TestCase): def setUp(self): self.vehicle_models = [] for i in range(3): self.vehicle_models.append(factories.VehicleModelFactory()) self.c = Client() self.list_url = reverse('api:vehiclemodel-list') def test_get_must_return_list_of_all_models(self): response = self.c.get(self.list_url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 3) def test_get_with_automaker_return_correct_list(self): model = self.vehicle_models[0] url = '{}?auto_maker={}'.format( self.list_url, model.auto_maker_id) response = self.c.get(url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['id'], model.id) def test_get_with_type_return_correct_list(self): model = self.vehicle_models[0] url = '{}?type={}'.format( self.list_url, model.model_type) response = self.c.get(url) expected = set(models.VehicleModel.objects.filter( model_type=model.model_type).values_list('id', flat=True)) result = {i['id'] for i in response.data} self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), len(expected)) self.assertEqual(result, expected) def test_post_must_create_a_vehicle_model(self): auto_maker = self.vehicle_models[0].auto_maker data = dict( name='Corsa', year=1997, auto_maker=auto_maker.id ) response = self.c.post(self.list_url, data=data) self.assertEqual(response.status_code, 201) models.VehicleModel.objects.get(name='Corsa', year=1997, auto_maker=auto_maker) def test_patch_must_edit_a_vehicle_model(self): model = self.vehicle_models[0] data = dict(name='Celta') url = reverse('api:vehiclemodel-detail', args=[model.id]) response = self.c.patch(url, data=json.dumps(data), content_type='application/json') self.assertEqual(response.status_code, 200) model.refresh_from_db() self.assertEqual(model.name, 'Celta') def test_delete_must_remove_a_vehicle(self): model = self.vehicle_models[0] url = reverse('api:vehiclemodel-detail', args=[model.id]) response = self.c.delete(url) self.assertEqual(response.status_code, 204) self.assertIsNone(models.VehicleModel.objects.filter(id=model.id).first())
class IndicatorPeriodDataTestCase(TestCase): """Tests the indicator period data REST endpoints.""" def setUp(self): """ Setup a minimal DB for the tests. """ self.project = Project.objects.create( title="REST test project", ) # Create groups check_auth_groups(settings.REQUIRED_AUTH_GROUPS) # Create organisation self.reporting_org = Organisation.objects.create( id=1337, name="Test REST reporting", long_name="Test REST reporting org", new_organisation_type=22 ) # Create partnership self.partnership = Partnership.objects.create( project=self.project, organisation=self.reporting_org, iati_organisation_role=Partnership.IATI_REPORTING_ORGANISATION, ) # Create active user self.username = "******" self.password = "******" self.user = User.objects.create_user( username=self.username, email="*****@*****.**", password=self.password, ) self.user.is_active = True self.user.is_admin = True self.user.is_superuser = True self.user.save() # Create employment self.employment = Employment.objects.create( user=self.user, organisation=self.reporting_org, is_approved=True, ) self.c = Client(HTTP_HOST=settings.RSR_DOMAIN) self.setup_results_framework() def tearDown(self): Project.objects.all().delete() User.objects.all().delete() Organisation.objects.all().delete() Group.objects.all().delete() def _create_new_user(self, group, is_admin=False, is_superuser=False): self.username2 = "username2" self.password2 = "password2" self.user2 = User.objects.create_user( username=self.username2, password=self.password2, email='{}@test.akvo.org'.format(self.username2), ) self.user2.is_active = True self.user2.is_admin = is_admin self.user2.is_superuser = is_superuser self.user2.save() group = Group.objects.get(name='M&E Managers') employment = Employment.objects.create( user=self.user2, organisation=self.reporting_org, group=group, is_approved=True, ) return employment def test_create_update(self): """Test that posting an update works.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } # When response = self.c.post(url, data=json.dumps(data), content_type='application/json') # Then self.assertEqual(201, response.status_code) def test_modify_update(self): """Test that modifying an update works.""" self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' update_url = '/rest/v1/indicator_period_data_framework/{}/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') period_data_id = json.loads(response.content)['id'] value = "10.00" # When data.update({'value': value}) response = self.c.patch(update_url.format(period_data_id), data=json.dumps(data), content_type='application/json') # Then self.assertEqual(200, response.status_code) self.assertEqual(value, json.loads(response.content)['value']) def test_create_disaggregated_update(self): """Test that creating an update with disaggregation works.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' value = "10.00" disaggregations = [{ 'dimension': self.dimension.id, 'value': value }] data = { 'period': self.period.id, 'user': self.user.id, 'value': value, 'disaggregations': disaggregations } # When response = self.c.post(url, data=json.dumps(data), content_type='application/json') # Then self.assertEqual(201, response.status_code) content = json.loads(response.content) self.assertEqual(value, content['value']) self.assertEqual(1, len(content['disaggregations'])) self.assertEqual(float(value), float(content['disaggregations'][0]['value'])) def test_modify_disaggregated_update(self): """Test that modifying an update with disaggregation works.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' value = 10 disaggregations = [{ 'dimension': self.dimension.id, 'value': value, 'update': None }] data = { 'period': self.period.id, 'user': self.user.id, 'value': value, 'disaggregations': disaggregations } update_url = '/rest/v1/indicator_period_data_framework/{}/?format=json' response = self.c.post(url, data=json.dumps(data), content_type='application/json') update_id = json.loads(response.content)['id'] new_value = "12.00" # When disaggregations[0]['value'] = data['value'] = new_value response = self.c.patch(update_url.format(update_id), data=json.dumps(data), content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(new_value, content['value']) self.assertEqual(1, len(content['disaggregations'])) self.assertEqual(float(new_value), float(content['disaggregations'][0]['value'])) def test_draft_update_invisible_to_me_manager(self): """Test that draft update is invisible to M&E managers.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') self._create_new_user(group='M&E Managers') # When self.c.logout() self.c.login(username=self.username2, password=self.password2) response = self.c.get(url, content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(0, len(content['results'])) def test_draft_update_invisible_to_other_project_editors(self): """Test that draft update is invisible to other Project Editors.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') self._create_new_user(group='Project Editors') # When self.c.logout() self.c.login(username=self.username2, password=self.password2) response = self.c.get(url, content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(0, len(content['results'])) def test_draft_update_visible_to_admin(self): """Test that draft update is visible to admins.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') content = json.loads(response.content) self._create_new_user(group='Project Editors', is_admin=True) update = IndicatorPeriodData.objects.get(id=content['id']) # When self.c.logout() self.c.login(username=self.username2, password=self.password2) response = self.c.get(url, content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(1, len(content['results'])) self.assertEqual(update.id, content['results'][0]['id']) def test_period_framework_hides_draft_updates_for_me_managers(self): """Test draft updates hidden from M&E Managers in period framework.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') self._create_new_user(group='M&E Managers') # When self.c.logout() self.c.login(username=self.username2, password=self.password2) url = '/rest/v1/indicator_period_framework/?format=json' response = self.c.get(url, content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(0, len(content['results'][0]['data'])) def test_period_framework_hides_draft_updates_for_project_editors(self): """Test draft updates hidden from other Project Editors in period framework.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') self._create_new_user(group='Project Editors') # When self.c.logout() self.c.login(username=self.username2, password=self.password2) url = '/rest/v1/indicator_period_framework/?format=json' response = self.c.get(url, content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(0, len(content['results'][0]['data'])) def test_period_framework_lists_draft_updates_for_admin(self): """Test draft updates visible to admins in the period framework.""" # Given self.c.login(username=self.username, password=self.password) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id } response = self.c.post(url, data=json.dumps(data), content_type='application/json') content = json.loads(response.content) self._create_new_user(group='Project Editors', is_admin=True) update = IndicatorPeriodData.objects.get(id=content['id']) # When self.c.logout() self.c.login(username=self.username2, password=self.password2) url = '/rest/v1/indicator_period_framework/?format=json' response = self.c.get(url, content_type='application/json') # Then self.assertEqual(200, response.status_code) content = json.loads(response.content) self.assertEqual(1, len(content['results'][0]['data'])) self.assertEqual(update.id, content['results'][0]['data'][0]['id']) def test_percentage_indicator_allows_edit_update(self): # Given self._create_new_user(group='M&E Managers') self.c.login(username=self.username2, password=self.password2) url = '/rest/v1/indicator_period_data_framework/?format=json' data = { 'period': self.period.id, 'user': self.user.id, "value": 150, "narrative": "", "text": "", "status": "D", "actual_value": 0, "numerator": "3", "denominator": "2", "disaggregations": [], } response = self.c.post(url, data=json.dumps(data), content_type='application/json') self.assertEqual(201, response.status_code) # When data['id'] = response.data['id'] data['numerator'] = '5' response = self.c.post(url, data=json.dumps(data), content_type='application/json') # Then self.assertEqual(201, response.status_code) self.assertEqual('5.00', response.data['numerator']) def setup_results_framework(self): self.result = Result.objects.create( title='Result 1', project=self.project ) self.indicator = Indicator.objects.create( title='Indicator 1', result=self.result ) self.dimension = IndicatorDimension.objects.create( indicator=self.indicator, name='Gender', value='Female', ) self.period = IndicatorPeriod.objects.create( period_start='2016-01-01', period_end='2016-12-31', indicator=self.indicator ) self.percentage_indicator = Indicator.objects.create( title='Indicator 2', result=self.result, measure='2', ) self.percentage_period = IndicatorPeriod.objects.create( period_start='2016-01-01', period_end='2016-12-31', indicator=self.percentage_indicator )
class WordlistTest(TestCase): wordlist_count = 5 words_count = 5 def setUp(self): self.client = Client() self.maxDiff = None def test_rest(self): objects = [] words = [] def detailed(i): return dict(objects[i], words=words[i]) # Create objects for i in range(0, self.wordlist_count): name = 'Colors'+str(i) resp = self.client.post(reverse('wordlist-list'), dumps( { 'name': name, 's_lang': 'sl', 't_lang': 'tl' }), content_type='application/json') self.assertEquals(201, resp.status_code) self.assertEquals(i+1, Wordlist.objects.count()); object = loads(resp.content) self.assertIn('id', object) self.assertIn('name', object) self.assertEquals(object['name'], name) objects.append(object) words.append([]) # Create words for j in range(0, self.words_count): word = { 'word': 'word'+str(j), 'wordlist': object['id'], 'translation': 'translation'+str(j) } resp = self.client.post(reverse('word-create'), dumps(word), content_type='application/json') self.assertEquals(201, resp.status_code) self.assertEquals(j+1, Wordlist.objects.get(pk=object['id']).word_set.count()); data = loads(resp.content) self.assertIn('id', data) self.assertIn('word', data) self.assertIn('wordlist', data) self.assertIn('translation', data) self.assertEquals(data['word'], word['word']) self.assertEquals(data['wordlist'], word['wordlist']) self.assertEquals(data['translation'], word['translation']) words[i].append(data) # List objects resp = self.client.get(reverse('wordlist-list')) self.assertEquals(200, resp.status_code) data = loads(resp.content) self.assertListEqual(objects, data) # Update object object = objects[0] object['name'] = 'CHANGED' resp = self.client.patch(reverse('wordlist-detail', kwargs={'pk': str(object['id'])}), dumps( { 'name': object['name'] }), content_type='application/json') self.assertEquals(200, resp.status_code) data = loads(resp.content) self.assertEquals(Wordlist.objects.get(pk=object['id']).name, object['name']) self.assertEquals(object['name'], data['name']) # Read object object = detailed(0) resp = self.client.get(reverse('wordlist-detail', kwargs={'pk': str(object['id'])})) self.assertEquals(200, resp.status_code) data = loads(resp.content) self.assertDictEqual(object, data) # Delete object object = objects[0] resp = self.client.delete(reverse('wordlist-detail', kwargs={'pk': str(object['id'])})) self.assertEquals(200, resp.status_code) data = loads(resp.content) self.assertRaises(Exception, lambda : Wordlist.objects.get(pk=object['id'])) self.assertEquals({}, data)
class ReleaseTest(TestCase): def setUp(self): self.c = Client() self.u1 = {"username": "******", "password": "******"} u = User.objects.create_user(**self.u1) u.is_superuser = True u.save() def login(self): self.c.login(username=self.u1["username"], password=self.u1["password"]) def test_create_release(self): self.login() response = self.c.post(reverse("release-list"), data={ "version": "1.0.0", "download_link": "http://www.baidu.com" }) self.assertEqual(response.status_code, 201, response.data) def test_create_release_without_login(self): response = self.c.post(reverse("release-list"), data={ "version": "1.0.0", "download_link": "http://www.baidu.com" }) self.assertEqual(response.status_code, 403, response.data) def test_get_release(self): Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com") time.sleep(0.1) Release.objects.create(version=u"1.0.1", download_link=u"http://www.baidu.com") time.sleep(0.1) r2 = Release.objects.create(version=u"1.1.1", download_link=u"http://www.baidu.com") response = self.c.get(reverse("release-list")) self.assertEqual(response.status_code, 200, response.data) self.assertEqual(len(response.data), 3, response.data) self.assertEqual(str(response.data[0].get("version")), str(r2.version), response.data) def test_update_release(self): r = Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com") self.login() response = self.c.patch(reverse("release-list") + "{}/".format(r.id), content_type="application/json", data = '{\ "version" : "1.1.0"\ }') self.assertEqual(response.status_code, 200, response.data) self.assertEqual(response.data.get("version"), "1.1.0", response.data) def test_get_latest_release(self): Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com") time.sleep(0.1) Release.objects.create(version=u"1.0.1", download_link=u"http://www.baidu.com") time.sleep(0.1) Release.objects.create(version=u"1.1.1", download_link=u"http://www.baidu.com") response = self.c.get(reverse("release-latest")) self.assertEqual(response.data.get("version"),"1.1.1",response.data) def test_log_release_request(self): Release.objects.create(version=u"1.0.0", download_link=u"http://www.baidu.com") self.c.get(reverse("release-latest")) self.assertEqual(UpgradeRequest.objects.count(),1) self.assertEqual(UpgradeRequest.objects.all()[0].ip,"127.0.0.1")
class PostTestCase(TestCase): def setUp(self): self.server = 'http://127.0.0.1' self.email = '*****@*****.**' self.password = '******' self.username = '******' self.user_object = get_user_model().objects.create_user( username=self.username, email=self.email, password=self.password, is_active=1, ) # second user self.email2 = '*****@*****.**' self.password2 = '2123456saasdfasdf' self.username2 = '2just_test' self.user_object2 = get_user_model().objects.create_user( username=self.username2, email=self.email2, password=self.password2, is_active=1 ) self.client = Client() self.client.force_login(self.user_object) # act default value self.act_title = 'just a test title' self.act_content = 'just a test content, content' self.act_thumb_url = '1490031868b2eaff2f9ae1a02ec01108757eb768d81dfc' self.act_type = 1 self.act_object = Act.objects.create( user=self.user_object, act_title=self.act_title, act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=self.act_type, act_ident=10, act_url=self.username + '/' + self.act_title, ) # post default vale self.post_content = 'just_sample_content' self.post_thumb_url = '1457502382959cf00' self.post_thumb_width = 500.0 self.post_thumb_height = 1000.0 self.post_mime_types = 1 self.nsfw = 1 self.post_object = Post.objects.create( act=self.act_object, user=self.user_object, post_content=self.post_content, post_thumb_url=self.post_thumb_url, post_thumb_width=self.post_thumb_width, post_thumb_height=self.post_thumb_height, post_mime_types=self.post_mime_types, nsfw=self.nsfw, ) def test_create_new_same_post(self): response = self.client.post('/api/posts/', { 'act': self.act_object.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 201) def test_create_new_post_content_too_long(self): post_long_content = "asdflasdfsafsadfjaskdfjasf" + \ "askdjfsldjfaskdfjsadfjsdfj" + \ "askdjfsldjfaskdfjsadfjsdfj" + \ "askdjfsldjfaskdfjsadfjsdfj" + \ "askdjfsldjfaskdfjsadfjsdfj" + \ "askdjfsldjfaskdfjsadfjsdfj" response = self.client.post('/api/posts/', { 'act': self.act_object.id, 'post_content': post_long_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 400) def test_modify_post(self): post_c_content = 'modify_post_content' post_c_thumb_url = 'modify_url' post_c_thumb_width = 100.0 post_c_thumb_height = 200.0 json_data = { 'act': self.act_object.id, 'user': self.user_object.id, 'post_content': post_c_content, 'post_thumb_url': post_c_thumb_url, 'post_thumb_width': post_c_thumb_width, 'post_thumb_height': post_c_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, } response = self.client.put( '/api/posts/' + str(self.post_object.id) + '/', json.dumps(json_data), content_type="application/json") self.assertEqual(response.status_code, 200) post_object = Post.objects.get(id=self.post_object.id) self.assertEqual(post_object.post_content, post_c_content) self.assertEqual(post_object.post_thumb_url, post_c_thumb_url) self.assertEqual(post_object.post_thumb_width, post_c_thumb_width) self.assertEqual(post_object.post_thumb_height, post_c_thumb_height) def test_delete_post(self): response = self.client.delete( '/api/posts/' + str(self.post_object.id) + '/', content_type="application/json") self.assertEqual(response.status_code, 204) def test_modify_post_without_content(self): post_c_thumb_url = 'modify_url' post_c_thumb_width = 100.0 post_c_thumb_height = 200.0 json_data = { 'act': self.act_object.id, 'user': self.user_object.id, 'post_thumb_url': post_c_thumb_url, 'post_thumb_width': post_c_thumb_width, 'post_thumb_height': post_c_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, } response = self.client.patch( '/api/posts/' + str(self.post_object.id) + '/', json.dumps(json_data), content_type="application/json") self.assertEqual(response.status_code, 200) post_object = Post.objects.get(id=self.post_object.id) self.assertEqual(post_object.post_content, self.post_content) self.assertEqual(post_object.post_thumb_url, post_c_thumb_url) self.assertEqual(post_object.post_thumb_width, post_c_thumb_width) self.assertEqual(post_object.post_thumb_height, post_c_thumb_height) def test_modify_post_without_url(self): post_c_content = 'modify_post_content' post_c_thumb_width = 100.0 post_c_thumb_height = 200.0 json_data = { 'act': self.act_object.id, 'user': self.user_object.id, 'post_content': post_c_content, 'post_thumb_width': post_c_thumb_width, 'post_thumb_height': post_c_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, } response = self.client.patch( '/api/posts/' + str(self.post_object.id) + '/', json.dumps(json_data), content_type="application/json") self.assertEqual(response.status_code, 200) post_object = Post.objects.get(id=self.post_object.id) self.assertEqual(post_object.post_content, post_c_content) self.assertEqual(post_object.post_thumb_url, self.post_thumb_url) self.assertEqual(post_object.post_thumb_width, post_c_thumb_width) self.assertEqual(post_object.post_thumb_height, post_c_thumb_height) def test_modify_ohter_user_post_failed(self): self.client.logout() self.client.force_login(self.user_object2) post_c_content = 'modify_post_content' post_c_thumb_url = 'modify_url' post_c_thumb_width = 100.0 post_c_thumb_height = 200.0 json_data = { 'act': self.act_object.id, 'user': self.user_object.id, 'post_content': post_c_content, 'post_thumb_url': post_c_thumb_url, 'post_thumb_width': post_c_thumb_width, 'post_thumb_height': post_c_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, } response = self.client.put( '/api/posts/' + str(self.post_object.id) + '/', json.dumps(json_data), content_type="application/json") self.assertEqual(response.status_code, 403) def test_modify_post_logout_failed(self): self.client.logout() post_c_content = 'modify_post_content' post_c_thumb_url = 'modify_url' post_c_thumb_width = 100.0 post_c_thumb_height = 200.0 json_data = { 'act': self.act_object.id, 'user': self.user_object.id, 'post_content': post_c_content, 'post_thumb_url': post_c_thumb_url, 'post_thumb_width': post_c_thumb_width, 'post_thumb_height': post_c_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, } response = self.client.put( '/api/posts/' + str(self.post_object.id) + '/', json.dumps(json_data), content_type="application/json") self.assertEqual(response.status_code, 403) def test_create_new_same_post_logout_failed(self): self.client.logout() response = self.client.post('/api/posts/', { 'act': self.act_object.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 403) def test_delete_post_logout(self): self.client.logout() response = self.client.delete( '/api/posts/' + str(self.post_object.id) + '/', content_type="application/json") self.assertEqual(response.status_code, 403) def test_other_delete_post_failed(self): self.client.logout() self.client.force_login(self.user_object2) response = self.client.delete( '/api/posts/' + str(self.post_object.id) + '/', content_type="application/json") self.assertEqual(response.status_code, 403) def test_admin_delete_post(self): self.admin_user = get_user_model().objects.create_user( username='******', email='*****@*****.**', password=self.password, is_active=1, is_admin=1 ) self.client.logout() self.client.force_login(self.admin_user) response = self.client.delete( '/api/posts/' + str(self.post_object.id) + '/', content_type="application/json") self.assertEqual(response.status_code, 204) def test_public_acts_author_can_join(self): public_act = Act.objects.create( user=self.user_object, act_title='public_act', act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=2, act_ident=10, act_url=self.username + '/' + self.act_title, ) self.client = Client() self.client.force_login(self.user_object) response = self.client.post('/api/posts/', { 'act': public_act.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 201) def test_public_acts_other_can_join(self): public_act = Act.objects.create( user=self.user_object, act_title='public_act', act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=2, act_ident=10, act_url=self.username + '/' + self.act_title, ) self.client = Client() self.client.force_login(self.user_object2) response = self.client.post('/api/posts/', { 'act': public_act.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 201) def test_group_acts_author_can_join(self): group_act = Act.objects.create( user=self.user_object, act_title='public_act', act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=1, act_ident=10, act_url=self.username + '/' + self.act_title, ) self.client = Client() self.client.force_login(self.user_object) response = self.client.post('/api/posts/', { 'act': group_act.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 201) def test_group_acts_other_can_join(self): group_act = Act.objects.create( user=self.user_object, act_title='public_act', act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=1, act_ident=10, act_url=self.username + '/' + self.act_title, ) self.client = Client() self.client.force_login(self.user_object2) response = self.client.post('/api/posts/', { 'act': group_act.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 201) def test_private_acts_author_can_join(self): private_act = Act.objects.create( user=self.user_object, act_title='public_act', act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=0, act_ident=10, act_url=self.username + '/' + self.act_title, ) self.client = Client() self.client.force_login(self.user_object) response = self.client.post('/api/posts/', { 'act': private_act.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 201) def test_private_acts_other_join_failed(self): private_act = Act.objects.create( user=self.user_object, act_title='public_act', act_content=self.act_content, act_thumb_url=self.act_thumb_url, act_type=0, act_ident=10, act_url=self.username + '/' + self.act_title, ) self.client = Client() self.client.force_login(self.user_object2) response = self.client.post('/api/posts/', { 'act': private_act.id, 'post_content': self.post_content, 'post_thumb_url': self.post_thumb_url, 'post_thumb_width': self.post_thumb_width, 'post_thumb_height': self.post_thumb_height, 'post_mime_types': self.post_mime_types, 'nsfw': self.nsfw, }) self.assertEqual(response.status_code, 403)
class UserTest(TestCase): def setUp(self): self.client = Client() self.token = Token.objects.get(user=factories.UserFactory()) self.url = '/api/users/update_details' self.user = factories.UserFactory() self.new_email = '*****@*****.**' self.new_password = '******' self.current_password = '******' self.user.set_password(self.current_password) self.user.save() self.reset_password_url = '/api/passwords/reset_password' self.reset_password_complete_url = '/api/passwords/reset_password_complete' grant_permissions() def test_update_email(self): data = { 'id': self.user.id, 'email': self.new_email, 'auth': str(self.token), 'current-password': self.current_password, } response = self.client.patch( path=self.url, data=json.dumps(data), content_type='application/json', HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token) ) assert_equals(response.status_code, status.HTTP_200_OK) assert_not_equals(self.user.email, self.new_email) assert_equals(User.objects.get(pk=self.user.id).email, self.new_email) def test_update_password(self): data = { 'id': self.user.id, 'password': self.new_password, 'auth': str(self.token), 'current-password': self.current_password, } response = self.client.patch( path=self.url, data=json.dumps(data), content_type='application/json', HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token) ) assert_equals(response.status_code, status.HTTP_200_OK) assert_false(self.user.check_password(self.new_password)) assert_true(User.objects.get(pk=self.user.id).check_password(self.new_password)) def test_update_missing_field(self): data = { 'id': self.user.id, 'username': '******', 'auth': str(self.token), } response = self.client.patch( path=self.url, data=json.dumps(data), content_type='application/json', HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token) ) assert_equals(response.status_code, status.HTTP_400_BAD_REQUEST) assert_equals(User.objects.get(pk=self.user.id), self.user) @patch('api.views.PasswordResetTokenGenerator.make_token') def test_reset_password(self, PasswordResetTokenGeneratorMock): data = { 'email': self.user.email, } PasswordResetTokenGeneratorMock.return_value = 'abc' response = self.client.post( path=self.reset_password_url, data=json.dumps(data), content_type='application/json', ) assert_equals(response.status_code, status.HTTP_201_CREATED) assert_equals(len(mail.outbox), 1) assert_equals(mail.outbox[0].subject, 'Reset Your Password') data = { 'reset_token': 'abc', 'new_password': self.new_password, 'password_confirmation': self.new_password, } response = self.client.post( path=self.reset_password_complete_url, data=json.dumps(data), content_type='application/json' ) assert_equals(response.status_code, status.HTTP_200_OK) assert_true(User.objects.get(pk=self.user.id).check_password(self.new_password)) assert_is_none(cache.get(self.user.email))
class ApiTestCase(TestCase): def setUp(self): self.factory = RequestFactory() self.client = Client() def test_api_url(self): response = self.client.get('/') self.assertEqual(response.status_code, 200) def test_todos_url(self): response = self.client.get('/todos') self.assertEqual(response.status_code, 200) def test_get_existing_todo(self): todo = Todo.objects.create(name="My todo name", description="This is my description") response = self.client.get('/todos/%i' % todo.id) self.assertEqual(response.status_code, 200) returned_object = json.loads(response.content) self.assertEqual(returned_object.get('name'), todo.name) self.assertEqual(returned_object.get('description'), todo.description) self.assertEqual(returned_object.get('checked'), todo.checked) def test_get_todos(self): expected_items = 10 for i in range(0, expected_items): Todo.objects.create(name="My todo name", description="This is my description") response = self.client.get('/todos') content = json.loads(response.content) self.assertEqual(int(content.get('count')), expected_items) def test_post_todo(self): todo_dict = { 'name': 'My Todo', 'description': 'My Todo Description', } response = self.client.post('/todos', todo_dict) self.assertEqual(response.status_code, 201) def test_delete_todo(self): todo = Todo.objects.create(name="My todo name", description="This is my description") response = self.client.delete('/todos/%i' % todo.id) self.assertEqual(response.status_code, 204) def test_update_todo(self): todo = Todo.objects.create(name="My todo name", description="This is my description") todo_new_content = { 'name': 'New Name', 'description': 'New Description', } response = self.client.put('/todos/%i' % todo.id, data=json.dumps(todo_new_content), content_type='application/json') self.assertEqual(response.status_code, 200) new_todo = Todo.objects.get(id=todo.id) self.assertEqual(new_todo.name, todo_new_content.get('name')) self.assertEqual(new_todo.description, todo_new_content.get('description')) def test_check_todo(self): todo = Todo.objects.create(name="My todo name", description="This is my description") todo_new_content = {'checked': True} response = self.client.patch('/todos/%i' % todo.id, data=json.dumps(todo_new_content), content_type='application/json') self.assertEqual(response.status_code, 200) new_todo = Todo.objects.get(id=todo.id) self.assertEqual(new_todo.checked, True)
def generate_all_emails(request: HttpRequest) -> HttpResponse: if not settings.TEST_SUITE: # nocoverage # It's really convenient to automatically inline the email CSS # here, since that saves a step when testing out changes to # the email CSS. But we don't run this inside the test suite, # because by role, the tests shouldn't be doing a provision-like thing. subprocess.check_call(["./tools/inline-email-css"]) # We import the Django test client inside the view function, # because it isn't needed in production elsewhere, and not # importing it saves ~50ms of unnecessary manage.py startup time. from django.test import Client client = Client() # write fake data for all variables registered_email = "*****@*****.**" unregistered_email_1 = "*****@*****.**" unregistered_email_2 = "*****@*****.**" realm = get_realm("zulip") other_realm = Realm.objects.exclude(string_id='zulip').first() user = get_user_by_delivery_email(registered_email, realm) host_kwargs = {'HTTP_HOST': realm.host} # Password reset emails # active account in realm result = client.post('/accounts/password/reset/', {'email': registered_email}, **host_kwargs) assert result.status_code == 302 # deactivated user user.is_active = False user.save(update_fields=['is_active']) result = client.post('/accounts/password/reset/', {'email': registered_email}, **host_kwargs) assert result.status_code == 302 user.is_active = True user.save(update_fields=['is_active']) # account on different realm result = client.post('/accounts/password/reset/', {'email': registered_email}, HTTP_HOST=other_realm.host) assert result.status_code == 302 # no account anywhere result = client.post('/accounts/password/reset/', {'email': unregistered_email_1}, **host_kwargs) assert result.status_code == 302 # Confirm account email result = client.post('/accounts/home/', {'email': unregistered_email_1}, **host_kwargs) assert result.status_code == 302 # Find account email result = client.post('/accounts/find/', {'emails': registered_email}, **host_kwargs) assert result.status_code == 302 # New login email logged_in = client.login(dev_auth_username=registered_email, realm=realm) assert logged_in # New user invite and reminder emails result = client.post("/json/invites", {"invitee_emails": unregistered_email_2, "stream": ["Denmark"]}, **host_kwargs) assert result.status_code == 200 # Verification for new email result = client.patch('/json/settings', urllib.parse.urlencode({'email': '*****@*****.**'}), **host_kwargs) assert result.status_code == 200 # Email change successful key = Confirmation.objects.filter(type=Confirmation.EMAIL_CHANGE).latest('id').confirmation_key url = confirmation_url(key, realm.host, Confirmation.EMAIL_CHANGE) user_profile = get_user_by_delivery_email(registered_email, realm) result = client.get(url) assert result.status_code == 200 # Reset the email value so we can run this again do_change_user_delivery_email(user_profile, registered_email) # Follow up day1 day2 emails for normal user enqueue_welcome_emails(user_profile) # Follow up day1 day2 emails for admin user enqueue_welcome_emails(get_user_by_delivery_email("*****@*****.**", realm), realm_creation=True) # Realm reactivation email do_send_realm_reactivation_email(realm) return redirect(email_page)
class PageTest(TestCase): def setUp(self): self.client = Client() self.user = factories.UserFactory() procedure = factories.ProcedureFactory() self.page1 = factories.PageFactory(display_index=0, procedure=procedure) self.page2 = factories.PageFactory(display_index=1, procedure=procedure) self.page3 = factories.PageFactory(display_index=2, procedure=procedure) self.token = Token.objects.get(user=self.user) self.partial_bulk_url = "/api/pages/partial_bulk_update/" @initialize_permissions def test_page_reorder_back(self): data = [ {"id": self.page1.id, "display_index": 1}, {"id": self.page2.id, "display_index": 0}, {"id": self.page3.id, "display_index": 2}, ] response_patch = self.client.patch( path=self.partial_bulk_url, data=json.dumps(data), content_type="application/json", HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token), ) assert_equals(response_patch.status_code, status.HTTP_200_OK) json_resp = json.loads(response_patch.content) for page in json_resp: if page["id"] == self.page1.id: assert_equals(page["display_index"], 1) elif page["id"] == self.page2.id: assert_equals(page["display_index"], 0) elif page["id"] == self.page3.id: assert_equals(page["display_index"], 2) else: assert_true(False) @initialize_permissions def test_page_reorder_forward(self): data = [ {"id": self.page1.id, "display_index": 0}, {"id": self.page2.id, "display_index": 2}, {"id": self.page3.id, "display_index": 1}, ] response_patch = self.client.patch( path=self.partial_bulk_url, data=json.dumps(data), content_type="application/json", HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token), ) assert_equals(response_patch.status_code, status.HTTP_200_OK) json_resp = json.loads(response_patch.content) for page in json_resp: if page["id"] == self.page1.id: assert_equals(page["display_index"], 0) elif page["id"] == self.page2.id: assert_equals(page["display_index"], 2) elif page["id"] == self.page3.id: assert_equals(page["display_index"], 1) else: assert_true(False) @initialize_permissions def test_page_reorder_blank_data(self): data = [] response_patch = self.client.patch( path=self.partial_bulk_url, data=json.dumps(data), content_type="application/json", HTTP_AUTHORIZATION=add_token_to_header(self.user, self.token), ) assert_equals(response_patch.status, status.HTTP_400_BAD_REQUEST)
class AccountsTestCase(LiveServerTestCase): def setUp(self): self.userOne = { 'email': '*****@*****.**', 'password': '******', 'first_name': 'FirstNameOne', 'last_name': 'LastNameOne', } self.userTwo = { 'email': '*****@*****.**', 'password': '******', 'first_name': 'FirstNameTwo', 'last_name': 'LastNameTwo', } self.userThree = { 'email': '*****@*****.**', 'password': '******', 'first_name': 'FirstNameThree', 'last_name': 'LastNameThree', } EmailUser.objects.create_superuser('*****@*****.**', 'p') self.client.post(reverse('users-list'), self.userOne) self.client.post(reverse('users-list'), self.userTwo) self.client.post(reverse('users-list'), self.userThree) self.user_one = get_user_model().objects.get( email=self.userOne['email']) self.user_two = get_user_model().objects.get( email=self.userTwo['email']) self.user_three = get_user_model().objects.get( email=self.userThree['email']) self.user_admin = get_user_model().objects.get(email='*****@*****.**') self.client = Client() def get_login(self, email, password): self.client.login(email=email, password=password) def patch_detail(self, pk, data): return self.client.patch( reverse('users-detail', args=[pk]), data=json.dumps(data), content_type='application/json') def delete_detail(self, pk): return self.client.delete( reverse('users-detail', args=[pk])) def test_get_list_without_auth(self): """ Declines unauthorized users from getting all users """ response = self.client.get(reverse('users-list')) self.assertEqual(response.status_code, 401) def test_get_detail_without_auth(self): """ Declines unauthorized users from getting detail user """ response = self.client.get(reverse('users-detail', args=[self.user_one.id])) self.assertEqual(response.status_code, 401) def test_get_other_user(self): """ Allows getting other users """ self.get_login(self.userTwo['email'], self.userTwo['password']) response = self.client.get(reverse('users-detail', args=[self.user_one.id])) self.assertEqual(response.data['first_name'], 'FirstNameOne') def test_get_users(self): """ Allows getting user lists """ self.get_login(self.userTwo['email'], self.userTwo['password']) response = self.client.get(reverse('users-list')) self.assertEqual(response.status_code, 200) def test_edit_other_user(self): """ Declines editing other users """ self.get_login(self.userTwo['email'], self.userTwo['password']) response = self.patch_detail(self.user_one.id, {"first_name": "Bill"}) self.assertEqual( response.data, {'detail': 'You do not have permission to perform this action.'}) def test_super_edit_other_user(self): """ Allows superusers to edit other users """ self.get_login('*****@*****.**', 'p') response = self.patch_detail(self.user_two.id, {"first_name": "Bill"}) self.assertEqual(response.data["first_name"], "Bill") def test_edit_self(self): """ Allows user to edit themselves """ self.get_login(self.userThree['email'], self.userThree['password']) response = self.patch_detail(self.user_three.id, {"first_name": "Bill"}) self.assertEqual(response.data["first_name"], "Bill") def test_edit_status(self): """ Declines editing user status """ self.get_login(self.userThree['email'], self.userThree['password']) response = self.patch_detail(self.user_three.id, {"is_developer": True}) self.assertEqual(response.data['is_developer'], False) self.patch_detail(self.user_three.id, {"is_superUser": True}) response = self.patch_detail(self.user_two.id, {'first_name': 'John'}) self.assertEqual( response.data, {'detail': 'You do not have permission to perform this action.'}) def test_delete_self(self): """ Allows deleting yourself """ self.get_login(self.userThree['email'], self.userThree['password']) response = self.delete_detail(self.user_three.id) self.assertEqual(response.status_code, 204) def test_delete_other(self): """ Declines normal users to delete other users """ self.get_login(self.userThree['email'], self.userThree['password']) response = self.delete_detail(self.user_two.id) self.assertEqual( response.data, {'detail': 'You do not have permission to perform this action.'}) def test_super_delete_other(self): """ Allows superusers to delete other users """ self.get_login('*****@*****.**', 'p') response = self.delete_detail(self.user_two.id) self.assertEqual(response.status_code, 204) def test_create_user(self): """ Allows creation of user without login """ self.userEight = {'email': '*****@*****.**', 'password': '******', 'first_name': 'FirstName', 'last_name': 'LastName', } response = self.client.post(reverse('users-list'), self.userEight) self.assertEqual(response.status_code, 201) def test_create_superuser(self): """ If we try to create a superuser via the API, just create a normal user. """ self.userEight = {'email': '*****@*****.**', 'password': '******', 'first_name': 'FirstName', 'last_name': 'LastName', 'is_superuser': True} response = self.client.post(reverse('users-list'), self.userEight) self.assertEqual(response.status_code, 201) self.get_login(self.userEight['email'], self.userEight['password']) response = self.patch_detail(self.user_two.id, {'first_name': 'John'}) self.assertEqual( response.data, {'detail': 'You do not have permission to perform this action.'})
class LoadWebserviceTest(TestCase): """ Test the webservice generated by previous unit test. """ def setUp(self): # Conf for webservice self.app_folder = join(join(settings.DJANGO_ROOT, "apps"), "webservice") # Create user, token, permissions and client self.user = User.objects.create(username="******", password="******") self.token = Token.objects.create(user=self.user, key=b'S3CR3T') self.client = Client() self.client.login(username='******', password='******') # permissions content_type = ContentType.objects.get_for_model(WsDjangoSite) Permission.objects.create(codename='Can view auth user', name='Can view auth user', content_type=content_type) self.user.user_permissions = Permission.objects.all() self.headers = {'HTTP_AUTHORIZATION': 'Token S3CR3T'} # fines permissions ct = ContentType.objects.get_by_natural_key("webservice", "djangosite") FieldPermission.objects.create(name="id", content_type=ct) FieldPermission.objects.create(name="domain", content_type=ct) FieldPermission.objects.create(name="name", content_type=ct) fields_perms = FieldPermission.objects.all() ufp = UserFieldPermissions.objects.create(user=self.user) ufp.permissions.add(*fields_perms) def test_ws1_post(self): response = self.client.post('/webservice/djangosite.json', data=json.dumps({'id': 2, 'domain': 'mydomain', 'name':'myname'}), content_type='application/json', **self.headers) self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name': 'myname'}) def test_ws2_get(self): response = self.client.get('/webservice/djangosite/2.json', **self.headers) self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name':'myname'}) def test_ws3_list(self): response = self.client.get('/webservice/djangosite.json', **self.headers) self.assertTrue({'id': 2, 'domain': 'mydomain', 'name': 'myname'} in response.data) def test_ws4_patch(self): response = self.client.patch('/webservice/djangosite/2.json', data=json.dumps({'name': 'newname'}), content_type='application/json', **self.headers) self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name': 'newname'}) def test_ws5_put(self): response = self.client.put('/webservice/djangosite/2.json', data=json.dumps({'name': 'newname2', 'domain':'mydomain','id':2}), content_type='application/json', **self.headers) self.assertEqual(response.data, {'id': 2, 'domain': 'mydomain', 'name': 'newname2'}) def test_ws6_delete(self): self.client.delete('/webservice/djangosite/2.json', **self.headers) response2 = self.client.get('/webservice/djangosite/2.json', **self.headers) self.assertEqual(response2.data, {'error': 'Not found'})
class ProfileTestCase(TestCase): def setUp(self): self.client = Client() # Every test needs access to the request factory. self.factory = RequestFactory() self.admin = User.objects.create_user( username='******', email='*****@*****.**', password='******') self.user = User.objects.create_user( username='******', email='*****@*****.**', password='******') os.environ['RECAPTCHA_TESTING'] = 'True' def _login_with_api(self, email, password): """ Perform login attempt using the login service. """ data = { 'email': email, 'password': password, } body = json.dumps(data) response = self.client.post( reverse("api_dispatch_login", kwargs={ "resource_name": "user", "api_name": "v1", }), data=body, follow=True, content_type='application/json') return response def test_login(self): """ Tests that login service works like a charm. """ # self.client.logout() response = self._login_with_api('*****@*****.**', '654321') self.assertEqual(response.status_code, 200) # print "== response:", response.content response_data = json.loads(response.content) self.assertEqual(response_data.get('success'), True) def test_logout(self): """ Tests that logout service works like a charm. """ self.client.logout() loged_in = self.client.login(username='******', password='******') self.assertEqual(loged_in, True) response = self.client.post( reverse("api_dispatch_logout", kwargs={ "resource_name": "user", "api_name": "v1", }), follow=True, content_type='application/json') self.assertEqual(response.status_code, 200) # print response.content response_data = json.loads(response.content) self.assertEqual(response_data.get('success'), True) def test_user_api_detail(self): """ Test user api detail response. """ loged_in = self.client.login(username='******', password='******') self.assertEqual(loged_in, True) response = self.client.get( reverse("api_dispatch_me", kwargs={ "resource_name": "user", "api_name": "v1", }), {'format': 'json'}, follow=True) self.assertEqual(response.status_code, 200) admin_data = json.loads(response.content) self.assertEqual(admin_data.get('username'), 'tester') for i in range(TASTYPROFILE_API_THROTTLE): response = self.client.get( reverse("api_dispatch_me", kwargs={ "resource_name": "user", "api_name": "v1", }), {'format': 'json'}, follow=True) self.assertEqual(response.status_code, 429) time.sleep(TASTYPROFILE_API_TIMEFRAME + 1) response = self.client.get( reverse("api_dispatch_me", kwargs={ "resource_name": "user", "api_name": "v1", }), {'format': 'json'}, follow=True) self.assertEqual(response.status_code, 200) admin_data = json.loads(response.content) self.assertEqual(admin_data.get('username'), 'tester') def _register_with_api(self, data): """ Request user registration using REST Api. """ self.client.logout() json_data = json.dumps(data) os.environ['RECAPTCHA_TESTING'] = 'True' response = self.client.post( reverse("api_dispatch_list", kwargs={ "resource_name": "user", "api_name": "v1", }), data=json_data, content_type='application/json') return response def test_register(self): """ Test successful user registration and login with that user. """ mail.outbox = [] response = self._register_with_api({ 'first_name': 'Testy', 'last_name': 'Testerson', 'email': '*****@*****.**', 'password': '******', 'repeat_password': '******', 'g-recaptcha-response': 'PASSED', }) print response.content self.assertEqual(response.status_code, 201) self.assertEqual(response.content, '') # Try to login with newly created user. response = self._login_with_api('*****@*****.**', 'roman.polansky') self.assertEqual(response.status_code, 200) response_data = json.loads(response.content) self.assertEqual(response_data.get('success'), True) response = self.client.get( reverse("api_dispatch_me", kwargs={ "resource_name": "user", "api_name": "v1", }), {'format': 'json'}, follow=True) self.assertEqual(response.status_code, 200) def test_register_errors(self): """ Test errors for void input. """ self.client.logout() response = self._register_with_api({}) # print "== response:", response.content self.assertEqual(response.status_code, 400) error_data = json.loads(response.content) self.assertEqual(type(error_data.get('user')), dict) # assert False, set(error_data.get('user').keys()) self.assertTrue( set([ u'username', u'first_name', u'last_name', u'repeat_password', u'captcha', u'password', u'email', ]).issubset(set(error_data.get('user').keys())) ) def test_user_update(self): """ Test successful profile update. """ loged_in = self.client.login(username='******', password='******') data = { 'first_name': 'Changed', 'email_alt': '*****@*****.**', 'state': 'JAL' } json_data = json.dumps(data) response = self.client.patch( reverse("api_dispatch_detail", kwargs={ "resource_name": "user", "api_name": "v1", "username": "******" }), data=json_data, content_type='application/json') self.assertEqual(response.status_code, 202) self.assertEqual(response.content, '') user = User.objects.get(username='******') self.assertEqual(user.first_name, 'Changed') def test_password_reset_invalid_email(self): mail.outbox = [] self.client.logout() json_data = json.dumps({ 'email': 'tester@example' }) response = self.client.post( reverse('api_dispatch_password_reset', kwargs={ 'resource_name': 'user', 'api_name': 'v1', }), data=json_data, content_type='application/json') response_data = json.loads(response.content) self.assertEqual(response.status_code, 400) self.assertEqual(response_data['success'], 'False') error_message = str(response_data['errors']['email']) self.assertIn('Enter a valid email address', error_message) def test_password_reset(self): """ Test the password reset service. """ mail.outbox = [] self.client.logout() json_data = json.dumps({ 'email': '*****@*****.**' }) UserResource._meta.cache.set('*****@*****.**', False) response = self.client.post( reverse("api_dispatch_password_reset", kwargs={ "resource_name": "user", "api_name": "v1", }), data=json_data, content_type='application/json') data = json.loads(response.content) self.assertEqual(response.status_code, 200) self.assertTrue(data.get('success')) # Test that one message has been sent. self.assertEqual(len(mail.outbox), 1) password_reset_email = mail.outbox[0] # Verify that the subject of the first message is correct. self.assertEqual( password_reset_email.subject, u'Password reset on testserver') match = re.search( r'\?token=%s-%s' % (UIDB36_REGEX, TOKEN_REGEX), str(password_reset_email.message())) uidb36 = match.group('uidb36') token = match.group('token') json_data = json.dumps({ 'new_password1': '123456', 'new_password2': '123456', }) response = self.client.post( reverse("api_dispatch_password_reset_confirm", kwargs={ "resource_name": "user", "api_name": "v1", "uidb36": uidb36, "token": token, }), data=json_data, content_type='application/json') self.assertEqual(response.status_code, 200) self.assertTrue(data.get('success')) loged_in = self.client.login(username='******', password='******') self.assertTrue(loged_in) def test_password_change(self): """ Test the password change service. """ # Test unauthenticated request self.client.logout() json_data = json.dumps({}) response = self.client.post( '/api/v1/user/tester/password-change/', data=json_data, content_type='application/json') self.assertEqual(response.status_code, 400) loged_in = self.client.login(username='******', password='******') self.assertTrue(loged_in) # Bad data json_data = "" response = self.client.post( reverse("api_dispatch_password_change", kwargs={ "resource_name": "user", "api_name": "v1", "username": "******", }), data=json_data, content_type='application/json') self.assertEqual(response.status_code, 400) # Test missing parameters json_data = "" response = self.client.post( reverse("api_dispatch_password_change", kwargs={ "resource_name": "user", "api_name": "v1", "username": "******", }), data=json_data, content_type='application/json') self.assertEqual(response.status_code, 400) json_data = json.dumps({ 'old_password': '******', 'new_password1': '123456', 'new_password2': '123456', }) response = self.client.post( reverse("api_dispatch_password_change", kwargs={ "resource_name": "user", "api_name": "v1", "username": "******", }), data=json_data, content_type='application/json') data = json.loads(response.content) self.assertEqual(response.status_code, 200) self.assertTrue(data.get('success'))
class PatchRequests(TestCase): fixtures = ['nice_fixture3.json'] def setUp(self): self.client = Client() response = self.client.post(AUTH_URL, data=TEST_USER_ALICE_JSON, content_type='application/json') self.token = json.loads(response.content)['token'] # def test_can_make_patch_request_to_post(self): # payload = { # "content": "This is some patched content." # } # response = self.client.patch(POSTS_URL, data=payload, HTTP_X_AUTHORIZATION=self.token) # self.assertEqual(response.status_code, 201) def test_requires_authorization(self): patch_request = self.client.patch(POSTS_URL + '/12345') self.assertEqual(patch_request.status_code, 401) def test_returns_not_found_on_bad_pk(self): patch_request = self.client.patch(POSTS_URL + '/a', HTTP_X_AUTHORIZATION=self.token) self.assertIn("{", patch_request.content) self.assertEqual(patch_request.status_code, 404) def test_can_make_update_to_existing_post(self): payload = { "content": "This is my sentence. This is my modified sentence. This is a third." } payload = json.dumps(payload) warnings.warn("Patch requests only support json") patch_request = self.client.patch(POSTS_URL + "/1", data=payload, HTTP_X_AUTHORIZATION=self.token, content_type='application/json') print(patch_request.content) self.assertEqual(patch_request.status_code, 201) def test_can_merge_with_old_sentences_in_post(self): post = Post.objects.get(parent_content_type=ContentType.objects.get(name="blog"), parent_id = 1) ed = Edition.objects.filter(parent = post) sentences = Sentence.objects.filter(edition = ed) test_content = ' '.join( [sentences[0].text.value, sentences[1].text.value] ) test_content += ' This is a third unmerged sentence.' payload = { "content": test_content } payload = json.dumps(payload) warnings.warn("Patch requests only support json") patch_request = self.client.patch(POSTS_URL + "/1", data=payload, HTTP_X_AUTHORIZATION=self.token, content_type='application/json') self.assertEqual(patch_request.status_code, 201) jres = json.loads(patch_request.content) self.assertEqual(jres['number_merged'], 2) def test_can_make_revisions_to_post_with_no_merging(self): payload = { "content": "This is my first sentence. This is the second sentence." } payload = json.dumps(payload) warnings.warn("Patch requests only support json") patch_request = self.client.patch(POSTS_URL + "/1", data=payload, HTTP_X_AUTHORIZATION=self.token, content_type='application/json') self.assertEqual(patch_request.status_code, 201) jres = json.loads(patch_request.content) self.assertEqual(jres['number_merged'], 0) self.assertEqual(jres['number_sentences'], 2)
def test_device_patch_by_id_invalid_payload(self): switch = self.createTestSwitch() client = Client() response = client.patch("/api/devices/1", "invalid patch document") self.assertEqual(response.status_code, 400)
class ProjectTestCases(TestCase): @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def setUp(self): self.client = Client() @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def test_create_project(self): u = ElementalUser(password='******', username='******', can_share_projects=True) u.save() self.client.login(username='******', password='******') data = { 'data': 'fake_testing_data_create', 'name': 'my_project' } response = self.client.post(reverse('api:project-create'), data) self.assertEqual(response.status_code, 201) try: project = Project.objects.get(data='fake_testing_data_create') except: project = None self.assertIsNotNone(project) @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def test_create_project_fail(self): u = ElementalUser(password='******', username='******') u.save() self.client.login(username='******', password='******') data = { 'data': 'fake_testing_data_create_fail', 'name': 'my_project' } response = self.client.post(reverse('api:project-create'), data) self.assertEqual(response.status_code, 403) try: project = Project.objects.get(data='fake_testing_data_create_fail') except: project = None self.assertIsNone(project) @override_settings(AUTH_USER_MODEL=settings.AUTH_USER_MODEL) def test_update_project(self): u = ElementalUser(password='******', username='******') u.save() self.client.login(username='******', password='******') project = Project(name='name', user=u, data='fake_data') project.save() data = { "data": "new_data" } data = json.dumps(data) response = self.client.patch(reverse('api:project-data', args=[project.id]), data, content_type='application/json') try: project = Project.objects.get(data='new_data') except: project = None self.assertIsNotNone(project)
def test_device_patch_by_id_toggle(self): switch = self.createTestSwitch() client = Client() response = client.patch("/api/devices/1", 'toggle') self.assertEqual(response.status_code, 200)
class VehicleEndpointTestCase(TestCase): def setUp(self): self.cars = [] for i in range(2): self.cars.append( factories.VehicleFactory(model__model_type=models.VehicleModel.TYPE_CAR)) self.motocycles = [] for i in range(2): self.motocycles.append( factories.VehicleFactory(model__model_type=models.VehicleModel.TYPE_MOTOCYCLE)) self.c = Client() self.list_url = reverse('api:vehicle-list') def test_get_must_return_list_of_all_vehicles(self): response = self.c.get(self.list_url) self.assertEqual(response.status_code, 200) def test_get_with_type_car_return_correct_list(self): url = '{}?type=car'.format(self.list_url) response = self.c.get(url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), len(self.cars)) ids = {i['id'] for i in response.data} expected_ids = {i.id for i in self.cars} self.assertEqual(ids, expected_ids) def test_get_with_type_motocycle_return_correct_list(self): url = '{}?type=motorcycle'.format(self.list_url) response = self.c.get(url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), len(self.motocycles)) ids = {i['id'] for i in response.data} expected_ids = {i.id for i in self.motocycles} self.assertEqual(ids, expected_ids) def test_get_with_automaker_return_correct_list(self): car = self.cars[0] url = '{}?auto_maker={}'.format(self.list_url, car.model.auto_maker_id) response = self.c.get(url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['id'], car.id) def test_get_with_model_return_correct_list(self): car = self.cars[0] url = '{}?model={}'.format(self.list_url, car.model_id) response = self.c.get(url) self.assertEqual(response.status_code, 200) self.assertEqual(len(response.data), 1) self.assertEqual(response.data[0]['id'], car.id) def test_get_with_color_return_correct_list(self): car = self.cars[0] url = '{}?color={}'.format(self.list_url, car.color) response = self.c.get(url) self.assertEqual(response.status_code, 200) expected = {i.id for i in models.Vehicle.objects.filter( color=car.color)} result_ids = {i['id'] for i in response.data} self.assertEqual(result_ids, expected) def test_get_with_year_range_return_correct_list(self): car = self.cars[0] start, end = car.model.year - 1, car.model.year + 1 expected = {i.id for i in models.Vehicle.objects.filter( model__year__gte=start, model__year__lte=end)} url = '{}?year_start={}&year_end={}'.format( self.list_url, start, end) response = self.c.get(url) ids_result = {i['id'] for i in response.data} self.assertEqual(ids_result, expected) def test_get_with_engine_range_return_correct_list(self): car = self.cars[0] start, end = car.engine - 100, car.engine + 100 expected = {i.id for i in models.Vehicle.objects.filter( engine__gte=start, engine__lte=end)} url = '{}?engine_start={}&engine_end={}'.format( self.list_url, start, end) response = self.c.get(url) ids_result = {i['id'] for i in response.data} self.assertEqual(ids_result, expected) def test_get_with_mileage_range_return_correct_list(self): car = self.cars[0] start, end = car.mileage - 500, car.mileage + 500 expected = {i.id for i in models.Vehicle.objects.filter( mileage__gte=start, mileage__lte=end)} url = '{}?mileage_start={}&mileage_end={}'.format( self.list_url, start, end) response = self.c.get(url) ids_result = {i['id'] for i in response.data} self.assertEqual(ids_result, expected) def test_call_post_must_create_an_item(self): model = factories.VehicleModelFactory() data = dict( model=model.id, color='red', mileage=144000, engine=1000 ) response = self.c.post(self.list_url, data=data) self.assertEqual(response.status_code, 201) models.Vehicle.objects.get(model=model, color='red', mileage=144000, engine=1000) def test_call_patch_must_update_an_item(self): vehicle = self.cars[0] new_mileage = vehicle.mileage + 1000 data = dict( mileage=new_mileage ) url = reverse('api:vehicle-detail', args=[vehicle.id]) response = self.c.patch(url, data=json.dumps(data), content_type='application/json') self.assertEqual(response.status_code, 200) vehicle.refresh_from_db() self.assertEqual(vehicle.mileage, new_mileage) def test_call_delete_must_delete_an_item(self): vehicle = self.cars[0] url = reverse('api:vehicle-detail', args=[vehicle.id]) response = self.c.delete(url) self.assertEqual(response.status_code, 204) self.assertIsNone(models.Vehicle.objects.filter(id=vehicle.id).first())