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)
