class TwoItemsSpatialTestCase(StacBaseTestCase): def setUp(self): self.client = Client() client_login(self.client) self.factory = Factory() self.collection = self.factory.create_collection_sample().model self.items = self.factory.create_item_samples( ['item-switzerland-west', 'item-switzerland-east'], self.collection, name=['item-switzerland-west', 'item-switzerland-east'], db_create=True, ) def test_two_item_endpoint(self): collection_name = self.collection.name item_west = self.items[0].model.name response_item_west = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}/items/{item_west}") item_east = self.items[1].model.name response_item_east = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}/items/{item_east}") response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") response_collection_json = response_collection.json() bbox_collection = response_collection.json( )['extent']['spatial']['bbox'][0] bbox_item_west = response_item_west.json()['bbox'] bbox_item_east = response_item_east.json()['bbox'] self.assertNotEqual( bbox_item_west, bbox_item_east, msg= 'the bbox should not be the same. one should cover the east, the other the west' ) self.assertNotEqual( bbox_item_west, bbox_collection, msg='the item bbox should be within the collection bbox') self.assertNotEqual( bbox_item_east, bbox_collection, msg='the item bbox should be within the collection bbox') polygon_west = Polygon.from_bbox(bbox_item_west) polygon_east = Polygon.from_bbox(bbox_item_east) union_polygon = Polygon.from_bbox( self._round_list(polygon_west.union(polygon_east).extent)) collection_polygon = Polygon.from_bbox( self._round_list(bbox_collection)) self.assertEqual( collection_polygon, union_polygon, msg= 'the union of item east and item west should be identical with the collection' ) def test_one_left_item(self): collection_name = self.collection.name item_west = self.items[0].model.name item_east = self.items[1].model.name # delete the eastern item path = f'/{STAC_BASE_V}/collections/{self.collection.name}/items/{item_east}' response = self.client.delete(path) self.assertStatusCode(200, response) response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") bbox_collection = response_collection.json( )['extent']['spatial']['bbox'][0] response_item_west = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}/items/{item_west}") bbox_item_west = response_item_west.json()['bbox'] self.assertEqual( self._round_list(bbox_collection), self._round_list(bbox_item_west), msg='the item and the collection bbox should be congruent') def test_update_covering_item(self): collection_name = self.collection.name item_name = self.items[0].model.name sample = self.factory.create_item_sample( self.collection, sample='item-covers-switzerland', name=item_name) path = f'/{STAC_BASE_V}/collections/{self.collection.name}/items/{item_name}' response = self.client.put(path, data=sample.get_json('put'), content_type="application/json") response_item = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}") bbox_item = response_item.json()['bbox'] response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") bbox_collection = response_collection.json( )['extent']['spatial']['bbox'][0] self.assertEqual( self._round_list(bbox_collection), self._round_list(bbox_item), msg='the item and the collection bbox should be congruent') def test_add_covering_item(self): collection_name = self.collection.name response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") bbox_collection_ch = response_collection.json( )['extent']['spatial']['bbox'][0] sample = self.factory.create_item_sample( self.collection, sample='item-covers-switzerland', db_create=True).model response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") bbox_collection_covers_ch = response_collection.json( )['extent']['spatial']['bbox'][0] self.assertNotEqual( self._round_list(bbox_collection_ch), self._round_list(bbox_collection_covers_ch), msg= 'the bbox that covers switzerland should be different from the bbox of ch' ) polygon_ch = Polygon.from_bbox(bbox_collection_ch) polygon_covers_ch = Polygon.from_bbox(bbox_collection_covers_ch) self.assertGreater( polygon_covers_ch.area, polygon_ch.area, msg= 'the area of the polygon covering CH has to be bigger than the bbox CH' ) def test_add_another_item(self): collection_name = self.collection.name response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") bbox_collection_ch = response_collection.json( )['extent']['spatial']['bbox'][0] sample = self.factory.create_item_sample(self.collection, sample='item-paris', db_create=True).model response_collection = self.client.get( f"/{STAC_BASE_V}/collections/{collection_name}") bbox_collection_paris = response_collection.json( )['extent']['spatial']['bbox'][0] self.assertNotEqual(self._round_list(bbox_collection_ch), self._round_list(bbox_collection_paris), msg='the bbox should have changed meanwhile') polygon_ch = Polygon.from_bbox(bbox_collection_ch) polygon_paris = Polygon.from_bbox(bbox_collection_paris) self.assertGreater( polygon_paris.area, polygon_ch.area, msg= 'the area of the bbox up to Paris has to be bigger than the bbox of Switzerland' ) def _round_list(self, unrounded_list): '''round a list of numbers Args: unrounded_list: list(float) Returns: list A list of rounded numbers ''' rounded_list = [round(i, 5) for i in unrounded_list] return rounded_list
class UserTestCase(TestCase): preclient = None def setUp(self): self.preclient = Client() self.preclient.post('/api/user/signup/', json.dumps( {'username': '******', "nickname": "SYLEE", 'password': '******', "wrong": False}),\ content_type='application/json') def tearDown(self): pass def test_signup(self): client = Client() response = client.post("/api/user/signup/", json.dumps({ 'username': "******", "nickname": "asdf" }), content_type="application/json") self.assertEqual(response.status_code, 400) response = client.post("/api/user/signup/", json.dumps({ 'username': "******", "nickname": "asdf", "password": "******", "wrong": True, }), content_type="application/json") self.assertEqual(response.status_code, 401) response = client.post("/api/user/signup/", json.dumps({ 'username': "******", "nickname": "asdf", "password": "******", "wrong": False, }), content_type="application/json") self.assertEqual(response.status_code, 201) response = client.post("/api/user/signup/", json.dumps({ 'username': "******", "nickname": "asdf", "password": "******", "wrong": False, }), content_type="application/json") self.assertEqual(response.status_code, 401) response = client.post("/api/user/signup/", json.dumps({ 'username': "******", "nickname": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "password": "******", "wrong": False, }), content_type="application/json") self.assertEqual(response.status_code, 401) response = client.post("/api/user/signup/", json.dumps({ 'username': "******", "nickname": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "password": "******", "wrong": False, }), content_type="application/json") self.assertEqual(response.status_code, 401) response = client.post("/api/user/signup/", json.dumps({ 'username': "", "nickname": "", "password": "******", "wrong": False, }), content_type="application/json") self.assertEqual(response.status_code, 401) response = client.get("/api/user/signup/") self.assertEqual(response.status_code, 405) def test_signin(self): response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******" }), content_type="application/json") self.assertEqual(response.status_code, 400) response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 401) response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) response = self.preclient.get("/api/user/signin/") self.assertEqual(response.status_code, 405) def test_signout(self): response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) response = self.preclient.post("/api/user/signout/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 405) response = self.preclient.get("/api/user/signout/") self.assertEqual(response.status_code, 204) response = self.preclient.get("/api/user/signout/") self.assertEqual(response.status_code, 401) def test_user_get(self): response = self.preclient.get("/api/user/") self.assertEqual(response.status_code, 204) response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) response = self.preclient.get("/api/user/") self.assertEqual(response.status_code, 200) def test_user_put(self): response = self.preclient.put("/api/user/", json.dumps({ 'nickname': "SY", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 401) # login response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) # wrong data response = self.preclient.put("/api/user/", json.dumps({ 'nickname': "sy", }), content_type="application/json") self.assertEqual(response.status_code, 400) # good data response = self.preclient.put("/api/user/", json.dumps({ 'nickname': "sy", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") response = self.preclient.put("/api/user/", json.dumps({ 'nickname': "sy", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 402) def test_user_invalid(self): response = self.preclient.post("/api/user/", json.dumps({ 'nickname': "sy", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 405) # def test_user_delete(self): def test_social(self): response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) response = self.preclient.put("/api/user/social/") self.assertEqual(response.status_code, 200) response = self.preclient.get("/api/user/social/") self.assertEqual(response.status_code, 405) def test_social_specific(self): User.objects.create_user(username="******", password="******", nickname="test") response = self.preclient.post("/api/user/signin/", json.dumps({ 'username': "******", "password": "******" }), content_type="application/json") self.assertEqual(response.status_code, 200) response = self.preclient.put("/api/user/social/1/") self.assertEqual(response.status_code, 405) response = self.preclient.get("/api/user/social/1000/") self.assertEqual(response.status_code, 401) response = self.preclient.get("/api/user/social/1/") self.assertEqual(response.status_code, 204) response = self.preclient.get("/api/user/social/2/") self.assertEqual(response.status_code, 401) # others in friend, group test def test_csrf(self): # By default, csrf checks are disabled in test client # To test csrf protection we enforce csrf checks here client = Client(enforce_csrf_checks=True) response = client.post('/api/user/signup/', json.dumps( {'username': '******', "nickname": "youngjae", 'password': '******', "wrong": False, }),\ content_type='application/json') # Request without csrf token returns 403 response self.assertEqual(response.status_code, 403) response = client.get('/api/user/token/') # Get csrf token from cookie csrftoken = response.cookies['csrftoken'].value response = client.post('/api/user/signup/', json.dumps( {'username': '******', "nickname": "youngjae", 'password': '******', "wrong": False, }),\ content_type='application/json', HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 201) # Pass csrf protection
class NoteViewAPITest(TestCase): """ Test module for notes view API's """ def setUp(self): self.client = Client() self.user1 = User.objects.create( username='******', email='*****@*****.**', password= '******' ) self.user2 = User.objects.create( username='******', email='*****@*****.**', password= '******' ) self.note_for_user1 = Notes.objects.create(title='title 1', note='note1', user=self.user1) self.note_for_user2 = Notes.objects.create(title='title 2', note='note2', user=self.user2) self.label_for_user1 = Label.objects.create(labelname='label1', user=self.user1) self.label_for_user2 = Label.objects.create(labelname='label2', user=self.user2) self.user1_credentials = {"username": "******", "password": "******"} self.valid_payload = {"title": "Birthday Message", "note": "Test note"} self.invalid_payload = {"title": "Message", "note": ""} self.invalid_credentials = { 'email': '*****@*****.**', 'password': '******' } self.valid_label_payload = {"label_name": "Greetings"} self.invalid_label_payload = {"label_name": ""} def test_get_all_notes_without_login(self): notes = Notes.objects.filter(user=self.user1) response = self.client.get(reverse('note-list')) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_all_notes_if_login_with_invalid_credentials(self): self.client.post(reverse('login'), data=json.dumps(self.invalid_credentials), content_type='json') response = self.client.get(reverse('create_note')) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_all_notes_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') notes = Notes.objects.filter(user=self.user1) response = self.client.get(reverse('create_note')) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_get_all_notes_of_with_is_archive_value_true_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') notes = Notes.objects.filter(user=self.user1) serializer = NotesSerializer(notes, many=True) response = self.client.get(reverse('create_note')) self.assertNotEqual(response.data, serializer.data) def test_create_notes_with_valid_payload_without_login(self): response = self.client.post(reverse('create_note'), data=json.dumps(self.valid_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_create_notes_with_valid_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.post(reverse('create_note'), data=json.dumps(self.valid_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) def test_create_notes_with_invalid_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.post(reverse('create_note'), data=json.dumps(self.invalid_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) ### Test cases for update, delete note def test_get_notes_by_id_without_login(self): response = self.client.get( reverse('note_update', kwargs={'id': self.note_for_user1.id})) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_notes_by_id_after_login_with_invalid_credentials(self): self.client.post(reverse('login'), data=json.dumps(self.invalid_credentials), content_type='json') response = self.client.get( reverse('note_update', kwargs={'id': self.note_for_user1.id})) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_notes_by_id_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') notes = Notes.objects.get(id=self.note_for_user1.id) serializer = NotesSerializer(notes) response = self.client.get( reverse('note_update', kwargs={'id': self.note_for_user1.id})) # self.assertEqual(response.data, serializer.data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_get_notes_by_id_of_other_user_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.get( reverse('note_update', kwargs={'id': self.note_for_user2.id})) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_update_notes_with_valid_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.put(reverse( 'note_update', kwargs={'id': self.note_for_user1.id}), data=json.dumps(self.valid_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) def test_update_notes_with_invalid_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.put(reverse( 'note_update', kwargs={'id': self.note_for_user1.id}), data=json.dumps(self.invalid_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_update_notes_with_id_of_other_user_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.put(reverse( 'note_update', kwargs={'id': self.note_for_user2.id}), data=json.dumps(self.invalid_payload), content_type='json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_delete_note_without_login(self): response = self.client.delete(reverse( 'note_update', kwargs={'id': self.note_for_user1.id}), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_delete_note_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.delete(reverse( 'note_update', kwargs={'id': self.note_for_user1.id}), content_type='json') self.assertEqual(response.status_code, status.HTTP_200_OK) def test_delete_note_with_id_of_other_user_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='application/json') response = self.client.delete(reverse( 'note_update', kwargs={'id': self.note_for_user2.id}), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) ### Test cases for list and create label def test_get_all_labels_if_login_with_invalid_credentials(self): self.client.post(reverse('login'), data=json.dumps(self.invalid_credentials), content_type='application/json') response = self.client.get(reverse('create_label')) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_all_labels_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='application/json') labels = Label.objects.filter(user=self.user1) serializer = LabelSerializer(labels, many=True) response = self.client.get(reverse('create_label')) self.assertEqual(response.data, serializer.data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_get_all_labels_without_login(self): labels = Label.objects.filter(user=self.user1) response = self.client.get(reverse('create_label')) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_all_labels_of_other_user_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='application/json') labels = Label.objects.filter(user=self.user2) serializer = LabelSerializer(labels, many=True) response = self.client.get(reverse('create_label')) self.assertNotEqual(response.data, serializer.data) def test_create_label_with_valid_payload_without_login(self): response = self.client.post(reverse('create_label'), data=json.dumps(self.valid_label_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_create_label_with_valid_label_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='application/json') response = self.client.post(reverse('create_label'), data=json.dumps(self.valid_label_payload), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) def test_create_label_with_invalid_label_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.post(reverse('create_label'), data=json.dumps( self.invalid_label_payload), content_type='json') self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) ### Test Cases for Retriew, Update and Delete def test_get_labels_by_id_without_login(self): response = self.client.get( reverse('label_update', kwargs={'id': self.label_for_user1.id})) self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_get_labels_by_id_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') labels = Label.objects.get(id=self.label_for_user1.id) serializer = LabelSerializer(labels) response = self.client.get( reverse('label_update', kwargs={'id': self.label_for_user1.id})) self.assertEqual(response.data, serializer.data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_update_label_with_valid_payload_without_login(self): response = self.client.put(reverse( 'label_update', kwargs={'id': self.label_for_user1.id}), data=json.dumps(self.valid_label_payload), content_type='json') self.assertEqual(response.status_code, status.HTTP_302_FOUND) def test_update_label_with_valid_payload_after_login(self): self.client.post(reverse('login'), data=json.dumps(self.user1_credentials), content_type='json') response = self.client.put(reverse( 'label_update', kwargs={'id': self.label_for_user1.id}), data=json.dumps(self.valid_label_payload), content_type='json') self.assertEqual(response.status_code, status.HTTP_200_OK) #TODO write test cases for 404
class EmployerTest(TestCase): """ use setUpTestData for the shared data and setUp for the per-test-method client """ @classmethod def setUpTestData(cls): cls.edit_url = reverse('/update_employer_profile/') cls.user = User.objects.create(username='******', email='*****@*****.**', password='******') cls.general_profile = Profile.objects.create(user=cls.user) cls.employer_profile = EmployerProfile.objects.create( general_profile=cls.general_profile) def SetUp(self): self.client = Client() def test_employer_profile_PUT_edit_profile(self): response = self.client.put( self.edit_url, { 'id': self.employer_profile.id, "contact_info_object": { "username": "******", "title": "Translater", "job_role_id": 21, "mobile_number": "01141155710" }, 'company_name': 'Smart', 'company_phone': '0114115510', 'company_website': '*****@*****.**', 'company_industry': 1, 'company_size': 1 }) self.assertEqual(response.status_code, 200) self.assertEqual(EmployerProfile.objects.first().company_name, 'Smart') def test_employer_profile_fails_blank(self): response = self.client.put(self.edit_url, {}) self.assertEqual(response.status_code, 500) def test_employer_profile_fails_invalid(self): response = self.client.put( self.edit_url, { 'profile_id': self.employer_profile.id, "contact_info_object": { "username": "******", "title": "Translater", "job_role_id": 21, "mobile_number": "01141155710" }, 'company_name': 'Smart', 'company_phone': '0114115510', 'company_website': '*****@*****.**', 'company_industry': 300, 'company_size': 1 }) self.assertRaises(ObjectDoesNotExist) self.assertEqual(response.status_code, 500) def test_employer_profile_fails_inavlid_profile(self): response = self.client.put( self.edit_url, { 'profile_id': 50, "contact_info_object": { "username": "******", "title": "Translater", "job_role_id": 21, "mobile_number": "01141155710" }, 'company_name': 'Smart', 'company_phone': '0114115510', 'company_website': '*****@*****.**', 'company_industry': 300, 'company_size': 1 }) self.assertRaises(ObjectDoesNotExist) self.assertEqual(response.status_code, 500)
class ListApiTest(TestCase): def setUp(self): self.client = Client() self.url = reverse('fancy_cats_list') FancyCat.objects.create(name='Alex', age=2) FancyCat.objects.create(name='Oscar', age=1) def test_get_method(self): # user = User.objects.create_superuser(username="******", password="******", # email="*****@*****.**") # self.client.force_login(user) response = self.client.get(self.url) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, [{ 'id': 1, 'name': 'Alex' }, { 'id': 2, 'name': 'Oscar' }]) def test_post_method(self): data = {'name': 'Mary'} user = User.objects.create_superuser(username="******", password="******", email="*****@*****.**") self.client.force_login(user) response = self.client.post(self.url, data=data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.data['id'], 3) self.assertEqual(response.data['name'], 'Mary') self.assertEqual(FancyCat.objects.count(), 3) def test_not_authenticated(self): data = {'name': 'Mary'} response = self.client.post(self.url, data={'name': 'Mary'}) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_bad_request(self): data = {} user = User.objects.create_superuser(username="******", password="******", email="*****@*****.**") self.client.force_login(user) response = self.client.post(self.url, data=data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_get_single_auth(self): user = User.objects.create_superuser('admin', None, 'adminadmin') self.client.force_login(user) self.url = reverse('fancy_cats_detail', kwargs={'pk': 2}) response = self.client.get(self.url) self.assertJSONEqual(response.content, {'id': 2, 'name': 'Oscar'}) # print(type(response.content)) # print(type(response.data)) def test_get_single_nonAuth(self): self.url = reverse('fancy_cats_detail', kwargs={'pk': 1}) response = self.client.get(self.url) # self.assertJSONEqual(response.content, {'id': 1, 'name': 'Alex'}) # **** fails if permission_classes are commented out self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_put_auth(self): user = User.objects.create_superuser('admin', None, 'adminadmin') self.client.force_login(user) self.url = reverse('fancy_cats_detail', kwargs={'pk': 1}) data = {'name': 'Patrunjel'} response = self.client.put(self.url, data=data, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data['name'], 'Patrunjel') self.assertEqual(response.data['id'], 1) def test_put_nonAuth(self): self.url = reverse('fancy_cats_detail', kwargs={'pk': 1}) data = {'name': 'Patrunjel'} response = self.client.put(self.url, data=data, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) def test_delete_auth(self): user = User.objects.create_superuser('admin', None, 'adminadmin') self.client.force_login(user) self.url = reverse('fancy_cats_detail', kwargs={'pk': 1}) response = self.client.delete(self.url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(FancyCat.objects.count(), 1) def test_delete_nonAuth(self): self.url = reverse('fancy_cats_detail', kwargs={'pk': 1}) response = self.client.delete(self.url) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
class InheritanceTest(TestCase): def setUp(self): super().setUp() u = User(username='******', is_active=True, is_superuser=True) u.set_password('test') u.save() self.client = Client() r = self.client.login(username='******', password='******') self.assertTrue(r) def test_add_lion_to_zoo(self): zoo = Zoo(name='Artis') zoo.save() response = self.client.put( '/zoo/', content_type='application/json', data=json.dumps({ 'data': [ { 'id': zoo.pk, 'animals': [-1, -2], }, ], 'with': { 'lion': [ { 'id': -1, 'name': 'Mufasa', 'mane_magnificence': 10, }, { 'id': -2, 'name': 'Scar', 'mane_magnificence': 4, }, ], }, }), ) self.assertEqual(response.status_code, 200) zoo.refresh_from_db() animals = list(zoo.animals.all()) self.assertEqual(len(animals), 2) mane_magnificence_map = { animal.name: animal.lion.mane_magnificence for animal in animals } self.assertEqual(mane_magnificence_map, { 'Mufasa': 10, 'Scar': 4, }) def test_create_lion_with_animal(self): response = self.client.put( '/animal/', content_type='application/json', data=json.dumps({ 'data': [{ 'id': -1, 'name': 'OVERRIDE THIS SHIET', 'lion': -2, }], 'with': {'lion': [{ 'id': -2, 'name': 'Mufasa', 'mane_magnificence': 10, }]}, }), ) self.assertEqual(response.status_code, 200) res_data = json.loads(response.content.decode()) lion_id = res_data['idmap']['lion'][0][1] self.assertEqual(res_data, { 'idmap': { 'animal': [[-1, lion_id]], 'lion': [[-2, lion_id]], }, }) def test_create_lion_with_animal_and_zoo(self): response = self.client.put( '/animal/', content_type='application/json', data=json.dumps({ 'data': [{ 'id': -1, 'name': 'OVERRIDE THIS SHIET', 'lion': -2, }], 'with': { 'lion': [{ 'id': -2, 'name': 'Mufasa', 'mane_magnificence': 10, }], 'zoo': [{ 'id': -3, 'name': 'Artis', 'animals': [-1], }], }, }), ) self.assertEqual(response.status_code, 200) res_data = json.loads(response.content.decode()) zoo_id = res_data['idmap']['zoo'][0][1] animal_id = res_data['idmap']['animal'][0][1] zoo = Zoo.objects.get(pk=zoo_id) zoo_animal_ids = [animal.id for animal in zoo.animals.all()] self.assertEqual(zoo_animal_ids, [animal_id])
class RestReadingTests(TestCase): """ Provides test cases for the Readings rest interface. """ # pylint: disable=invalid-name def setUp(self): """ Setup a test user for login. """ self.client = Client() self.user = User.objects.create_user('testuser', '*****@*****.**', 'q2w3E$R%') self.meter = Meter.objects.create(meter_name='testmeter', meter_unit='X') self.meter.save() reading = Reading.objects.create(meter=self.meter, reading=100, date=datetime.strptime( '2001-01-01', '%Y-%m-%d').date(), remark='test reading') reading.save() def test_need_login_to_see_readinglist(self): """ The rest-interface should *not* be accessible for everyone. """ response = self.client.get(reverse('api_v1:reading-list'), follow=True) self.assertEqual(response.status_code, 403) def test_login_can_see_readinglist(self): """ Readinglist is available to logged in members. """ self.client.login(username='******', password='******') response = self.client.get(reverse('api_v1:reading-list'), follow=True) self.assertEqual(response.status_code, 200) self.assertContains(response, 'test reading') self.assertContains(response, '2001') self.assertContains(response, '100') self.assertContains(response, 'meter_url') self.assertContains(response, 'http://testserver/api/v1/meter/1') def test_login_cannot_add_new_reading(self): """ Not everyone can add a meter. Trying to post data as XML """ self.client.login(username='******', password='******') data = XML_HEADER + '<root>' + \ ' <date>2018-01-10</date>' + \ ' <reading>-200.00</reading>' + \ ' <meter>1</meter>' + \ ' <remark>testnew</remark>' + \ '</root>' response = self.client.post(reverse('api_v1:reading-list'), data=data, content_type='application/xml', follow=True) self.assertEqual(response.status_code, 403) self.assertNotIn('testnew', str(response.content)) def test_special_login_can_add_reading(self): """ Adding a meter require login. Trying to post data as XML. """ p = Permission.objects.get(name='Can add reading') self.user.user_permissions.add(p) self.client.login(username='******', password='******') data = XML_HEADER + '<root>' + \ ' <date>2018-01-10</date>' + \ ' <reading>-200.00</reading>' + \ ' <meter>1</meter>' + \ ' <remark>testnew</remark>' + \ '</root>' response = self.client.post(reverse('api_v1:reading-list'), data=data, content_type='application/xml', follow=True) self.assertEqual(response.status_code, 201) self.assertIn('testnew', str(response.content)) def test_need_login_to_see_reading_details(self): """ Login is required to see the reading details """ response = self.client.get(reverse('api_v1:reading-detail', args=[1]), follow=True) self.assertEqual(response.status_code, 403) def test_login_can_see_reading_details(self): """ With login reading details are available. """ self.client.login(username='******', password='******') response = self.client.get(reverse('api_v1:reading-detail', args=[1]), follow=True) self.assertEqual(response.status_code, 200) self.assertContains(response, 'test reading') self.assertContains(response, '2001') self.assertContains(response, '100') def test_need_login_to_change_reading_details(self): """ Not anyone can change reading details. """ data = {'reading': 500} response = self.client.put(reverse('api_v1:reading-detail', args=[1]), content_type='application/json', follow=True, data=json.dumps(data)) self.assertEqual(response.status_code, 403) def test_not_every_loging_can_change_reading_details(self): """ Special permission is required. """ self.client.login(username='******', password='******') data = {'reading': 500} response = self.client.put(reverse('api_v1:reading-detail', args=[1]), content_type='application/json', follow=True, data=json.dumps(data)) self.assertEqual(response.status_code, 403) def test_login_can_change_reading(self): """ Login with permission can change reading. """ p = Permission.objects.get(name='Can change reading') self.user.user_permissions.add(p) self.user.save() self.client.login(username='******', password='******') data = {'reading': 500} response = self.client.patch(reverse('api_v1:reading-detail', args=[1]), content_type='application/json', follow=True, data=json.dumps(data)) self.assertEqual(response.status_code, 200) self.assertContains(response, 500) self.assertContains(response, 2001) def test_adding_reading_calculates_usage(self): """ Adding a reading should calculate the usage """ p = Permission.objects.get(name='Can add reading') self.user.user_permissions.add(p) self.client.login(username='******', password='******') data = XML_HEADER + '<root>' + \ ' <date>2001-02-01</date>' + \ ' <reading>200.00</reading>' + \ ' <meter>1</meter>' + \ ' <remark>testnew</remark>' + \ '</root>' response = self.client.post(reverse('api_v1:reading-list'), data=data, content_type='application/xml', follow=True) self.assertEqual(response.status_code, 201) usage = Usage.objects.get(pk=1) self.assertEqual(usage.usage, 100) def test_cannot_add_two_readings_on_same_data(self): """ Only one reading per day per meter is allowd. """ p = Permission.objects.get(name='Can add reading') self.user.user_permissions.add(p) self.client.login(username='******', password='******') data = XML_HEADER + '<root>' + \ ' <date>2001-01-01</date>' + \ ' <reading>-200.00</reading>' + \ ' <meter>1</meter>' + \ ' <remark>testnew</remark>' + \ '</root>' response = self.client.post(reverse('api_v1:reading-list'), data=data, content_type='application/xml', follow=True) self.assertEqual(response.status_code, 400)
class TestCaseBase(TestCase): setup = False invalid_accesstoken = 'aaaaa' # Jack jack_accesstoken = 'abcde' jack = None jack_fbuser = None jack_fb_info = { "id": "12345", "first_name": "Jack", "gender": "male", "last_name": "The Tester", "link": "https://www.facebook.com/app_scoped_user_id/12345/", "locale": "en_GB", "middle_name": "", "name": "Jack The Tester", "timezone": 0, "updated_time": "2016-11-12T09:18:12+0000", "verified": True } # Marie marie_accesstoken = 'ghijk' marie = None marie_fbuser = None marie_fb_info = { "id": "67890", "first_name": "Marie", "gender": "female", "last_name": "The Tester", "link": "https://www.facebook.com/app_scoped_user_id/67890/", "locale": "en_GB", "middle_name": "", "name": "Marie The Tester", "timezone": 0, "updated_time": "2016-11-12T09:18:12+0000", "verified": True } @staticmethod def create_test_users(): print( 'Creating Jack test user. Jack is a normal user with no permission.' ) # Jack User object. TestCaseBase.jack = User() TestCaseBase.jack.username = '******' TestCaseBase.jack.email = '*****@*****.**' TestCaseBase.jack.set_password('password') TestCaseBase.jack.first_name = 'Jack' TestCaseBase.jack.last_name = 'The Tester' TestCaseBase.jack.is_staff = False TestCaseBase.jack.is_superuser = False TestCaseBase.jack.save() # Jack FbUser object. TestCaseBase.jack_fbuser = FbUser(fb_id=12345, user=TestCaseBase.jack) TestCaseBase.jack_fbuser.save() print( 'Creating Marie test user. Marie is a superuser with full permission.' ) # Marie User object. TestCaseBase.marie = User() TestCaseBase.marie.username = '******' TestCaseBase.marie.email = '*****@*****.**' TestCaseBase.marie.set_password('password') TestCaseBase.marie.first_name = 'Marie' TestCaseBase.marie.last_name = 'The Tester' TestCaseBase.marie.is_staff = True TestCaseBase.marie.is_superuser = True TestCaseBase.marie.save() # Marie FbUser object. TestCaseBase.marie_fbuser = FbUser(fb_id=67890, user=TestCaseBase.marie) TestCaseBase.marie_fbuser.save() @staticmethod def mock_fbapi(): def fb_get_mock(path, access_token): if path == 'me' and access_token == TestCaseBase.jack_accesstoken: return TestCaseBase.jack_fb_info if path == 'me' and access_token == TestCaseBase.marie_accesstoken: return TestCaseBase.marie_fb_info if path == 'me' and access_token == TestCaseBase.invalid_accesstoken: raise FacebookError() raise MethodNotConfigured() fbapi.fb_get = fb_get_mock # noinspection PyPep8Naming @classmethod def setUpClass(cls): if TestCaseBase.setup: return TestCaseBase.setup = True TestCaseBase.create_test_users() TestCaseBase.mock_fbapi() pass # noinspection PyPep8Naming @classmethod def tearDownClass(cls): pass def setUp(self): self.client = Client() def get(self, path): return self.client.get(path) def post(self, path, data): return self.client.post(path, json.dumps(data), content_type='application/json') def put(self, path, data): return self.client.put(path, json.dumps(data), content_type='application/json') def patch(self, path, data): return self.client.patch(path, json.dumps(data), content_type='application/json')
class TestMilestonePut(APITestCase): def setUp(self): self.user = User.objects.create_user(username="******", password="******", email='*****@*****.**') token = RefreshToken.for_user(self.user) self.client = Client(HTTP_AUTHORIZATION=f'Bearer {token.access_token}') self.repository = Repository.objects.create( url='https://github.com/lazarmarkovic/uks2020', name='uks2020', is_private=False, user=self.user) self.milestone = Milestone.objects.create( name="Milestone", description="Milestone Description", start_date=datetime.now().date(), end_date=datetime(2020, 12, 25), repository=self.repository) self.milestone1 = Milestone.objects.create( name="Milestone1", description="Milestone Description", start_date=datetime.now().date(), end_date=datetime(2020, 12, 25), repository=self.repository) def test_edit_milestone_success(self): milestone = { 'name': 'Updated milestone', 'description': 'Milestone Description', 'start_date': '2021-12-05', 'end_date': '2021-12-25', 'state': 'CL' } response = self.client.put(reverse( 'edit_milestone', kwargs={'milestone_id': self.milestone.id}), data=json.dumps(milestone), content_type='application/json') serializer = MilestoneSerializer( Milestone.objects.get(pk=self.milestone.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual('Updated milestone', serializer.data['name']) def test_put_request_with_no_data(self): response = self.client.put(reverse( 'edit_milestone', kwargs={'milestone_id': self.milestone.id}), data={}, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_edit_milestone_with_bad_credentials(self): milestone = { 'name': 'Updated milestone', 'description': 'Milestone Description', 'start_date': '2021-12-05', 'end_date': '2021-12-25', 'state': 'CL' } self.client = Client(HTTP_AUTHORIZATION='Bearer acsfhjsdkjf') response = self.client.put(reverse( 'edit_milestone', kwargs={'milestone_id': self.milestone.id}), data=json.dumps(milestone), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_edit_milestone_not_found(self): milestone = { 'name': 'Updated milestone', 'description': 'Milestone Description', 'start_date': '2021-12-05', 'end_date': '2021-12-25', 'state': 'CL' } response = self.client.put(reverse('edit_milestone', kwargs={'milestone_id': 123456789}), data=json.dumps(milestone), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_edit_milestone_duplicate_name(self): milestone = { 'name': self.milestone1.name, 'description': 'Milestone Description', 'start_date': '2021-12-05', 'end_date': '2021-12-25', 'state': 'CL' } response = self.client.put(reverse( 'edit_milestone', kwargs={'milestone_id': self.milestone.id}), data=json.dumps(milestone), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_edit_milestone_start_date_before_end_date(self): milestone = { 'name': 'Updated milestone', 'description': 'Milestone Description', 'end_date': '2019-12-25', 'state': 'CL' } response = self.client.put(reverse( 'edit_milestone', kwargs={'milestone_id': self.milestone.id}), data=json.dumps(milestone), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
class AdviserProjectsToPlayersTests(TestCase): def setUp(self): User.objects.create(username="******", is_superuser=True, email="*****@*****.**", id=1) User.objects.create(username="******", is_superuser=False, email="*****@*****.**", id=2) User.objects.create(username="******", is_superuser=False, email="*****@*****.**", id=3) user = User.objects.get(id=1) user.set_password("password") user.save() user = User.objects.get(id=2) user.set_password("password") user.save() user = User.objects.get(id=3) user.set_password("password") user.save() Company.objects.create( id=1, zipcode="79008", logo="http://test.test", name="testcompany", mail="*****@*****.**", address="testaddress", phone="+380901234567", ) Company.objects.create( id=2, zipcode="794508", logo="http://test2.test", name="testcompany2", mail="*****@*****.**", address="testaddress2", phone="+380901234677", ) AdviserUser.objects.create(user=User.objects.get(id=2), id_company=Company.objects.get(id=1), id=1) AdviserUser.objects.create(user=User.objects.get(id=3), id_company=Company.objects.get(id=2), id=2) AdviserProject.objects.create(name="TestProject", description="Test description", id_company=Company.objects.get(id=1), id=1) AdviserProject.objects.create(name="TestProject 2", description="Test description", id_company=Company.objects.get(id=2), id=2) Player.objects.create(id=1, name="testPlayer 1", description="first player test description", mac_address="aa:dd:ff:11:22:33", status=True, project=AdviserProject.objects.get(id=1)) Player.objects.create(id=2, name="testPlayer 2", description="second player test description", mac_address="66:55:44:ad:fb:cc", status=False, project=AdviserProject.objects.get(id=1)) Player.objects.create(id=3, name="testPlayer 3", description="third player test description", mac_address="df:df:aa:aa:aa:cc", status=True, project=AdviserProject.objects.get(id=2)) Player.objects.create( id=4, name="testPlayer 4", description="third player test description", mac_address="fd:fd:cc:aa:32:cc", status=True, ) self.client = Client() self.client.login(username="******", password="******") def test_get(self): url = reverse('get_players_for_project', args=[1]) response = self.client.get(url) players = json.loads(response._container[0]) self.assertEqual(response.status_code, 200) self.assertEqual(players[0].get("id"), 2) self.assertEqual(players[1].get("id"), 1) def test_get_try_foreign_project(self): url = reverse('get_players_for_project', args=[2]) response = self.client.get(url) self.assertEqual(response.status_code, 400) massage = response._container[0] self.assertEqual(massage, 'Permission denied') def test_put(self): url = reverse('put_projects_to_players') data = json.dumps({ 'project': { 'id': 2, 'name': 'TestProject 2', 'description': 'Test description', 'id_company': 2 }, 'players': [{ 'id': 1, 'name': 'testPlayer 1', 'description': 'first player test description', 'mac_address': 'aa:dd:ff:11:22:33', 'status': True, }, { 'id': 4, 'name': 'testPlayer 4', 'description': 'player test description', 'mac_address': 'fd:fd:cc:aa:32:cc', 'status': True, }], }) self.client = Client() self.client.login(username="******", password="******") response = self.client.put(url, data=data, content_type='application/json') self.assertEqual(response.status_code, 201) first_player = Player.objects.get(id=1) self.assertEqual(first_player.project.id, 2) second_player = Player.objects.get(id=4) self.assertEqual(second_player.project.id, 2) def test_put_try_foreign_project(self): data = json.dumps({ 'project': { 'id': 2, 'name': 'TestProject 2', 'description': 'Test description', 'id_company': 2 }, 'players': [{ 'id': 1, 'name': 'testPlayer 1', 'description': 'first player test description', 'mac_address': 'aa:dd:ff:11:22:33', 'status': True, }, { 'id': 4, 'name': 'testPlayer 4', 'description': 'player test description', 'mac_address': 'fd:fd:cc:aa:32:cc', 'status': True, }], }) url = reverse('put_projects_to_players') response = self.client.put(url, data=data, content_type='application/json') self.assertEqual(response.status_code, 400) massage = response._container[0] self.assertEqual(massage, 'Permission denied') def test_put_try_without_players(self): invalid_data = json.dumps({ 'project': { 'id': 1, 'name': 'TestProject 1', 'description': 'Test description', 'id_company': 1 } }) url = reverse('put_projects_to_players') response = self.client.put(url, data=invalid_data, content_type='application/json') self.assertEqual(response.status_code, 400) massage = response._container[0] self.assertEqual(massage, 'Players are not added. Please, add some players.') def test_post_project_with_players(self): AdviserProject.objects.all().delete() url = reverse('projects-list') data = json.dumps({ 'id': 1, 'name': 'TestProject 1', 'description': 'Test description', 'players': [ 2, 3, ], }) response = self.client.post(url, data=data, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(AdviserProject.objects.count(), 1) first_player = Player.objects.get(id=2) self.assertEqual(first_player.project.name, 'TestProject 1') second_player = Player.objects.get(id=3) self.assertEqual(second_player.project.name, 'TestProject 1')
class HeroTestCase(TestCase): def setUp(self): Hero.objects.create(name='Karkat') Hero.objects.create(name='Terezi') Hero.objects.create(name='Vriska') self.client = Client() def test_hero_str(self): terezi = Hero.objects.get(name='Terezi') self.assertEqual(str(terezi), 'Terezi') def test_hero_list_get(self): response = self.client.get('/api/hero/') data = json.loads(response.content.decode()) self.assertEqual(len(data), 3) def test_hero_list_post(self): aradia = json.dumps({'name': 'Aradia'}) response = self.client.post('/api/hero/', aradia, content_type='application/json') self.assertEqual(response.status_code, 201) # Created response = self.client.get('/api/hero/') data = json.loads(response.content.decode()) self.assertEqual(len(data), 4) response = self.client.get('/api/hero/4') data = json.loads(response.content.decode()) self.assertEqual(data['name'], 'Aradia') def test_hero_list_not_allowed(self): response = self.client.put('/api/hero/') self.assertEqual(response.status_code, 405) # Not allowed def test_hero_detail_get(self): # Test heroDetail with GET request response = self.client.get('/api/hero/1') data = json.loads( response.content.decode()) # Deserialize response data self.assertEqual(data['name'], 'Karkat') # Verify the data self.assertEqual(response.status_code, 200) # Check the response code response = self.client.get('/api/hero/62') self.assertEqual(response.status_code, 404) # Not found def test_hero_detail_put(self): sollux = json.dumps({'name': 'Sollux'}) response = self.client.put('/api/hero/3', sollux, content_type='application/json') self.assertEqual(response.status_code, 204) # No content response = self.client.get('/api/hero/3') data = json.loads(response.content.decode()) self.assertEqual(data['name'], 'Sollux') response = self.client.put('/api/hero/62', sollux, content_type='application/json') self.assertEqual(response.status_code, 404) # Not found def test_hero_detail_delete(self): response = self.client.delete('/api/hero/3') self.assertEqual(response.status_code, 204) # No content response = self.client.get('/api/hero/3') self.assertEqual(response.status_code, 404) # Not found response = self.client.delete('/api/hero/62') self.assertEqual(response.status_code, 404) # Not found def test_hero_detail_not_allowed(self): response = self.client.post('/api/hero/1') self.assertEqual(response.status_code, 405) # Not allowed
class DatasetListJSONTestCase(TestCase): def setUp(self): self.client = Client() user = User.objects.create_user(BASIC_USER, password=BASIC_PASSWORD) user.save() dataset = Dataset(title='Dataset title', description='Dataset description') dataset.save() self.json_headers = { 'HTTP_ACCEPT': 'application/json', 'HTTP_AUTHORIZATION': 'BASIC {}'.format( base64.b64encode('{}:{}'.format( BASIC_USER, BASIC_PASSWORD).encode()).decode()) } def test_get_datasets_json(self): headers = {'HTTP_ACCEPT': 'application/json'} response = self.client.get('/dataset/', **headers) self.assertEqual(200, response.status_code) response_json = json.loads(response.content) self.assertEqual(1, len(response_json)) self.assertEqual('Dataset title', response_json[0]['title']) self.assertEqual('Dataset description', response_json[0]['description']) self.assertEqual('dataset-title', response_json[0]['name']) def test_post_dataset_json(self): self.assertEqual(1, Dataset.objects.count()) body = { 'title': 'Another dataset', 'name': 'another-dataset', 'description': 'Another dataset description' } response = self.client.post('/dataset/', json.dumps(body), content_type='application/json', **self.json_headers) self.assertEqual(201, response.status_code) self.assertEqual(2, Dataset.objects.count()) def test_post_dataset_json_error(self): self.assertEqual(1, Dataset.objects.count()) body = { 'title': 'Another dataset', 'description': 'Another dataset description' } response = self.client.post('/dataset/', json.dumps(body), content_type='application/json', **self.json_headers) self.assertEqual(400, response.status_code) self.assertEqual(1, Dataset.objects.count()) def test_get_dataset_json(self): headers = {'HTTP_ACCEPT': 'application/json'} response = self.client.get('/dataset/1/', **headers) self.assertEqual(200, response.status_code) response_json = json.loads(response.content) self.assertEqual('Dataset title', response_json['title']) self.assertEqual('Dataset description', response_json['description']) self.assertEqual('dataset-title', response_json['name']) def test_put_dataset_json(self): self.assertEqual(1, Dataset.objects.count()) body = { 'title': 'Another modified dataset', 'name': 'another-modified-dataset', 'description': 'Another modified dataset description' } response = self.client.put('/dataset/1/', json.dumps(body), content_type='application/json', **self.json_headers) self.assertEqual(200, response.status_code) self.assertEqual(1, Dataset.objects.count()) dataset = Dataset.objects.first() self.assertEqual('Another modified dataset', dataset.title) self.assertEqual('another-modified-dataset', dataset.name) self.assertEqual('Another modified dataset description', dataset.description) def test_put_dataset_json_error(self): self.assertEqual(1, Dataset.objects.count()) body = { 'title': 'Another modified dataset', 'description': 'Another modified dataset description' } response = self.client.put('/dataset/1/', json.dumps(body), content_type='application/json', **self.json_headers) self.assertEqual(400, response.status_code) self.assertEqual(1, Dataset.objects.count()) def test_delete_dataset_json(self): self.assertEqual(1, Dataset.objects.count()) response = self.client.delete('/dataset/1/', content_type='application/json', **self.json_headers) self.assertEqual(204, response.status_code) self.assertEqual(0, Dataset.objects.count())
class TestNotifyUsersAboutChallenge(TestCase): def setUp(self): self.client = Client() self.superuser = User.objects.create_superuser( "superuser", "*****@*****.**", "secret_password" ) self.user = User.objects.create( username="******", email="*****@*****.**", password="******", ) self.url = reverse_lazy("web:notify_users_about_challenge") self.email_data = { "subject": "Subject of the Email", "body": "Body of the Email", } def test_if_user_isnt_authenticated(self): response = self.client.get(self.url) html = response.content.decode("utf8") self.assertTrue(html.startswith("<!DOCTYPE html>")) self.assertTrue(html.endswith("")) self.assertEqual(response.status_code, 200) def test_if_user_is_authenticated_but_not_superuser(self): self.data = { "username": self.user.username, "password": self.user.password, } response = self.client.post(self.url, self.data) html = response.content.decode("utf8") self.assertTrue(html.startswith("<!DOCTYPE html>")) self.assertTrue(html.endswith("")) self.assertEqual(response.status_code, 200) def test_if_user_is_authenticated_and_superuser(self): request = self.client.get("/admin/", follow=True) response = self.client.login( username="******", password="******" ) self.assertEqual(request.status_code, 200) self.assertTrue(response) def test_notification_email_data_page(self): request = self.client.get("/admin/", follow=True) response = self.client.login( username="******", password="******", follow=True ) request = self.client.get(self.url) html = request.content.decode("utf8") self.assertTrue(html.startswith("")) self.assertTrue(html.endswith("")) self.assertEqual(request.status_code, 200) self.assertTrue(response) def test_notification_email_without_challenge_image(self): request = self.client.get("/admin/", follow=True) response = self.client.login( username="******", password="******", follow=True ) request = self.client.post(self.url, self.email_data) html = request.content.decode("utf8") self.assertTrue(html.startswith("")) self.assertTrue(html.endswith("")) self.assertEqual(request.status_code, 200) self.assertTrue(response) def test_notification_email_with_challenge_image(self): request = self.client.get("/admin/", follow=True) response = self.client.login( username="******", password="******", follow=True ) self.email_data["challenge_image"] = SimpleUploadedFile( name="test_background_image.jpg", content=open("frontend/src/images/rocket.png", "rb").read(), content_type="image/jpg", ) request = self.client.post(self.url, self.email_data) html = request.content.decode("utf8") self.assertTrue(html.startswith("")) self.assertTrue(html.endswith("")) self.assertTrue(response) self.assertEqual(request.status_code, 200) def test_notification_with_put_request(self): request = self.client.get("/admin/", follow=True) response = self.client.login( username="******", password="******", follow=True ) request = self.client.put(self.url, self.email_data) html = request.content.decode("utf8") self.assertTrue(html.startswith("<!DOCTYPE html>")) self.assertTrue(html.endswith("")) self.assertTrue(response) self.assertEqual(request.status_code, 200)
class RecommendTestCase(TestCase): def setUp(self): self.client = Client(enforce_csrf_checks=True) self.user_set = [] self.user_set.append(User.objects.create_superuser( email='*****@*****.**', password='******', username='******')) self.user_set.append(User.objects.create_superuser( email='*****@*****.**', password='******', username='******')) self.user_set.append(User.objects.create_user( email='*****@*****.**', password='******', username='******')) self.user_set.append(User.objects.create_superuser( email='*****@*****.**', password='******', username='******')) self.user_set.append(User.objects.create_user( email='*****@*****.**', password='******', username='******')) for i in range(10): Course.objects.create( title="swpp", credit=i + 1, ) def get(self, *args, **kwargs): return self.client.get(*args, **kwargs) def post(self, *args, **kwargs): response = self.client.get('/api/token/') csrftoken = response.cookies['csrftoken'].value return self.client.post(*args, **kwargs, HTTP_X_CSRFTOKEN=csrftoken) def delete(self, *args, **kwargs): response = self.client.get('/api/token/') csrftoken = response.cookies['csrftoken'].value return self.client.delete(*args, **kwargs, HTTP_X_CSRFTOKEN=csrftoken) def put(self, *args, **kwargs): response = self.client.get('/api/token/') csrftoken = response.cookies['csrftoken'].value return self.client.put(*args, **kwargs, HTTP_X_CSRFTOKEN=csrftoken) def test_get_coursepref(self): response = self.get('/api/recommend/coursepref/1/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.post('/api/recommend/coursepref/1/') self.assertEqual(response.status_code, 405) CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=1), score=5).save() response = self.get('/api/recommend/coursepref/1/') self.assertEqual(response.status_code, 200) self.assertEqual(5, json.loads(response.content.decode())['score']) response = self.get('/api/recommend/coursepref/2/') self.assertEqual(response.status_code, 404) def test_put_coursepref_id(self): response = self.put('/api/recommend/coursepref/1/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.put('/api/recommend/coursepref/1/', json.dumps({}), content_type='application/json') self.assertEqual(response.status_code, 400) response = self.put('/api/recommend/coursepref/1/', json.dumps({'score':-1}), content_type='application/json') self.assertEqual(response.status_code, 400) response = self.put('/api/recommend/coursepref/20/', json.dumps({'score':5}), content_type='application/json') self.assertEqual(response.status_code, 404) response = self.put('/api/recommend/coursepref/1/', json.dumps({'score':5}), content_type='application/json') self.assertEqual(response.status_code, 201) response = self.put('/api/recommend/coursepref/1/', json.dumps({'score':1}), content_type='application/json') self.assertEqual(response.status_code, 200) response = self.get('/api/recommend/coursepref/1/') expected = {'id':1, 'user':1, 'course':1, 'score':1} self.assertEqual(expected, json.loads(response.content.decode())) def test_delete_coursepref(self): response = self.delete('/api/recommend/coursepref/1/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.delete('/api/recommend/coursepref/1/', json.dumps({}), content_type='application/json') self.assertEqual(response.status_code, 404) response = self.put('/api/recommend/coursepref/1/', json.dumps({'score':5}), content_type='application/json') response = self.delete('/api/recommend/coursepref/99/', content_type='application/json') self.assertEqual(response.status_code, 404) response = self.delete('/api/recommend/coursepref/1/', content_type='application/json') self.assertEqual(response.status_code, 200) response = self.get('/api/recommend/coursepref/1/') self.assertEqual(response.status_code, 404) def test_get_timepref(self): response = self.get('/api/recommend/timepref/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.post('/api/recommend/timepref/') self.assertEqual(response.status_code, 405) TimePref(user=User.objects.get(id=1), weekday=0, start_time="12:00", score=0).save() TimePref(user=User.objects.get(id=1), weekday=0, start_time="12:30", score=1).save() TimePref(user=User.objects.get(id=2), weekday=0, start_time="12:00", score=2).save() response = self.get('/api/recommend/timepref/') self.assertEqual(response.status_code, 200) self.assertEqual(26, len(json.loads(response.content.decode()))) self.assertEqual(1, json.loads(response.content.decode())[9][0]) def test_put_timepref(self): response = self.put('/api/recommend/timepref/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.put('/api/recommend/timepref/', json.dumps({'score': 3, 'weekday': 0, 'start_time':"12:00"}), content_type='application/json') self.assertEqual(response.status_code, 400) response = self.put('/api/recommend/timepref/', json.dumps({'weekday':0, 'start_time':"12:00"}), content_type='application/json') self.assertEqual(response.status_code, 400) table = [] table_row = [1, 1, 1, 1, 1, 1] for _ in range(26): table.append(table_row) response = self.put('/api/recommend/timepref/', json.dumps({'table':table}), content_type='application/json') self.assertEqual(response.status_code, 200) response = self.get('/api/recommend/timepref/') self.assertEqual(response.status_code, 200) self.assertEqual(26, len(json.loads(response.content.decode()))) self.assertEqual(1, json.loads(response.content.decode())[8][0]) table = [] table_row = [2, 2, 2, 2, 2, 2] for _ in range(26): table.append(table_row) response = self.put('/api/recommend/timepref/', json.dumps({'table':table}), content_type='application/json') self.assertEqual(response.status_code, 200) response = self.get('/api/recommend/timepref/') self.assertEqual(response.status_code, 200) self.assertEqual(26, len(json.loads(response.content.decode()))) self.assertEqual(2, json.loads(response.content.decode())[8][0]) def test_get_coursepref_rated(self): response = self.get('/api/recommend/coursepref/rated/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.post('/api/recommend/coursepref/rated/') self.assertEqual(response.status_code, 405) response = self.put('/api/recommend/coursepref/rated/') self.assertEqual(response.status_code, 405) response = self.delete('/api/recommend/coursepref/rated/') self.assertEqual(response.status_code, 405) CoursePref(user=User.objects.get(id=2), course=Course.objects.get(id=1), score=7).save() CoursePref(user=User.objects.get(id=2), course=Course.objects.get(id=2), score=1).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=1), score=5).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=3), score=5).save() response = self.get('/api/recommend/coursepref/rated/?'+ 'start=0&end=49&title=swpp&classification='+ '&department=°ree_program=&academic_year='+ '&course_number=&lecture_number=&professor='+ '&language=&min_credit=&max_credit=&min_score='+ '&max_score=&sort=1') self.assertEqual(response.status_code, 200) self.assertEqual(2, len(json.loads(response.content.decode()))) response = self.get('/api/recommend/coursepref/rated/?start=0&end=0'+ '&title=swpp&classification=&department='+ '°ree_program=&academic_year=&course_number='+ '&lecture_number=&professor=&language=&min_credit='+ '&max_credit=&min_score=&max_score=&sort=1') self.assertEqual(response.status_code, 200) self.assertEqual(1, len(json.loads(response.content.decode()))) def test_get_coursepref_unrated(self): response = self.get('/api/recommend/coursepref/unrated/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.post('/api/recommend/coursepref/unrated/') self.assertEqual(response.status_code, 405) response = self.put('/api/recommend/coursepref/unrated/') self.assertEqual(response.status_code, 405) response = self.delete('/api/recommend/coursepref/unrated/') self.assertEqual(response.status_code, 405) CoursePref(user=User.objects.get(id=2), course=Course.objects.get(id=1), score=7).save() CoursePref(user=User.objects.get(id=2), course=Course.objects.get(id=2), score=5).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=1), score=5).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=3), score=5).save() response = self.get('/api/recommend/coursepref/unrated/?start=0'+ '&end=49&title=swpp&classification=&department='+ '°ree_program=&academic_year=&course_number='+ '&lecture_number=&professor=&language=&min_credit='+ '&max_credit=&min_score=&max_score=&sort=0') self.assertEqual(response.status_code, 200) self.assertEqual(8, len(json.loads(response.content.decode()))) response = self.get('/api/recommend/coursepref/unrated/?start=0'+ '&end=0&title=swpp&classification=&department='+ '°ree_program=&academic_year=&course_number='+ '&lecture_number=&professor=&language=&min_credit='+ '&max_credit=&min_score=&max_score=&sort=0') self.assertEqual(response.status_code, 200) self.assertEqual(1, len(json.loads(response.content.decode()))) def test_put_constraints(self): response = self.put('/api/recommend/constraints/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.post('/api/recommend/constraints/') self.assertEqual(response.status_code, 405) response = self.delete('/api/recommend/constraints/') self.assertEqual(response.status_code, 405) response = self.put('/api/recommend/constraints/', json.dumps({'days_per_week':4, 'credit_min':1, 'credit_max':12, 'major_min':1, 'major_max':13, }), content_type='application/json') self.assertEqual(response.status_code, 200) response = self.put('/api/recommend/constraints/', json.dumps({'days_per_week':4, 'credit_min':3, 'credit_max':5, 'major_min':1, 'major_max':2, }), content_type='application/json') self.assertEqual(response.status_code, 200) response = self.put('/api/recommend/constraints/', json.dumps({}), content_type='application/json') self.assertEqual(response.status_code, 400) def test_get_recommend(self): response = self.get('/api/recommend/recommend/') self.assertEqual(response.status_code, 401) response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.get('/api/recommend/recommend/') self.assertEqual(response.status_code, 200) self.assertEqual(0, len(json.loads(response.content.decode()))) CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=1), score=7).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=2), score=8).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=3), score=9).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=4), score=10).save() Building(name='A', repre_name='A', latitude=37, longitude=127).save() Building(name='B', repre_name='B', latitude=37.0000001, longitude=127.0000001).save() Building(name='C', repre_name='C', latitude=37.01, longitude=127.01).save() CourseTime(course=Course.objects.get(id=1), building=Building.objects.get(id=1), lectureroom='home', weekday=0, start_time="12:00", end_time="13:00").save() CourseTime(course=Course.objects.get(id=2), building=Building.objects.get(id=2), lectureroom='home', weekday=0, start_time="13:00", end_time="14:00").save() CourseTime(course=Course.objects.get(id=3), building=Building.objects.get(id=3), lectureroom='home', weekday=0, start_time="14:00", end_time="15:00").save() CourseTime(course=Course.objects.get(id=4), building=Building.objects.get(id=3), lectureroom='home', weekday=0, start_time="14:00", end_time="15:00").save() response = self.get('/api/recommend/recommend/') self.assertEqual(response.status_code, 200) def test_post_recommend(self): response = self.post('/api/signin/', json.dumps({'email': '*****@*****.**', 'password': '******'}), content_type='application/json') response = self.post('/api/recommend/recommend/') self.assertEqual(1, len(json.loads(response.content.decode()))) CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=1), score=7).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=2), score=8).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=3), score=9).save() CoursePref(user=User.objects.get(id=1), course=Course.objects.get(id=4), score=10).save() Building(name='A', repre_name='A', latitude=37, longitude=127).save() Building(name='B', repre_name='B', latitude=37.0000001, longitude=127.0000001).save() Building(name='C', repre_name='C', latitude=37.01, longitude=127.01).save() CourseTime(course=Course.objects.get(id=1), building=Building.objects.get(id=1), lectureroom='home', weekday=0, start_time="12:00", end_time="13:00").save() CourseTime(course=Course.objects.get(id=2), building=Building.objects.get(id=2), lectureroom='home', weekday=0, start_time="13:00", end_time="14:00").save() CourseTime(course=Course.objects.get(id=3), building=Building.objects.get(id=3), lectureroom='home', weekday=0, start_time="14:00", end_time="15:00").save() CourseTime(course=Course.objects.get(id=4), building=Building.objects.get(id=3), lectureroom='home', weekday=0, start_time="14:00", end_time="15:00").save() response = self.post('/api/recommend/recommend/') response = self.get('/api/recommend/recommend/') self.assertEqual(response.status_code, 200)
def test_put(self): c = Client() response = c.put('/', HTTP_ACCEPT='application/javascript') expected_response = b'<p>This Request method is not handled.</p>' self.assertEqual(response.content, expected_response)
class BaseTestCase(TestCase): verbose = True def setUp(self): self.username = '******' self.user = User.objects.create(username=self.username, password=make_password('password')) self.client = Client() self.sign_in() def sign_in(self): self.assertTrue( self.client.login(username='******', password='******')) def get_test(self, url, success=True, status_code=None): response = self.client.get(url) if self.verbose: print(response.json()) self.assertEqual( response.status_code, status_code if status_code else 200 if success else 400) return response def post_test(self, url, data, success=True, status_code=None): response = self.client.post(url, data=data) if self.verbose: print(response.json()) self.assertEqual( response.status_code, status_code if status_code else 201 if success else 400) return response def put_test(self, url, data, success=True, status_code=None): response = self.client.put(url, data=json.dumps(data), content_type='application/json') if self.verbose: print(response.json()) self.assertEqual( response.status_code, status_code if status_code else 200 if success else 400) return response def patch_test(self, url, data, success=True, status_code=None): response = self.client.patch(url, data=json.dumps(data), content_type='application/json') if self.verbose: print(response.json()) self.assertEqual( response.status_code, status_code if status_code else 200 if success else 400) return response def delete_test(self, url, status_code=None): response = self.client.delete(url) if self.verbose: print(response.status_code) self.assertEqual(response.status_code, status_code if status_code else 204) return response
def grant_book_wish(self, user_creds, book_id): c = Client() url = '/wishlist/auth/bookWishes/books/{:d}/grant'.format(book_id) response = c.put(url, {'credentials': user_creds}, content_type="application/json") return _parse_response(response)[0]
class TestNotifyUsersAboutChallenge(TestCase): def setUp(self): self.client = Client() self.superuser = User.objects.create_superuser('superuser', "*****@*****.**", 'secret_password') self.user = User.objects.create(username='******', email="*****@*****.**", password='******') self.url = reverse_lazy('web:notify_users_about_challenge') self.email_data = { 'subject': 'Subject of the Email', 'body': 'Body of the Email' } def test_if_user_isnt_authenticated(self): response = self.client.get(self.url) html = response.content.decode('utf8') self.assertTrue(html.startswith('<!DOCTYPE html>')) self.assertTrue(html.endswith('')) self.assertEqual(response.status_code, 200) def test_if_user_is_authenticated_but_not_superuser(self): self.data = { 'username': self.user.username, 'password': self.user.password } response = self.client.post(self.url, self.data) html = response.content.decode('utf8') self.assertTrue(html.startswith('<!DOCTYPE html>')) self.assertTrue(html.endswith('')) self.assertEqual(response.status_code, 200) def test_if_user_is_authenticated_and_superuser(self): request = self.client.get('/admin/', follow=True) response = self.client.login(username='******', password='******') self.assertEqual(request.status_code, 200) self.assertTrue(response) def test_notification_email_data_page(self): request = self.client.get('/admin/', follow=True) response = self.client.login(username='******', password='******', follow=True) request = self.client.get(self.url) html = request.content.decode('utf8') self.assertTrue(html.startswith('')) self.assertTrue(html.endswith('')) self.assertEqual(request.status_code, 200) self.assertTrue(response) def test_notification_email_without_challenge_image(self): request = self.client.get('/admin/', follow=True) response = self.client.login(username='******', password='******', follow=True) request = self.client.post(self.url, self.email_data) html = request.content.decode('utf8') self.assertTrue(html.startswith('')) self.assertTrue(html.endswith('')) self.assertEqual(request.status_code, 200) self.assertTrue(response) def test_notification_email_with_challenge_image(self): request = self.client.get('/admin/', follow=True) response = self.client.login(username='******', password='******', follow=True) self.email_data['challenge_image'] = SimpleUploadedFile( name='test_background_image.jpg', content=open('frontend/src/images/rocket.png', 'rb').read(), content_type='image/jpg') request = self.client.post(self.url, self.email_data) html = request.content.decode('utf8') self.assertTrue(html.startswith('')) self.assertTrue(html.endswith('')) self.assertTrue(response) self.assertEqual(request.status_code, 200) def test_notification_with_put_request(self): request = self.client.get('/admin/', follow=True) response = self.client.login(username='******', password='******', follow=True) request = self.client.put(self.url, self.email_data) html = request.content.decode('utf8') self.assertTrue(html.startswith('<!DOCTYPE html>')) self.assertTrue(html.endswith('')) self.assertTrue(response) self.assertEqual(request.status_code, 200)
class LabelTest(APITestCase): def setUp(self): self.user = User.objects.create_user(username="******", password="******", email="*****@*****.**") token = RefreshToken.for_user(self.user) self.client = Client(HTTP_AUTHORIZATION=f'Bearer {token.access_token}') admin = User.objects.create_superuser(username="******", password="******") self.repository = Repository.objects.create( url='https://github.com/lazarmarkovic/uks2020', name='uks2020', is_private=False, user=admin) self.label1 = Label.objects.create(name="Label1", description="Test description", color="blue", repository=self.repository) self.label2 = Label.objects.create(name="Label2", description="Test description2", color="red", repository=self.repository) self.repository.label_set.add(self.label1) def test_get_all_labels(self): response = self.client.get(reverse("get_all_labels")) labels = Label.objects.all() serializer = LabelSerializer(labels, many=True) self.assertEqual(response.data, serializer.data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_get_all_labels_for_repo(self): response = self.client.get( reverse("get_all_labels_for_repo", kwargs={'repo_id': self.repository.id})) labels = Label.objects.filter(repository=self.repository.id) serializer = LabelSerializer(labels, many=True) self.assertEqual(response.data, serializer.data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_get_all_labels_for_repo_unauthorized(self): self.client = Client(HTTP_AUTHORIZATION="Bearer bad") response = self.client.get( reverse("get_all_labels_for_repo", kwargs={'repo_id': self.repository.id})) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_get_single_label_valid(self): response = self.client.get( reverse('get_one_label', kwargs={'label_id': self.label1.id})) label = Label.objects.get(pk=self.label1.pk) serializer = LabelSerializer(label) self.assertEqual(response.data, serializer.data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_get_single_label_invalid(self): respone = self.client.get( reverse('get_one_label', kwargs={'label_id': 99})) self.assertEqual(respone.status_code, status.HTTP_404_NOT_FOUND) def test_create_label_valid_data(self): count_before_create = Label.objects.all().count() response = self.client.post( reverse("create_label", kwargs={'repo_id': self.repository.id}), { 'name': 'LabelNew', 'description': 'Test description new label', 'color': 'green' }) count_after_create = Label.objects.all().count() label_new = Label.objects.get(name="LabelNew") serializer = LabelSerializer(label_new) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data, serializer.data) self.assertEqual(count_after_create, count_before_create + 1) def test_post_label_name_exists(self): response = self.client.post( reverse("create_label", kwargs={'repo_id': self.repository.id}), { 'name': 'Label1', 'description': 'Test creating label with existing name', 'color': 'white' }) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_post_label_unauthorized(self): self.client = Client(HTTP_AUTHORIZATION="Bearer bad") response = self.client.post( reverse("create_label", kwargs={'repo_id': self.repository.id}), { 'name': 'Label', 'description': 'Test creating label while unauthorized', 'color': 'black' }) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_post_label_invalid_repository(self): response = self.client.post( reverse("create_label", kwargs={'repo_id': 99}), { 'name': 'Label', 'description': 'Test creating label with invalid repository', 'color': 'grey' }) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_put_label_valid_data(self): label_info = { 'name': 'LabelUpdated', 'description': 'Test description updated label', 'color': 'orange' } response = self.client.put(reverse("update_label", kwargs={'label_id': self.label1.id}), data=json.dumps(label_info), content_type='application/json') label_updated = Label.objects.get(pk=self.label1.id) serializer = LabelSerializer(label_updated) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual('LabelUpdated', serializer.data['name']) self.assertEqual('Test description updated label', serializer.data['description']) self.assertEqual('orange', serializer.data['color']) def test_put_label_not_found(self): label_info = { 'name': 'LabelUpdated', 'description': 'Test description update label not found', 'color': 'orange' } response = self.client.put(reverse("update_label", kwargs={'label_id': 99}), data=json.dumps(label_info), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_put_label_unauthorized(self): self.client = Client(HTTP_AUTHORIZATION="Bearer bad") label_info = { 'name': 'LabelUpdated', 'description': 'Test description update label unauthorized', 'color': 'orange' } response = self.client.put(reverse("update_label", kwargs={'label_id': self.label1.id}), data=json.dumps(label_info), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_put_label_name_exists(self): label_info = { 'name': 'Label2', 'description': 'Test description update label to existing name', 'color': 'orange' } response = self.client.put(reverse("update_label", kwargs={'label_id': self.label1.id}), data=json.dumps(label_info), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_delete_label_valid(self): count_before_delete = Label.objects.all().count() response = self.client.delete( reverse("delete_label", kwargs={'label_id': self.label1.id})) count_after_delete = Label.objects.all().count() label_deleted = Label.objects.filter(name="Label1") self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(count_after_delete, count_before_delete - 1) self.assertEqual(label_deleted.exists(), False) def test_delete_label_not_found(self): response = self.client.delete( reverse("delete_label", kwargs={'label_id': 99})) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_delete_label_unathorized(self): self.client = Client(HTTP_AUTHORIZATION="Bearer bad") response = self.client.delete( reverse("delete_label", kwargs={'label_id': 99})) self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
class TestSerialPortsResource(TestCase): def setUp(self): self._random_model_generator = RandomSerialPortConfigGenerator() self._random_generator = RandomGenerator() (self._config_file, self._model_content) =\ self._random_model_generator.generate() self._serial_ports = self._model_content['serial_ports'] self._capture_data_access = SerialPortConfigModel._data_access SerialPortConfigModel._data_access =\ SerialPortConfigDataAccess(self._config_file) self.client = Client() self.json_parser = JSONParser() def tearDown(self): SerialPortConfigModel._data_access = self._capture_data_access os.remove(self._config_file) def prettify_json_content(self, device_list_content): result = {} for device in device_list_content: device_name = device['device_name'] result[device_name] = {} result[device_name]['log_file'] = device['log_file'] result[device_name]['driver'] = device['driver'] result[device_name]['baud_rate'] = device['baud_rate'] result[device_name]['flow_control'] = device['flow_control'] result[device_name]['parity'] = device['parity'] result[device_name]['stop_bits'] = device['stop_bits'] result[device_name]['character_size'] = device['character_size'] return result def assert_devices_equal_to_json_content(self, device_list, json_content): assert_that(len(device_list), equal_to(len(json_content))) for device in device_list: device_name = device.device_name device_json_content = json_content[device_name] assert_that(device_name, is_in(json_content)) self.assert_device_equal_to_json_content( device, device_json_content, check_device_name=False) def assert_device_equal_to_json_content( self, device, json_content, check_device_name=True): if check_device_name: assert_that(device.device_name, equal_to(json_content['device_name'])) assert_that(device.log_file, equal_to(json_content['log_file'])) assert_that(device.driver, equal_to(json_content['driver'])) assert_that(device.baud_rate, equal_to(json_content['baud_rate'])) assert_that(device.flow_control, equal_to(json_content['flow_control'])) assert_that(device.parity, equal_to(json_content['parity'])) assert_that(device.stop_bits, equal_to(json_content['stop_bits'])) assert_that(device.character_size, equal_to(json_content['character_size'])) def assert_device_updated(self, devices_before_request, device_to_be_going_to_updated, expected_updated_device_data, response): response_content = self.json_to_dict(response.content) assert_that(response.status_code, equal_to(200)) devices_after_request = SerialPortConfigModel.objects.all() assert_that(len(devices_before_request),\ equal_to(len(devices_after_request))) assert_that(response_content, equal_to(expected_updated_device_data)) updated_device = SerialPortConfigModel.objects.get( expected_updated_device_data['device_name']) self.assert_device_equal_to_json_content( updated_device, expected_updated_device_data) devices_before_request.remove(device_to_be_going_to_updated) devices_before_request.append(updated_device) ModelEqualityGuard.assert_equal_objects( devices_before_request, devices_after_request) def json_to_dict(self, json): stream = io.BytesIO(json) return self.json_parser.parse(stream) def update_device(self, device, updated_field): updated_device_data = {} updated_device_data['device_name'] =device.device_name updated_device_data['log_file'] = device.log_file updated_device_data['driver'] = device.driver updated_device_data['baud_rate'] = device.baud_rate updated_device_data['flow_control'] =\ device.flow_control updated_device_data['parity'] = device.parity updated_device_data['stop_bits'] = device.stop_bits updated_device_data['character_size'] =\ device.character_size updated_device_data[updated_field['field']] = updated_field['value'] return updated_device_data def choose_a_random_device(self): devices = SerialPortConfigModel.objects.all() selected_random_device = random.choice(devices) return (selected_random_device, devices) def __test_update_device__(self, updated_data): (selected_random_device, device_before_request) =\ self.choose_a_random_device() resource_url = '/serial_ports/{0}/'.format( selected_random_device.device_name) updated_device_data = self.update_device( selected_random_device, updated_data) response = self.client.put( resource_url, data=updated_device_data, content_type='application/json') self.assert_device_updated( device_before_request, selected_random_device, updated_device_data, response) def test_get_all_resource(self): model_equality_guard = ModelEqualityGuard(SerialPortConfigModel) response = self.client.get('/serial_ports/') json_content =\ self.prettify_json_content(self.json_to_dict(response.content)) devices = SerialPortConfigModel.objects.all() assert_that(response.status_code, equal_to(200)) self.assert_devices_equal_to_json_content( devices, json_content) def test_add_new_resource(self): devices_before_request = SerialPortConfigModel.objects.all() new_device_data = self._random_model_generator.generate_device_data() response = self.client.post( '/serial_ports/', data=new_device_data, content_type='application/json') devices_after_request = SerialPortConfigModel.objects.all() device = SerialPortConfigModel.objects.get( new_device_data['device_name']) assert_that(response.status_code, equal_to(201)) assert_that(len(devices_after_request), equal_to(len(devices_before_request) + 1)) self.assert_device_equal_to_json_content(device, new_device_data) devices_before_request.append(device) ModelEqualityGuard.assert_equal_objects( devices_before_request, devices_after_request) def test_get_a_resource(self): model_equality_guard = ModelEqualityGuard(SerialPortConfigModel) selected_random_device =\ random.choice(SerialPortConfigModel.objects.all()) resource_url = '/serial_ports/{0}/'.format( selected_random_device.device_name) response = self.client.get(resource_url) json_content = self.json_to_dict(response.content) assert_that(response.status_code, equal_to(200)) self.assert_device_equal_to_json_content( selected_random_device, json_content) def test_update_device_name(self): self.__test_update_device__({'field' : 'device_name', 'value' : self._random_generator.generate_string(2,10)}) def test_update_log_file(self): self.__test_update_device__({'field' : 'log_file', 'value' : self._random_generator.generate_string(2,10)}) def test_update_driver(self): self.__test_update_device__({'field' : 'driver', 'value' : self._random_generator.generate_string(2,10)}) def test_update_baud_rate(self): self.__test_update_device__({'field' : 'baud_rate', 'value' : random.choice(SerialPortConfigModel.baud_rate_choices)}) def test_update_flow_control(self): self.__test_update_device__({'field' : 'flow_control', 'value' : random.choice(SerialPortConfigModel.flow_control_choices)}) def test_update_parity(self): self.__test_update_device__({'field' : 'parity', 'value' : random.choice(SerialPortConfigModel.parity_choices)}) def test_update_stop_bits(self): self.__test_update_device__({'field' : 'stop_bits', 'value' : random.choice(SerialPortConfigModel.stop_bits_choices)}) def test_update_character_size(self): self.__test_update_device__({'field' : 'character_size', 'value' : self._random_generator.generate_int(1,100)}) def test_delete_a_resource(self): devices_before_request = SerialPortConfigModel.objects.all() selected_random_device = random.choice(devices_before_request) resource_url = '/serial_ports/{0}/'.format( selected_random_device.device_name) response = self.client.delete(resource_url) devices_after_request = SerialPortConfigModel.objects.all() assert_that(response.status_code, equal_to(204)) assert_that(len(devices_after_request), equal_to(len(devices_before_request) - 1)) devices_after_request.append(selected_random_device) ModelEqualityGuard.assert_equal_objects( devices_before_request, devices_after_request)
class CommentUrlsTest(TestCase): def setUp(self): User.objects.create(username='******', password=make_password('user1')) User.objects.create(username='******', password=make_password('user2')) User.objects.create(username='******', password=make_password('user3')) Project.objects.create(title='title1', description='description1', type='projet') Project.objects.create(title='title2', description='a description 2', type='projet') Contributor.objects.create( user=User.objects.get(pk=1), project=Project.objects.get(pk=1), permission='manager', role='manager', ) Contributor.objects.create( user=User.objects.get(pk=2), project=Project.objects.get(pk=1), permission='contributeur', role='contributeur', ) Issue.objects.create( title='title1', desc='description1', tag='bug', priority='moyenne', project=Project.objects.get(pk=1), status='a faire', author=User.objects.get(pk=1), assignee=User.objects.get(pk=2), created_time=0, ) Issue.objects.create( title='title2', desc='description2', tag='bug', priority='moyenne', project=Project.objects.get(pk=1), status='a faire', author=User.objects.get(pk=1), assignee=User.objects.get(pk=2), created_time=0, ) Issue.objects.create( title='title4', desc='description4', tag='bug', priority='moyenne', project=Project.objects.get(pk=2), status='a faire', author=User.objects.get(pk=1), assignee=User.objects.get(pk=2), created_time=0, ) Comment.objects.create( description='description1', author=User.objects.get(pk=1), issue=Issue.objects.get(pk=1), created_time=0, ) Comment.objects.create( description='description2', author=User.objects.get(pk=2), issue=Issue.objects.get(pk=1), created_time=0, ) Comment.objects.create( description='description3', author=User.objects.get(pk=1), issue=Issue.objects.get(pk=3), created_time=0, ) self.create_read_good_url = '/api/projects/1/issues/1/comments/' self.create_read_wrong_urls = [ '/api/projects/1/issues/3/comments/', '/api/projects/2/issues/1/comments/', '/api/projects/3/issues/1/comments/', '/api/projects/1/issues/4/comments/', '/api/projects/3/issues/3/comments/', ] self.read_update_delete_good_url =\ '/api/projects/1/issues/1/comments/1/' self.read_update_delete_wrong_urls = [ '/api/projects/1/issues/1/comments/3/', '/api/projects/1/issues/2/comments/1/', '/api/projects/2/issues/1/comments/1/', '/api/projects/3/issues/1/comments/1/', '/api/projects/1/issues/4/comments/1/', '/api/projects/1/issues/1/comments/3/', '/api/projects/2/issues/3/comments/1/', '/api/projects/1/issues/2/comments/2/', ] self.auth_url = reverse('token_obtain') self.client_user1 = Client(HTTP_AUTHORIZATION='Bearer ' + self.get_token('user1', 'user1')) self.client_user2 = Client(HTTP_AUTHORIZATION='Bearer ' + self.get_token('user2', 'user2')) self.client_user3 = Client(HTTP_AUTHORIZATION='Bearer ' + self.get_token('user3', 'user3')) def get_token(self, username, password): post = {'username': username, 'password': password} response = self.client.post(self.auth_url, post) data = json.loads(response.content) return data['access'] def test_list_good_url(self): response = self.client_user1.get(self.create_read_good_url) self.assertEquals(response.status_code, 200) def test_list_wrong_urls(self): for url in self.create_read_wrong_urls: response = self.client_user1.get(url) self.assertEquals(response.status_code, 404) def test_create_good_url(self): post = {'description': 'description4'} response = self.client_user1.post(self.create_read_good_url, post) self.assertEquals(response.status_code, 201) def test_create_wrong_urls(self): post = {'description': 'description4'} for url in self.create_read_wrong_urls: response = self.client_user1.post(url, post) self.assertEquals(response.status_code, 404) def test_read_good_url(self): response = self.client_user1.get(self.read_update_delete_good_url) self.assertEquals(response.status_code, 200) def test_read_wrong_urls(self): for url in self.read_update_delete_wrong_urls: response = self.client_user1.get(url) self.assertEquals(response.status_code, 404) def test_update_good_url(self): post = {'description': 'description_update'} response = self.client_user1.put(self.read_update_delete_good_url, post, content_type='application/json') self.assertEquals(response.status_code, 200) def test_update_wrong_urls(self): post = {'description': 'description_update'} for url in self.read_update_delete_wrong_urls: response = self.client_user1.put(url, post, content_type='application/json') self.assertEquals(response.status_code, 404) def test_delete_good_url(self): response = self.client_user1.delete(self.read_update_delete_good_url) self.assertEquals(response.status_code, 204) def test_delete_wrong_urls(self): for url in self.read_update_delete_wrong_urls: response = self.client_user1.delete(url) self.assertEquals(response.status_code, 404)
class CommentHttpTestCase(TestCase): def setUp(self): category = Category.objects.create(title="고민 상담") board1 = Board.objects.create( category_id=category, user="******", name="hodong", description="테스트란 어떤 걸까", ) board2 = Board.objects.create( category_id=category, user="******", name="hodongGod", description="테스트는 해야 하는 것인가에 대하여 어렵구만", ) Comment.objects.create(board_id=board1, user="******", name="alexis", description="이적했다 개꿀") Comment.objects.create(board_id=board1, user="******", name="mchitariyan", description="슈바 난 가기 싫었어") Comment.objects.create(board_id=board2, user="******", name="딥플로우", description="deep is back") Comment.objects.create(board_id=board2, user="******", name="던말릭", description="Old wave") self._client = Client() def test_http_get_list_comment(self): http_response = self._client.get("/api/board/comment/") self.assertEqual(http_response.status_code, 200) def test_http_get_retrieve_comment(self): http_response1 = self._client.get("/api/board/comment/1/") http_response2 = self._client.get("/api/board/comment/2/") http_response3 = self._client.get("/api/board/comment/3/") http_response4 = self._client.get("/api/board/comment/4/") self.assertEqual(http_response1.status_code, 200) self.assertEqual(http_response2.status_code, 200) self.assertEqual(http_response3.status_code, 200) self.assertEqual(http_response4.status_code, 200) def test_http_post_create_comment(self): http_response = self._client.post( "/api/board/comment/", { "board_id": 2, "user": "******", "name": "메수트", "description": "산체스 치사하게 지 혼자 가네" }) self.assertEqual(http_response.status_code, 201) def test_http_put_update_comment(self): http_response = self._client.put("/api/board/comment/1/", dumps({ "board_id": 2, "user": "******", "name": "메수트", "description": "산체스 치사하게 지 혼자 가네" }), content_type="application/json") self.assertEqual(http_response.status_code, 200) def test_http_delete_comment(self): http_response = self._client.delete("/api/board/comment/1/") self.assertEqual(http_response.status_code, 204)
class TestUserAPP(TestCase): def setUp(self): self.client = Client() self.valid_payload = { 'username': '******', 'email': '*****@*****.**', 'first_name': 'Akash', 'last_name': 'Kumar', 'password': '******' } self.invalid_payload = { 'username': '', 'email': '*****@*****.**', 'first_name': 'Akash', 'last_name': 'Kumar', 'password': '******' } self.valid_credential = { 'username': '******', 'password': '******' } self.invalid_credential = { 'username': '******', 'password': '******' } self.valid_old_password = "******" self.valid_profile_payload = { "firstName": "Aryan", "lastName": "Nath", "bio": "Hi, I am a passionate software developer", "dob": "1995-09-09" } self.invalid_profile_payload = { "firstName": "", "lastName": "DebNath", "bio": "Hi, I am a passionate software developer", "dob": "199509", } def test_user_registration_when_given_valid_payload(self): response = self.client.post(reverse('userRegistration'), data=json.dumps(self.valid_payload), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_201_CREATED) def test_user_registration_when_given_invalid_payload(self): response = self.client.post(reverse('userRegistration'), data=json.dumps(self.invalid_payload), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) def test_user_email_validated_when_given_valid_token(self): response = self.client.post(reverse('userRegistration'), data=json.dumps(self.valid_payload), content_type='application/json') jwtTokn = response.data['response_data'] get_respose = self.client.get( "http://127.0.0.1:8000/user/verify-email/?token=" + jwtTokn, content_type='application/json') self.assertEquals(get_respose.status_code, status.HTTP_200_OK) def test_user_email_validated_when_given_invalid_token(self): jwtTokn = """eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VybmFtZSI6ImFrYXNoMTIzIiwicGFzc3dvcmQiOiJwYmtkZjJfc2hhMjU2JDE4MDAwMCRxdDBFa3Vxa2t4ZU8kNndURDMrWGF2SENyTGQwSHM3S3BmYlo1b01v NWIzTkZEZStDMTlBM0ZXdz0iLCJleHAiOjE2MDk5NTA2MT.l31v9OmEZoMFSHA4LycwsDT4oD-lxm5VUkEz3Zrn_28""" get_respose = self.client.get( "http://127.0.0.1:8000/user/verify-email/?token=" + jwtTokn, content_type='application/json') self.assertEquals(get_respose.status_code, status.HTTP_401_UNAUTHORIZED) def test_user_login_when_given_valid_credential(self): self.test_user_email_validated_when_given_valid_token() response = self.client.post(reverse('userLogin'), data=json.dumps(self.valid_credential), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_302_FOUND) def test_user_login_when_given_invalid_credential(self): self.test_user_email_validated_when_given_valid_token() response = self.client.post(reverse('userLogin'), data=json.dumps(self.invalid_credential), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_401_UNAUTHORIZED) def test_user_login_when_given_valid_credential_but_account_is_not_activated( self): self.test_user_registration_when_given_valid_payload() response = self.client.post(reverse('userLogin'), data=json.dumps(self.valid_credential), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_100_CONTINUE) def test_user_logout_when_user_is_not_logged_in(self): response = self.client.get(reverse('userLogout')) self.assertEquals(response.status_code, status.HTTP_302_FOUND) self.assertEquals(response.url, '/user/login?next=/user/logout/') def test_user_logout_when_user_is_logged_in(self): self.test_user_login_when_given_valid_credential() response = self.client.get(reverse('userLogout')) self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEquals(response.data['response_msg'], 'You are logged out successfully') def test_forgot_password_api_when_mail_id_is_registered(self): self.test_user_registration_when_given_valid_payload() email = json.dumps({'email': '*****@*****.**'}) response = self.client.post(reverse('forgotPassword'), data=email, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_100_CONTINUE) self.assertEquals(response.data['response_msg'], 'Password reset link is sent to your mail.') def test_forgot_password_api_when_mail_id_is_not_registered(self): email = json.dumps({'email': '*****@*****.**'}) response = self.client.post(reverse('forgotPassword'), data=email, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND) self.assertEquals(response.data['response_msg'], 'Your Mail id is not registered') def test_forgot_password_api_when_mail_id_is_invalid(self): email = json.dumps({'email': 'birajit1123.com'}) response = self.client.post(reverse('forgotPassword'), data=email, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) def test_reset_password_api_when_given_valid_uid_and_valid_token(self): self.test_user_registration_when_given_valid_payload() email = json.dumps({'email': '*****@*****.**'}) response1 = self.client.post(reverse('forgotPassword'), data=email, content_type='application/json') token = response1.data['response_data'] uid = 1 data = json.dumps({ 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('resetPassword', args=[uid, token]), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEquals(response.data['response_msg'], 'Your password is reset successfully !') def test_reset_password_api_when_given_mismatch_passwords(self): self.test_user_registration_when_given_valid_payload() email = json.dumps({'email': '*****@*****.**'}) response1 = self.client.post(reverse('forgotPassword'), data=email, content_type='application/json') token = response1.data['response_data'] uid = 1 data = json.dumps({ 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('resetPassword', args=[uid, token]), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) def test_reset_password_api_when_given_invalid_token(self): self.test_user_registration_when_given_valid_payload() email = json.dumps({'email': '*****@*****.**'}) response1 = self.client.post(reverse('forgotPassword'), data=email, content_type='application/json') token = response1.data['response_data'] + 'invalid' uid = 1 data = json.dumps({ 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('resetPassword', args=[uid, token]), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) def test_change_password_api_when_given_valid_old_password_and_user_is_logged_in( self): self.test_user_login_when_given_valid_credential() data = json.dumps({ 'old_password': self.valid_old_password, 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('changePassword'), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_200_OK) def test_change_password_api_when_given_invalid_old_password_and_user_is_logged_in( self): self.test_user_login_when_given_valid_credential() data = json.dumps({ 'old_password': '******', 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('changePassword'), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_401_UNAUTHORIZED) self.assertEquals(response.data['response_msg'], "Old password does not match!") def test_change_password_api_when_given_valid_old_password_and_user_is_logged_in_but_missmatch_new_passwords( self): self.test_user_login_when_given_valid_credential() data = json.dumps({ 'old_password': self.valid_old_password, 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('changePassword'), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) def test_change_password_api_when_given_valid_old_password_but_user_is_not_logged_in( self): data = json.dumps({ 'old_password': self.valid_old_password, 'password': '******', 'confirm_password': '******' }) response = self.client.put(reverse('changePassword'), data=data, content_type='application/json') self.assertEquals(response.status_code, status.HTTP_302_FOUND) self.assertEquals(response.url, '/user/login?next=/user/change-password/') def test_profile_update_api_when_given_valid_payload_and_user_is_logged_in( self): self.test_user_login_when_given_valid_credential() response = self.client.put(reverse('userProfile'), data=json.dumps(self.valid_profile_payload), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEquals(response.data['response_msg'], "Your Profile is updated") def test_profile_update_api_when_given_invalid_payload_and_user_is_logged_in( self): self.test_user_login_when_given_valid_credential() response = self.client.put(reverse('userProfile'), data=json.dumps( self.invalid_profile_payload), content_type='application/json') self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) def test_profile_api_when_hit_get_request_and_user_is_logged_in(self): self.test_profile_update_api_when_given_valid_payload_and_user_is_logged_in( ) expected_response_data = json.dumps({ 'username': '******', 'email': '*****@*****.**', 'first_name': 'Aryan', 'last_name': 'Nath', 'bio': 'Hi, I am a passionate software developer', 'dob': '1995-09-09', 'image': '/media/profile_pics/default.jpg' }) response = self.client.get(reverse('userProfile')) self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEquals(json.dumps(response.data['response_msg']), expected_response_data) def test_profile_api_when_hit_get_request_and_user_is_not_logged_in(self): response = self.client.get(reverse('userProfile')) self.assertEquals(response.status_code, status.HTTP_302_FOUND) self.assertEquals(response.url, '/user/login?next=/user/profile/')
def test_get_user_action(self): """Get USER action""" client = Client() # Sign In client.get('/api/session', data={ constants.EMAIL: '*****@*****.**', constants.PASSWORD: '******' }, content_type='application/json') # Make Collections client.post('/api/collection', json.dumps({ constants.TITLE: 'test_collection', constants.TEXT: 'test_collection' }), content_type='application/json') test_collection_id = Collection.objects.filter( title='test_collection').first().id paper_id = Paper.objects.filter(title='paper1').first().id user_id = User.objects.filter(email='*****@*****.**').first().id keyword_id = Keyword.objects.filter(name='keyword1').first().id # Add paper to test_collection client.put('/api/paper/collection', json.dumps({ constants.ID: paper_id, constants.COLLECTION_IDS: [test_collection_id] }), content_type='application/json') # Like Paper client.post('/api/like/paper', data=json.dumps({ constants.ID: paper_id, }), content_type='application/json') # Make Review For Paper client.post('/api/review', data=json.dumps({ constants.ID: paper_id, constants.TITLE: "Test Review Title", constants.TEXT: 'Test Review Text' }), content_type='application/json') response = client.get('/api/user/action') self.assertEqual(response.status_code, 200) self.assertListEqual([{ "UserId": user_id, "ItemId": paper_id, "Type": "make_review", "Count": 1 }, { "UserId": user_id, "ItemId": paper_id, "Type": "like_paper", "Count": 1 }, { "UserId": user_id, "ItemId": paper_id, "Type": "add_to_collection", "Count": 1 }], json.loads(response.content)["actions"]) self.assertListEqual([{ 'UserId': user_id }], json.loads(response.content)["users"]) self.assertDictEqual( { 'ItemId': paper_id, 'Keywords': [{ 'id': keyword_id, 'name': 'keyword1', 'type': 'abstract' }], 'Abstract': 'abstract1' }, json.loads(response.content)["papers"][10])
class PlayerSettingsTest(TestCase): def setUp(self): self.player_alpha = Player() self.player_alpha.email = '*****@*****.**' self.player_alpha.set_password('fake_a') self.player_alpha.username = '******' self.player_alpha.save() self.player_beta = Player() self.player_beta.email = '*****@*****.**' self.player_beta.set_password('fake_b') self.player_beta.username = '******' self.player_beta.save() self.game_session = GameSession.objects.create() self.player_gamesession = Player_GameSession.objects.create( game_session=self.game_session, player=self.player_alpha, ) self.player_gamesession = Player_GameSession.objects.create( game_session=self.game_session, player=self.player_beta, ) self.client_player_a = Client( HTTP_AUTHORIZATION=f'Token {self.player_alpha.auth_token.key}') self.profile_url = reverse('profile') def test_token_retrieval(self): client = Client() token_endpoint = reverse('get_token') unauth_response = client.post(token_endpoint, { 'username': self.player_alpha.username, 'password': '******' }) self.assertEqual(unauth_response.status_code, 401) response = client.post(token_endpoint, { 'username': self.player_alpha.username, 'password': '******' }) self.assertEqual(response.status_code, 200) self.assertEqual(response.data['token'], self.player_alpha.auth_token.key) # Profile related view tests def test_new_player_POST_can_create_new_player_on_valid_request(self): client = Client() url = reverse('new_player') email = '*****@*****.**' username = '******' data = {'email': email, 'username': username, 'password': '******'} json_data = json.dumps(data) response = client.post(path=url, data=json_data, content_type='application/json') self.assertEqual(response.status_code, 201) queried_player = Player.objects.get(username=username) self.assertEqual(queried_player.email, email) incomplete_data = data.pop('email') incomplete_json_data = json.dumps(incomplete_data) print("Error logging from test prints to console:") response = client.post(path=url, data=incomplete_json_data, content_type='application/json') print("Log complete. \n") self.assertEqual(response.status_code, 400) def test_player_views_own_account_with_valid_token_only_on_GET(self): auth_token = f'Token {self.player_alpha.auth_token.key}' client = Client() invalid_token = 'Token not_a_valid_token' response = self.client.get(self.profile_url, HTTP_AUTHORIZATION=invalid_token) self.assertEqual(response.status_code, 401) response = self.client.get(self.profile_url, HTTP_AUTHORIZATION=auth_token) self.assertEqual(response.status_code, 200) def test_player_can_delete_account(self): response = self.client_player_a.delete(self.profile_url) self.assertEqual(response.status_code, 204) def test_player_POST_updates_profile_info(self): username = '******' data = {'username': username} json_data = json.dumps(data) response = self.client_player_a.post(self.profile_url, data=json_data, content_type='application/json') self.assertEqual(response.status_code, 202) # GameSession related view tests def test_player_can_GET_all_sessions_available(self): for i in range(10): GameSession.objects.create() url = reverse('game_sessions') response = self.client_player_a.get(url) game_session_id = str(self.game_session.game_session_id) self.assertContains(response, game_session_id) def test_player_POST_can_create_new_game_session(self): url = reverse('game_sessions') response = self.client_player_a.post(url) self.assertEqual(response.status_code, 201) self.assertIn('x_position', response.data) self.assertContains(response, text='x_position', status_code=201) # Player_GameSession related view tests def test_player_GET_all_own_game_sessions(self): url = reverse('player_all_game_sessions') response = self.client_player_a.get(url) self.assertEqual(response.status_code, 200) game_sessions = GameSession.objects.all().filter( player=self.player_alpha) for session in game_sessions: session_id = str(session.game_session_id) self.assertContains(response, text=session_id) unused_session = GameSession.objects.create() unused_session_id = str(unused_session.game_session_id) self.assertNotContains(response, text=unused_session_id) def test_player_GET_sees_game_session_data(self): url = reverse('player_game_session') game_session = str(self.game_session.game_session_id) data = {'game_session': game_session} json_data = json.dumps(data) response = self.client_player_a.post(url, json_data, content_type='application/json') self.assertContains(response, text=game_session) # NOTE: Add check that player_beta is returned -- player data for all players needed def test_player_PUT_updates_game_session_data(self): url = reverse('player_game_session') keys = ['x_position', 'y_position', 'points'] values = [101, 501, 12001] data = dict(zip(keys, values)) data['game_session'] = str(self.game_session.game_session_id) json_data = json.dumps(data) response = self.client_player_a.put(url, json_data, content_type='application/json') self.assertContains( response, text='"x_position":101,"y_position":501,"points":12001', status_code=202) def test_player_DELETE_removes_player_from_game_session(self): url = reverse('player_game_session') session_id = str(self.game_session.game_session_id) data = {'game_session': session_id} json_data = json.dumps(data) response = self.client_player_a.delete(url, json_data, content_type='application/json') removed_session = Player_GameSession.objects.all().filter( game_session=session_id, player=self.player_alpha).first() self.assertEqual(removed_session, None)
class TestCreditTrades(TestCase): fixtures = [ 'organization_types.json', 'organization_government.json', 'organization_balance_gov.json', 'credit_trade_statuses.json', 'credit_trade_statuses_refused.json', 'organization_actions_types.json', 'organization_statuses.json', 'test_users.json', 'credit_trade_types.json', 'test_credit_trades.json', 'test_organization_fuel_suppliers.json', 'test_organization_balances.json', 'roles.json', 'permissions.json', 'roles_permissions.json', ] def setUp(self): # Initialize Foreign keys self.test_url = "/api/credit_trades" self.gov_user = User.objects.filter(organization__id=1).first() self.gov_client = Client( HTTP_SMGOV_USERGUID=str(self.gov_user.authorization_guid), HTTP_SMGOV_USERDISPLAYNAME=self.gov_user.display_name, HTTP_SMGOV_USEREMAIL=self.gov_user.email, HTTP_SM_UNIVERSALID=self.gov_user.authorization_id, HTTP_SMGOV_USERTYPE='Internal', HTTP_SM_AUTHDIRNAME='IDIR') ''' Apply a government role to Teperson ''' username = "******".join( ['internal', self.gov_user.authorization_id.lower()]) gov_user = User.objects.get(username=username) gov_role = Role.objects.get(name='GovDirector') UserRole.objects.create(user_id=gov_user.id, role_id=gov_role.id) self.user_1 = User.objects.filter(organization__id=2).first() self.fs_client_1 = Client( HTTP_SMGOV_USERGUID=str(self.user_1.authorization_guid), HTTP_SMGOV_USERDISPLAYNAME=self.user_1.display_name, HTTP_SMGOV_USEREMAIL=self.user_1.email, HTTP_SM_UNIVERSALID=self.user_1.authorization_id) self.user_2 = User.objects.filter(organization__id=3).first() self.fs_client_2 = Client( HTTP_SMGOV_USERGUID=str(self.user_2.authorization_guid), HTTP_SMGOV_USERDISPLAYNAME=self.user_2.display_name, HTTP_SMGOV_USEREMAIL=self.user_2.email, HTTP_SM_UNIVERSALID=self.user_2.authorization_id) self.user_3 = User.objects.filter(organization__id=4).first() self.fs_client_3 = Client( HTTP_SMGOV_USERGUID=str(self.user_3.authorization_guid), HTTP_SMGOV_USERDISPLAYNAME=self.user_3.display_name, HTTP_SMGOV_USEREMAIL=self.user_3.email, HTTP_SM_UNIVERSALID=self.user_3.authorization_id) # As a fuel supplier, I should see all credit trades where: # I'm the initiator, regardless of status # I'm the respondent, if the status is "submitted" or greater def test_initiator_should_see_appropriate_credit_trades(self): response = self.fs_client_1.get('/api/credit_trades') self.assertEqual(response.status_code, status.HTTP_200_OK) fs_credit_trades = response.json() for ct in fs_credit_trades: correct_view = False if ct['initiator']['id'] == self.user_1.organization.id: correct_view = True elif (ct['respondent']['id'] == self.user_1.organization.id and ct['status']['id'] >= STATUS_SUBMITTED): correct_view = True self.assertTrue(correct_view) # As a fuel supplier, I should be able to refuse credit transfers where: # I'm the respondent def test_respondent_can_refuse_credit_trades(self): # Assign FSManager role to user 1 role = Role.objects.get(name='FSManager') UserRole.objects.create(user_id=self.user_1.id, role_id=role.id) refused_status, created = CreditTradeStatus.objects.get_or_create( status='Refused') submitted_status, created = CreditTradeStatus.objects.get_or_create( status='Submitted') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade = CreditTrade.objects.create( status=submitted_status, initiator=self.user_2.organization, respondent=self.user_1.organization, type=credit_trade_type, number_of_credits=100, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) payload = { 'fairMarketValuePerCredit': credit_trade.fair_market_value_per_credit, 'initiator': credit_trade.initiator_id, 'numberOfCredits': credit_trade.number_of_credits, 'respondent': credit_trade.respondent_id, 'status': refused_status.id, 'tradeEffectiveDate': credit_trade.trade_effective_date, 'type': credit_trade.type_id, 'zeroReason': credit_trade.zero_reason_id } response = self.fs_client_1.put('/api/credit_trades/{}'.format( credit_trade.id), content_type='application/json', data=json.dumps(payload)) self.assertEqual(response.status_code, status.HTTP_200_OK) credit_trade = CreditTrade.objects.get(id=credit_trade.id) self.assertEqual(credit_trade.status, refused_status) # As a government user, I should see all credit trades where: # I'm the initiator, regardless of status # Government will never be the respondent # All other credit trades that have the status "Accepted" or greater def test_government_user_should_see_appropriate_credit_trades(self): response = self.gov_client.get('/api/credit_trades') self.assertEqual(response.status_code, status.HTTP_200_OK) gov_credit_trades = response.json() for ct in gov_credit_trades: correct_view = False if ct['initiator']['id'] == self.gov_user.organization.id: correct_view = True elif ct['status']['id'] >= STATUS_ACCEPTED and \ ct['status']['id'] != STATUS_CANCELLED: correct_view = True self.assertTrue(correct_view) # As a government user, I should be able to add an approved # credit transfer def test_government_user_add_credit_transfer(self): credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') payload = { 'fairMarketValuePerCredit': '1.00', 'initiator': 2, 'numberOfCredits': 1, 'respondent': 3, 'status': credit_trade_status.id, 'tradeEffectiveDate': datetime.datetime.today().strftime('%Y-%m-%d'), 'type': credit_trade_type.id, 'zeroReason': None } response = self.gov_client.post('/api/credit_trades', content_type='application/json', data=json.dumps(payload)) self.assertEqual(response.status_code, status.HTTP_201_CREATED) # As a government user, I should be able to add an approved # credit transfer with 0 fair market value: # If the type is 'Sell', Fair Market Value needs to be greater than 0 # or zero dollar reason must be provided # This tests if we try to submit a 0 dollar credit transaction with no # reason def test_government_user_add_credit_transfer(self): credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') payload = { 'fairMarketValuePerCredit': '0.00', 'initiator': 2, 'numberOfCredits': 1, 'respondent': 3, 'status': credit_trade_status.id, 'tradeEffectiveDate': datetime.datetime.today().strftime('%Y-%m-%d'), 'type': credit_trade_type.id, 'zeroReason': None } response = self.gov_client.post('/api/credit_trades', content_type='application/json', data=json.dumps(payload)) # 400 since zero reason was set to None self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) # As a government user, I should be able to add an approved # credit transfer with 0 fair market value: # If the type is 'Sell', Fair Market Value needs to be greater than 0 # or zero dollar reason must be provided def test_government_user_add_credit_transfer(self): credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade_zero_reason, created = CreditTradeZeroReason.objects \ .get_or_create(reason='Other', display_order=2) payload = { 'fairMarketValuePerCredit': '0.00', 'initiator': 2, 'numberOfCredits': 1, 'respondent': 3, 'status': credit_trade_status.id, 'tradeEffectiveDate': datetime.datetime.today().strftime('%Y-%m-%d'), 'type': credit_trade_type.id, 'zeroReason': credit_trade_zero_reason.id } response = self.gov_client.post('/api/credit_trades', content_type='application/json', data=json.dumps(payload)) # 400 since zero reason was set to None self.assertEqual(response.status_code, status.HTTP_201_CREATED) # As a government user, I should be able to validate approved credit # transfers: # It should raise an exception if it sees any fuel suppliers with # insufficient funds def test_validate_credit(self): credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade_zero_reason, created = CreditTradeZeroReason.objects \ .get_or_create(reason='Other', display_order=2) CreditTrade.objects.create( status=credit_trade_status, initiator=self.user_2.organization, respondent=self.user_3.organization, type=credit_trade_type, number_of_credits=1000000000, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) credit_trades = CreditTrade.objects.filter( status_id=credit_trade_status.id) with self.assertRaises(PositiveIntegerException): CreditTradeService.validate_credits(credit_trades) # As a government user, I should be able to validate approved credit # transfers: # It should raise an exception if it sees any fuel suppliers with # insufficient funds # This is a slightly more complex test where we have multi credit trades # with new organizations that bounces the number of credits up and down def test_validate_credit_complex(self): credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade_zero_reason, created = CreditTradeZeroReason.objects \ .get_or_create(reason='Other', display_order=2) from_organization = Organization.objects.create(name="Test 1", actions_type_id=1, status_id=1) to_organization = Organization.objects.create(name="Test 2", actions_type_id=1, status_id=1) # Award Test 1 with 1000 credits (new organizations start # with 0 credits) # (Please note in most cases we should use a different type # but to reduce the number of things to keep track, lets just # transfer from organization: 1 (BC Government)) CreditTrade.objects.create( status=credit_trade_status, initiator=self.gov_user.organization, respondent=from_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # Transfer 500 from Test 1 to Test 2 CreditTrade.objects.create( status=credit_trade_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=500, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # Transfer 700 from Test 1 to Test 2 CreditTrade.objects.create( status=credit_trade_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=700, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) credit_trades = CreditTrade.objects.filter( status_id=credit_trade_status.id) # this should now raise an exception since we tried transferring # 1200 credits when only 1000 are available with self.assertRaises(PositiveIntegerException): CreditTradeService.validate_credits(credit_trades) # As a government user, I should be able to validate approved credit # transfers: # It should raise an exception if it sees any fuel suppliers with # insufficient funds # This test is similar to the one above, but should succeed as we're going # to allocate the right amount of credits this time def test_validate_credit_success(self): credit_trades = [] credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade_zero_reason, created = CreditTradeZeroReason.objects \ .get_or_create(reason='Other', display_order=2) from_organization = Organization.objects.create(name="Test 1", actions_type_id=1, status_id=1) to_organization = Organization.objects.create(name="Test 2", actions_type_id=1, status_id=1) # Award Test 1 with 1000 credits (new organizations start # with 0 credits) # (Please note in most cases we should use a different type # but to reduce the number of things to keep track, lets just # transfer from organization: 1 (BC Government)) credit_trades.append( CreditTrade.objects.create( status=credit_trade_status, initiator=self.gov_user.organization, respondent=from_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d'))) # Transfer 500 from Test 1 to Test 2 credit_trades.append( CreditTrade.objects.create( status=credit_trade_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=500, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d'))) # Transfer 300 from Test 1 to Test 2 credit_trades.append( CreditTrade.objects.create( status=credit_trade_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=300, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d'))) # no exceptions should be raised CreditTradeService.validate_credits(credit_trades) # As a government user, I should be able to process all the approved # credit transfers # This test is similar to the one above, but a functional test to check # if the commit actually works def test_batch_process(self): credit_trade_status, created = CreditTradeStatus.objects.get_or_create( status='Approved') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade_zero_reason, created = CreditTradeZeroReason.objects \ .get_or_create(reason='Other', display_order=2) from_organization = Organization.objects.create(name="Test 1", actions_type_id=1, status_id=1) to_organization = Organization.objects.create(name="Test 2", actions_type_id=1, status_id=1) CreditTrade.objects.create( status=credit_trade_status, initiator=self.gov_user.organization, respondent=from_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) CreditTrade.objects.create( status=credit_trade_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=500, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) CreditTrade.objects.create( status=credit_trade_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=400, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) credit_trades = CreditTrade.objects.filter( status_id=credit_trade_status.id) response = self.gov_client.put('/api/credit_trades/batch_process') assert response.status_code == status.HTTP_200_OK organization_balance = OrganizationBalance.objects.get( organization_id=from_organization.id, expiration_date=None) self.assertEqual(organization_balance.validated_credits, 100) # As a government user, I should be able to delete credit transfers # (Not a hard delete, just sets the status to Cancelled) def test_delete(self): completed_status, created = CreditTradeStatus.objects.get_or_create( status='Completed') cancelled_status, created = CreditTradeStatus.objects.get_or_create( status='Cancelled') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') credit_trade_zero_reason, created = CreditTradeZeroReason.objects \ .get_or_create(reason='Other', display_order=2) from_organization = Organization.objects.create(name="Test 1", actions_type_id=1, status_id=1) to_organization = Organization.objects.create(name="Test 2", actions_type_id=1, status_id=1) credit_trade = CreditTrade.objects.create( status=completed_status, initiator=self.gov_user.organization, respondent=from_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=0, zero_reason=credit_trade_zero_reason, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) response = self.gov_client.put('/api/credit_trades/{}/delete'.format( credit_trade.id)) self.assertEqual(response.status_code, status.HTTP_200_OK) credit_trade = CreditTrade.objects.get(id=credit_trade.id) self.assertEqual(credit_trade.status_id, cancelled_status.id) # As a government user # I shouldn't see drafts unless I'm the initiator # I shouldn't see cancelled transfers as they're considered (deleted) def test_get_organization_credit_trades_gov(self): completed_status, created = CreditTradeStatus.objects.get_or_create( status='Completed') cancelled_status, created = CreditTradeStatus.objects.get_or_create( status='Cancelled') draft_status, created = CreditTradeStatus.objects.get_or_create( status='Draft') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') from_organization = Organization.objects.create(name="Test 1", actions_type_id=1, status_id=1) to_organization = Organization.objects.create(name="Test 2", actions_type_id=1, status_id=1) # the function shouldn't see this as it's only a draft and the # initiator is not government draft_credit_trade = CreditTrade.objects.create( status=draft_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # the function should see this as it's a draft from the government draft_credit_trade_from_gov = CreditTrade.objects.create( status=draft_status, initiator=self.gov_user.organization, respondent=to_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # the function should see this as it's completed completed_credit_trade = CreditTrade.objects.create( status=completed_status, initiator=from_organization, respondent=to_organization, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) credit_trades = CreditTradeService.get_organization_credit_trades( self.gov_user.organization) self.assertNotIn(draft_credit_trade, credit_trades) self.assertIn(draft_credit_trade_from_gov, credit_trades) self.assertIn(completed_credit_trade, credit_trades) # As a fuel supplier # I shouldn't see drafts unless I'm the initiator # I shouldn't see cancelled transfers as they're considered (deleted) # I shouldn't see submitted transfers unless I'm involved somehow def test_get_organization_credit_trades_fuel_supplier(self): completed_status, created = CreditTradeStatus.objects.get_or_create( status='Completed') cancelled_status, created = CreditTradeStatus.objects.get_or_create( status='Cancelled') draft_status, created = CreditTradeStatus.objects.get_or_create( status='Draft') submitted_status, created = CreditTradeStatus.objects.get_or_create( status='Submitted') credit_trade_type, created = CreditTradeType.objects.get_or_create( the_type='Sell') test_organization_1 = Organization.objects.create(name="Test 1", actions_type_id=1, status_id=1) test_organization_2 = Organization.objects.create(name="Test 2", actions_type_id=1, status_id=1) test_organization_3 = Organization.objects.create(name="Test 3", actions_type_id=1, status_id=1) # the function shouldn't see this as it's only a draft and the # initiator is not fuel_supplier # (even though the fuel supplier is the respondent) draft_credit_trade = CreditTrade.objects.create( status=draft_status, initiator=test_organization_2, respondent=test_organization_1, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # the function should see this as it's a draft from the fuel supplier draft_credit_trade_from_fuel_supplier = CreditTrade.objects.create( status=draft_status, initiator=test_organization_1, respondent=test_organization_2, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # the function shouldn't see this as it's a submitted transaction # not involving the fuel supplier submitted_credit_trade = CreditTrade.objects.create( status=submitted_status, initiator=test_organization_2, respondent=test_organization_3, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # the function should see this as it's a submitted transaction # involving the fuel supplier submitted_credit_trade_as_respondent = CreditTrade.objects.create( status=submitted_status, initiator=test_organization_2, respondent=test_organization_1, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) # the function should see this as it's completed completed_credit_trade = CreditTrade.objects.create( status=completed_status, initiator=test_organization_1, respondent=test_organization_2, type=credit_trade_type, number_of_credits=1000, fair_market_value_per_credit=1, zero_reason=None, trade_effective_date=datetime.datetime.today().strftime( '%Y-%m-%d')) credit_trades = CreditTradeService.get_organization_credit_trades( test_organization_1) self.assertNotIn(draft_credit_trade, credit_trades) self.assertIn(draft_credit_trade_from_fuel_supplier, credit_trades) self.assertNotIn(submitted_credit_trade, credit_trades) self.assertIn(submitted_credit_trade_as_respondent, credit_trades) self.assertIn(completed_credit_trade, credit_trades)
def test_review_login(self): second_test_user = self.t_data.second_user some_review = Review.objects.create(recipe=self.t_data.recipe, user=second_test_user, title="title", content="adsasdasd") client = Client() client.post('/api/user/signup/', json.dumps(test_user), content_type='applications/json') response = client.post('/api/user/signin/', json.dumps(test_user), content_type='applications/json') self.assertEqual(response.status_code, 200) response = client.get('/api/recipe/1/review/') self.assertEqual(response.status_code, 200) response = client.post('/api/recipe/1/review/', json.dumps(rev), content_type='applications/json') self.assertEqual(response.status_code, 201) wid = json.loads(response.content)['id'] response = client.post('/api/recipe/1/review/', json.dumps(test_user), content_type='applications/json') self.assertEqual(response.status_code, 400) response = client.put('/api/recipe/1/review/', json.dumps(rev), content_type='applications/json') self.assertEqual(response.status_code, 405) response = client.put(f'/api/review/{wid}/', json.dumps(rev), content_type='application/json') self.assertEqual(response.status_code, 200) response = client.put(f'/api/review/{wid}/', json.dumps(test_user), content_type='application/json') self.assertEqual(response.status_code, 400) # You can't modify other's review response = client.put(f'/api/review/{some_review.id}/', json.dumps(rev), content_type='application/json') self.assertEqual(response.status_code, 403) # There is no patch response = client.patch(f'/api/review/{wid}/', json.dumps(rev), content_type='application/json') self.assertEqual(response.status_code, 405) # Delete response = client.delete(f'/api/review/{wid}/') self.assertEqual(response.status_code, 200) # Rating response = client.put('/api/review/999999999999/reaction/', json.dumps(test_review_give_report), content_type='application/json') self.assertEqual(response.status_code, 404) response = client.put(f'/api/review/{self.t_data.review.id}/reaction/', json.dumps(test_review_give_report), content_type='application/json') response = client.put(f'/api/review/{self.t_data.review.id}/reaction/', json.dumps(test_review_give_report), content_type='application/json') self.assertEqual(response.status_code, 200) response = client.post( f'/api/review/{self.t_data.review.id}/reaction/', json.dumps(test_review_give_report), content_type='application/json') self.assertEqual(response.status_code, 405)
def test_carousel(self): """ Carousel API """ req = Client() user = ContextUnitTest.create_user() user2 = ContextUnitTest.create_user(username='******', is_staff=True) carousel = CarouselUnitTest.create_carousel() # carousel list url = reverse('unicms_api:carousels') # accessible to staff users only res = req.get(url) assert res.status_code == 403 user.is_staff = True user.is_superuser = True user.save() req.force_login(user) res = req.get(url) assert isinstance(res.json(), dict) # POST data = { 'name': 'posted name', 'description': 'posted description', 'is_active': 0 } # user hasn't permission req.force_login(user2) res = req.post(url, data=data, follow=1) assert res.status_code == 403 # user has permission req.force_login(user) res = req.post(url, data=data, follow=1) assert Carousel.objects.filter(name='posted name').first() # GET LOGS url = reverse('unicms_api:carousel-logs', kwargs={'pk': carousel.pk}) res = req.get( url, content_type='application/json', ) assert isinstance(res.json(), dict) # redis lock set ct = ContentType.objects.get_for_model(carousel) data = {'content_type_id': ct.pk, 'object_id': carousel.pk} res = req.post(url, data, content_type='application/json', follow=1) assert isinstance(res.json(), dict) # GET, patch, put, delete url = reverse('unicms_api:carousel', kwargs={'pk': carousel.pk}) # GET res = req.get( url, content_type='application/json', ) assert isinstance(res.json(), dict) # PATCH data = {'name': 'patched'} # user hasn't permission req.force_login(user2) res = req.patch(url, data, content_type='application/json', follow=1) assert res.status_code == 403 # user has permission carousel.created_by = user2 carousel.save() content_type = ContentType.objects.get_for_model(Carousel) edit_perm = Permission.objects.get(content_type=content_type, codename='change_carousel') user2.user_permissions.add(edit_perm) user2.refresh_from_db() req.force_login(user2) res = req.patch(url, data, content_type='application/json', follow=1) carousel.refresh_from_db() assert carousel.name == 'patched' # PUT carousel.created_by = None carousel.save() data = { 'name': 'carousel api-test', 'description': 'put description', 'is_active': 0 } # user hasn't permission req.force_login(user2) res = req.put(url, data, content_type='application/json') assert res.status_code == 403 # user has permission req.force_login(user) res = req.put(url, data, content_type='application/json') carousel.refresh_from_db() assert carousel.name == 'carousel api-test' assert not carousel.is_active # GET SelectField Options url = reverse('unicms_api:carousel-options') res = req.get(url) assert isinstance(res.json(), dict) url = reverse('unicms_api:carousel-option', kwargs={'pk': carousel.pk}) res = req.get(url) assert isinstance(res.json(), dict) # DELETE # user hasn't permission url = reverse('unicms_api:carousel', kwargs={'pk': carousel.pk}) req.force_login(user2) res = req.delete(url) assert res.status_code == 403 # user has permission req.force_login(user) res = req.delete(url) try: carousel.refresh_from_db() except ObjectDoesNotExist: assert True # form url = reverse('unicms_api:carousel-form') res = req.get(url) assert isinstance(res.json(), list)
class SellerViewSetTest(TestCase): def setUp(self): self.client = Client() def test_create_seller(self): plan = mommy.make('Plan') data = {'id': 1, 'cpf': '77711100077', 'name': 'Bruce', 'age': 30, 'phone': '47997001177', 'email': '*****@*****.**', 'plan': plan.id} response = self.client.post(reverse('sellgood:seller-list'), data=data, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertDictEqual(response.json(), data) def test_read_seller(self): seller = mommy.make('Seller', age=30) response = self.client.get(reverse('sellgood:seller-list'), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.json()[0]['id'], 1) self.assertEqual(response.json()[0]['age'], 30) def test_update_seller(self): seller = mommy.make('Seller') data = {'id': 1, 'cpf': '77711100077', 'name': 'Bruce', 'age': 30, 'phone': '47997001177', 'email': '*****@*****.**', 'plan': seller.plan.id} response = self.client.put(reverse('sellgood:seller-detail', kwargs={'pk': seller.id}), data=data, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertDictEqual(response.json(), data) def test_partially_update_seller(self): seller = mommy.make('Seller') data = {'id': 1, 'age': 40} response = self.client.patch(reverse('sellgood:seller-detail', kwargs={'pk': seller.id}), data=data, content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.json()['age'], 40) def test_delete_seller(self): seller = mommy.make('Seller') response = self.client.delete(reverse('sellgood:seller-detail', kwargs={'pk': seller.id}), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) def test_empty_seller(self): response = self.client.get(reverse('sellgood:seller-list'), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.json()), 0) def test_number_sellers(self): mommy.make('Seller', _quantity=5) response = self.client.get(reverse('sellgood:seller-list'), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.json()), 5) def test_method_not_allowed(self): response = self.client.put(reverse('sellgood:seller-list'), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
def test_roadmap_id_progress(self): client = Client(enforce_csrf_checks=True) csrftoken = get_csrf(client) path = self.roadmap_path + "1/progress/" # 405 (except for PUT) response = client.get(path, HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 405) response = client.post(path, HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 405) response = client.delete(path, HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 405) # 401 (PUT) response = client.put(path, HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 401) # sign up -> sign in author_user = signup_signin(client, self.dump_user) csrftoken = get_csrf(client) # 404 response = client.put(path, HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 404) # create another user, and her roadmap another_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") not_my_roadmap = Roadmap.objects.create( title="roadmap title", level=1, original_author=another_user, author=another_user, ) others_path = self.roadmap_path + str(not_my_roadmap.id) + "/progress/" # 403 response = client.put(others_path, HTTP_X_CSRFTOKEN=csrftoken) self.assertEqual(response.status_code, 403) # create my roadmap (progress 1) response = client.post( self.roadmap_path, self.dump_roadmap_input, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) # change roadmap progress into 2 (in progress) # this has to be done manually after the creation process # since roadmaps are always created with progress 1 (before studying) roadmap_progress1_roadmap_id = response.json()["id"] roadmap_progress1_roadmap = Roadmap.objects.get( id=roadmap_progress1_roadmap_id) # change the 'checked' task manually # since task's 'checked' attribute is always set to False on creation # Doing this to check if all tasks are cleared on progress state transition roadmap_progress1_task = roadmap_progress1_roadmap.task_roadmap.all( )[0] roadmap_progress1_task.toggle_progress() roadmap_progress1_task.save() self.assertTrue(roadmap_progress1_task.checked) # 400 # invalid state trainsition (1->1), (1->3) response = client.put( self.roadmap_path + "{}/progress/".format(roadmap_progress1_roadmap_id), {"progress_state": 1}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 400) response = client.put( self.roadmap_path + "{}/progress/".format(roadmap_progress1_roadmap_id), {"progress_state": 3}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 400) # 200 # state trainsition: start (1->2) response = client.put( self.roadmap_path + "{}/progress/".format(roadmap_progress1_roadmap_id), {"progress_state": 2}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 200) self.assertEqual(response.json()["progress_state"], 2) # every task's 'checked state should be cleared roadmap_progress1_roadmap = Roadmap.objects.get( id=roadmap_progress1_roadmap_id) for task in roadmap_progress1_roadmap.task_roadmap.all(): self.assertFalse(task.checked) # create my roadmap (progress 2) dump_roadmap_progress2 = { "private": False, "imageId": 1, "title": "swpp", "level": 1, "description": "test-description", "sections": [ { "section_title": "design pattern", "tasks": [ { "task_title": "proxy", "task_url": "www.proxy.com", "task_type": 3, "task_description": "proxy hoxy proxy", }, ], }, ], "tags": ["python", "CV"], } response = client.post( self.roadmap_path, dump_roadmap_progress2, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) # change roadmap progress into 2 (in progress) # this has to be done manually after the creation process # since roadmaps are always created with progress 1 (before studying) roadmap_progress2_roadmap_id = response.json()["id"] roadmap_progress2_roadmap = Roadmap.objects.get( id=roadmap_progress2_roadmap_id) roadmap_progress2_roadmap.progress = 2 roadmap_progress2_roadmap.save() # 400 # invalid state transition (2 -> 2) response = client.put( self.roadmap_path + "{}/progress/".format(str(roadmap_progress2_roadmap_id)), {"progress_state": 2}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 400) # 200 # progress state transition (2 -> 3) response = client.put( self.roadmap_path + "{}/progress/".format(str(roadmap_progress2_roadmap_id)), {"progress_state": 3}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 200) self.assertEqual(response.json()["progress_state"], 3) # create my roadmap (progress 3) dump_roadmap_progress3 = { "private": False, "imageId": 1, "title": "swpp", "level": 1, "description": "test-description", "sections": [ { "section_title": "design pattern", "tasks": [ { "task_title": "proxy", "task_url": "www.proxy.com", "task_type": 3, "task_description": "proxy hoxy proxy", }, ], }, ], "tags": ["python", "CV"], } response = client.post( self.roadmap_path, dump_roadmap_progress3, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) # change roadmap progress into 3 (in progress) # this has to be done manually after the creation process # since roadmaps are always created with progress 1 (before studying) roadmap_progress3_roadmap_id = response.json()["id"] roadmap_progress3_roadmap = Roadmap.objects.get( id=roadmap_progress3_roadmap_id) roadmap_progress3_roadmap.progress = 3 roadmap_progress3_roadmap.save() # 400 # invalid state transition (3 -> 2) response = client.put( self.roadmap_path + "{}/progress/".format(str(roadmap_progress3_roadmap_id)), {"progress_state": 2}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 400) # 200 # progress state transition (3 -> 1) response = client.put( self.roadmap_path + "{}/progress/".format(str(roadmap_progress3_roadmap_id)), {"progress_state": 1}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 200) self.assertEqual(response.json()["progress_state"], 1) # 400 # progress state transition into an invalid state (any state except 1,2,3) response = client.put( self.roadmap_path + "{}/progress/".format(str(roadmap_progress2_roadmap_id)), {"progress_state": 4}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 400) # 400 # request body is invalid response = client.put( self.roadmap_path + "{}/progress/".format(str(roadmap_progress2_roadmap_id)), {"progress": 1}, content_type=JSON_TYPE, HTTP_X_CSRFTOKEN=csrftoken, ) self.assertEqual(response.status_code, 400)