def test_post_delete(self):
client = RequestsClient()
response = client.delete('http://127.0.0.1:8000/api/posts/1')
response = client.delete('http://127.0.0.1:8000/api/posts/1')
self.assertEqual(response.status_code, 404)
class RuleTestCase(APITestCase):
def setUp(self):
self.client = RequestsClient()
def test_framework_works(self):
self.assertEqual(1, 1)
def test_list_api_needs_userid(self):
response = self.client.get("http://testserver/api/rules")
self.assertEqual(response.status_code, 400)
def test_can_get_after_create(self):
body = {
"name": "Rent",
"rrule": str(rrule(freq=MONTHLY, byweekday=1)),
"value": -1000
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 201)
rule_id = response.json()['id']
response = self.client.get(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"})
self.assertEqual(response.status_code, 200)
res_json = response.json()
self.assertEqual(res_json["name"], body["name"])
self.assertEqual(res_json["rrule"], body["rrule"])
self.assertEqual(res_json["value"], body["value"])
self.assertEqual(res_json["id"], rule_id)
self.assertEqual(res_json["userid"], "testuser")
# Is rule_id in list of rules?
response = self.client.get("http://testserver/api/rules",
params={"userid": "testuser"})
res_json = response.json()
rule_ids = list(map(lambda r: r["id"], res_json["data"]))
self.assertEqual(response.status_code, 200)
self.assertIn(rule_id, rule_ids)
def test_delete(self):
body = {
"name": "Rent",
"rrule": str(rrule(freq=MONTHLY, byweekday=1)),
"value": -1000
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 201)
rule_id = response.json()['id']
# Ensure it's there
response = self.client.get(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"})
self.assertEqual(response.status_code, 200)
# Remove it
response = self.client.delete(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"})
self.assertEqual(response.status_code, 204)
# Ensure it is removed
response = self.client.get(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"})
self.assertEqual(response.status_code, 404)
# Assert non-existing rules give 404 when delete attempted
response = self.client.delete(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"})
self.assertEqual(response.status_code, 404)
def test_update(self):
body = {
"name": "Rent",
"rrule": str(rrule(freq=MONTHLY, byweekday=1)),
"value": -1000
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 201)
rule_id = response.json()['id']
# Update the value
body = {
"name": "Rent",
"rrule": str(rrule(freq=MONTHLY, byweekday=1)),
"value": -1200
}
response = self.client.put(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 200)
# Ensure change is saved
response = self.client.get(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"})
self.assertEqual(response.status_code, 200)
res_json = response.json()
self.assertEqual(res_json["name"], body["name"])
self.assertEqual(res_json["rrule"], body["rrule"])
self.assertEqual(res_json["value"], body["value"])
self.assertEqual(res_json["userid"], "testuser")
self.assertIn("id", res_json)
def test_no_partial_update(self):
body = {
"name": "Rent",
"rrule": str(rrule(freq=MONTHLY, byweekday=1)),
"value": -1000
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 201)
rule_id = response.json()['id']
body = {"name": "Rent"}
response = self.client.put(f"http://testserver/api/rules/{rule_id}",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 400)
def test_400_when_ridiculously_large_value_is_used(self):
body = {
"name": "Paycheck",
"rrule": str(rrule(freq=WEEKLY, byweekday=1)),
"value": 99999999999999999999999999999999999
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 400)
def test_400_when_ridiculously_large_name_is_used(self):
letters = string.ascii_lowercase
name = ''.join(
random.choice(letters) for i in range(NAME_MAX_LENGTH + 1))
body = {
"name": name,
"rrule": str(rrule(freq=WEEKLY, byweekday=1)),
"value": 100
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 400)
def test_rrule_validation_failure(self):
body = {"name": "Paycheck", "rrule": 'invalid rrule', "value": 2000}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 400)
def test_missing_userid_parm(self):
now = date.today()
endDate = now + relativedelta(days=1)
response = self.client.get("http://testserver/api/transactions",
params={
"currentBalance": "0",
"endDate": endDate.strftime("%Y-%m-%d")
})
self.assertEqual(response.status_code, 400)
def test_valid_start_date(self):
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "testuser",
"currentBalance": "0",
"startDate": "2020-13-1",
"endDate": "2021-1-1"
})
self.assertEqual(response.status_code, 400)
def test_valid_end_date(self):
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "testuser",
"currentBalance": "0",
"startDate": "2020-1-1",
"endDate": "2021-13-1"
})
self.assertEqual(response.status_code, 400)
def test_start_date_preceeds_end_date(self):
now = date.today()
endDate = now - relativedelta(days=1)
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "testuser",
"currentBalance": "0",
"startDate": now.strftime("%Y-%m-%d"),
"endDate": endDate.strftime("%Y-%m-%d")
})
self.assertEqual(response.status_code, 400)
def test_max_span(self):
now = date.today()
startDate = now
endDate = now + relativedelta(years=30, days=2)
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "testuser",
"currentBalance": "0",
"startDate":
startDate.strftime("%Y-%m-%d"),
"endDate": endDate.strftime("%Y-%m-%d")
})
self.assertEqual(response.status_code, 400)
def test_up_to_max_span(self):
now = date.today()
endDate = now + relativedelta(years=30, days=1)
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "testuser",
"currentBalance": "0",
"startDate": now.strftime("%Y-%m-%d"),
"endDate": endDate.strftime("%Y-%m-%d")
})
self.assertEqual(response.status_code, 200)
def test_no_transactions_when_no_rules_exist_for_user(self):
now = date.today()
endDate = now + relativedelta(years=3)
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "fakeuser",
"currentBalance": "0",
"startDate": now.strftime("%Y-%m-%d"),
"endDate": endDate.strftime("%Y-%m-%d")
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()["transactions"], [])
def test_transactions_when_rules_exist(self):
# Create a rule
body = {
"name": "Rent",
"rrule": str(rrule(freq=MONTHLY, byweekday=1)),
"value": -1000
}
response = self.client.post("http://testserver/api/rules",
params={"userid": "testuser"},
json=body)
self.assertEqual(response.status_code, 201)
# Check transactions
now = date.today()
endDate = now + relativedelta(years=3)
response = self.client.get("http://testserver/api/transactions",
params={
"userid": "testuser",
"currentBalance": "0",
"startDate": now.strftime("%Y-%m-%d"),
"endDate": endDate.strftime("%Y-%m-%d")
})
self.assertEqual(response.status_code, 200)
self.assertGreater(len(response.json()["transactions"]), 0)
class TestRooms(APITestCase):
def setUp(self):
self.client = RequestsClient()
# Create 2 customer and 2 room manager users
self.user1 = User.objects.create(username='******', password='******',
is_room_manager=True)
self.user2 = User.objects.create(username='******', password='******',
is_customer=True)
self.user3 = User.objects.create(username='******', password='******',
is_customer=True)
self.user4 = User.objects.create(username='******', password='******',
is_customer=True)
# Generate tokens for the users
self.token1 = Token.objects.create(user=self.user1)
self.token2 = Token.objects.create(user=self.user2)
self.token3 = Token.objects.create(user=self.user3)
self.token4 = Token.objects.create(user=self.user4)
# Create room objects
Room.objects.create(name="Sample Room1", num_days_in_adv=2, owner=self.user1)
Room.objects.create(name="Sample Room2", num_days_in_adv=7, owner=self.user3)
# Call create room without authentication
def test_rooms_create_as_customer(self):
response = self.client.post('http://localhost:8000/api/rooms', {"name": "SampleRoom", "num_days_in_adv": 3})
self.assertEquals(response.status_code, 401 or 403)
self.assertEquals(Room.objects.all().count(), 2)
# Call create as customer user
def test_rooms_create_without_auth(self):
response = self.client.post('http://localhost:8000/api/rooms', {"name": "SampleRoom", "num_days_in_adv": 3},
headers={"Authorization": "token " + str(self.token2)})
self.assertEquals(response.status_code, 403)
self.assertEquals(Room.objects.all().count(), 2)
# Call create room with incomplete input fields
def test_rooms_create_incomplete_input(self):
response = self.client.post('http://localhost:8000/api/rooms', {"name": "SampleRoom"},
headers={"Authorization": "token " + str(self.token1)})
self.assertEquals(response.status_code, 400)
self.assertEquals(Room.objects.all().count(), 2)
# Call create room with right all fields and authentication
def test_rooms_create(self):
response = self.client.post('http://localhost:8000/api/rooms', {"name": "SampleRoom", "num_days_in_adv": 3},
headers={"Authorization": "token " + str(self.token1)})
self.assertEquals(response.status_code, 201)
self.assertEquals(Room.objects.all().count(), 3)
# Call get rooms without authentication
def test_rooms_get_without_auth(self):
response = self.client.get('http://localhost:8000/api/rooms')
self.assertEquals(response.status_code, 401)
# Call get rooms as customer
def test_rooms_get_as_customer(self):
response = self.client.get('http://localhost:8000/api/rooms',
headers={"Authorization": "token " + str(self.token2)})
self.assertEquals(response.status_code, 200)
self.assertEquals(len(response.json()), 2)
# Call get rooms as room manager
def test_rooms_get_as_room_manager(self):
response = self.client.get('http://localhost:8000/api/rooms',
headers={"Authorization": "token " + str(self.token1)})
self.assertEquals(response.status_code, 200)
self.assertEquals(len(response.json()), 1) # Gets only the room he owns
# Call retrieve specific room without authentication
def test_rooms_retrieve_without_auth(self):
response = self.client.get('http://localhost:8000/api/rooms/1')
self.assertEquals(response.status_code, 401)
# Call retrieve specific room as customer
def test_rooms_retrieve_as_customer(self):
response = self.client.get('http://localhost:8000/api/rooms/1',
headers={"Authorization": "token " + str(self.token2)})
self.assertEquals(response.status_code, 403)
# Call retrieve specific room as other room manager (not the owner)
def test_rooms_retrieve_as_not_owner(self):
response = self.client.get('http://localhost:8000/api/rooms/1',
headers={"Authorization": "token " + str(self.token3)})
self.assertEquals(response.status_code, 403)
# Call retrieve specific room as the owner
def test_rooms_retrieve_as_owner(self):
response = self.client.get('http://localhost:8000/api/rooms/1',
headers={"Authorization": "token " + str(self.token1)})
self.assertEquals(response.status_code, 200)
# Call update (patch) specific room without authentication
def test_rooms_update_without_auth(self):
response = self.client.patch('http://localhost:8000/api/rooms/1',
{"name": "Other Room"})
self.assertEquals(response.status_code, 401)
# Call update (patch) specific room as customer
def test_rooms_update_as_customer(self):
response = self.client.patch('http://localhost:8000/api/rooms/1',
{"name": "Other Room"},
headers={"Authorization": "token " + str(self.token2)})
self.assertEquals(response.status_code, 403)
# Call update (patch) specific room as other room manager (not the owner)
def test_rooms_update_as_not_owner(self):
response = self.client.patch('http://localhost:8000/api/rooms/1',
{"name": "Other Room"},
headers={"Authorization": "token " + str(self.token3)})
self.assertEquals(response.status_code, 403)
# Call update (patch) specific room as the owner
def test_rooms_update_as_owner(self):
response = self.client.patch('http://localhost:8000/api/rooms/1',
{"name": "Other Room"},
headers={"Authorization": "token " + str(self.token1)})
self.assertEquals(response.status_code, 200)
# Call delete specific room without authentication
def test_rooms_delete_without_auth(self):
response = self.client.delete('http://localhost:8000/api/rooms/1')
self.assertEquals(response.status_code, 401)
self.assertEquals(Room.objects.all().count(), 2)
# Call delete specific room as customer
def test_rooms_delete_as_customer(self):
response = self.client.delete('http://localhost:8000/api/rooms/1',
headers={"Authorization": "token " + str(self.token2)})
self.assertEquals(response.status_code, 403)
self.assertEquals(Room.objects.all().count(), 2)
# Call delete specific room as other room manager (not the owner)
def test_rooms_delete_as_not_owner(self):
response = self.client.delete('http://localhost:8000/api/rooms/1',
headers={"Authorization": "token " + str(self.token3)})
self.assertEquals(response.status_code, 403)
self.assertEquals(Room.objects.all().count(), 2)
# Call delete specific room as the owner
def test_rooms_delete_as_owner(self):
response = self.client.delete('http://localhost:8000/api/rooms/1',
headers={"Authorization": "token " + str(self.token1)})
self.assertEquals(response.status_code, 204)
self.assertEquals(Room.objects.all().count(), 1)
class TrainUnitSerializerTest(APITestCase):
"""
Tests the functionality of the TrainUnitSerializer.
"""
fixtures = ['fix.json']
def setUp(self):
self.c = RequestsClient()
self.pre_http = "http://127.0.0.1:8000"
self.rfid_tag = UserTrackingProfile.objects.all(
)[0].user_profile.rfid_tag
self.user = UserTrackingProfile.objects.all()[0].user_profile.user
self.active_set = UserTrackingProfile.objects.all()[0].active_set
self.header = {'Authorization': 'Token ' + str(self.user.auth_token)}
def test_trainunit_retrieval(self):
"""
Test whether list-interface works properly.
"""
response = self.c.get(self.pre_http + reverse('trainunit_list'),
headers=self.header)
self.assertEqual(response.status_code, 200)
def test_trainunit_retrieval_by_user(self):
"""
Tests whether TrainUnits for a specific user can be retrieved.
"""
response = self.c.get(
self.pre_http +
reverse('trainunit_user_list', kwargs={'user': self.user.id}),
headers=self.header)
content = (json.loads(response.content.decode("utf-8")))
self.assertEqual(response.status_code, 200)
def test_trainunit_delete(self):
"""
When a TrainUnit is deleted, all corresponding exerciseunits and sets must be deleted, too.
"""
# get reference on a trainunit
test_unit = TrainUnit.objects.all()[1]
test_id = test_unit.id
# get count of all exerciseunits of the trainunit
exerciseunit_count_before = len(
ExerciseUnit.objects.filter(train_unit=test_unit))
self.assertNotEqual(exerciseunit_count_before, 0)
# get count of all sets of the trainunit
set_count_before = 0
for exercise_unit in ExerciseUnit.objects.filter(train_unit=test_unit):
set_count_before += len(
Set.objects.filter(exercise_unit=exercise_unit))
self.assertNotEqual(set_count_before, 0)
# delete trainunit
response = self.c.delete(
self.pre_http +
reverse('trainunit_detail', kwargs={'pk': test_unit.id}),
headers=self.header)
# check whether exerciseunit and its sets were deleted
exerciseunit_count_after = len(
ExerciseUnit.objects.filter(train_unit=test_unit))
self.assertEqual(exerciseunit_count_after, 0)
self.assertEqual(len(TrainUnit.objects.filter(id=test_id)), 0)
class ExampleTest(TestCase):
def setUp(self):
self.client = RequestsClient()
def test_example(self):
INPUT_USERS = [
{
'name' : 'João da Silva',
'cpf' : '12345678900',
'birthday' : '1980-08-05',
},
{
'name' : 'Luke Skywalker',
'cpf' : '12345678901',
'birthday' : '1975-05-10',
},
]
INPUT_SALARIES = [
{
'date' : '2020-12-17',
'cpf' : '12345678900',
'salary' : '2000.00',
'discount' : '2.00',
},
{
'date' : '2020-12-17',
'cpf' : '12345678900',
'salary' : '5000.00',
'discount' : '4.00',
},
{
'date' : '2020-12-17',
'cpf' : '12345678901',
'salary' : '500.00',
'discount' : '4.00',
},
{
'date' : '2020-12-17',
'cpf' : '12345678901',
'salary' : '300.00',
'discount' : '8.00',
},
{
'date' : '2020-12-17',
'cpf' : '12345678901',
'salary' : '45678.00',
'discount' : '22.71',
},
]
EXPECTED_USERS_OUTPUT = [
{
'pk' : 1,
'name' : 'João da Silva Sauro',
'cpf' : '12345678900',
'birthday' : '1980-08-05',
'average_salary' : 3000.00,
'average_discounts' : 3.00,
'bigger_salary' : 4000,
'smaller_salary' : 2000,
},
{
'pk' : 2,
'name' : 'Luke Skywalker',
'cpf' : '12345678901',
'birthday' : '1975-05-10',
'average_salary' : 400.00,
'average_discounts' : 6.00,
'bigger_salary' : 500,
'smaller_salary' : 300,
},
]
EXPECTED_SALARIES_OUTPUT = [
{
'pk' : 1,
'date' : '2020-12-17',
'cpf' : '12345678900',
'salary' : '2000.00',
'discount' : '2.00',
},
{
'pk' : 2,
'date' : '2020-12-17',
'cpf' : '12345678900',
'salary' : '4000.00',
'discount' : '4.00',
},
{
'pk' : 3,
'date' : '2020-12-17',
'cpf' : '12345678901',
'salary' : '500.00',
'discount' : '4.00',
},
{
'pk' : 4,
'date' : '2020-12-17',
'cpf' : '12345678901',
'salary' : '300.00',
'discount' : '8.00',
},
]
EXPECTED_GLOBAL_OUTPUT = {
'average_salary' : 1700.00,
'average_discount' : 4.50,
'bigger_salary' : 4000.00,
'smaller_salary' : 300,
}
URL = 'http://testserver/'
for data in INPUT_USERS:
self.client.post(URL + 'users/', data)
for data in INPUT_SALARIES:
self.client.post(URL + 'salaries/', data)
self.client.patch(URL + 'users/1/', {'name':'João da Silva Sauro'})
self.client.patch(URL + 'salaries/2/', {'salary' : '4000.00'})
self.client.delete(URL + 'salaries/5/')
response = self.client.get(URL + 'users/')
assert response.json() == EXPECTED_USERS_OUTPUT
response = self.client.get(URL + 'salaries/')
assert response.json() == EXPECTED_SALARIES_OUTPUT
response = self.client.get(URL + 'global/')
assert response.json() == EXPECTED_GLOBAL_OUTPUT
class CRUDTests(TestCase):
def setUp(self):
self.client = RequestsClient()
def test_user(self):
INPUT_DATA = [
{
'name':'André Fernandes',
'cpf':'12345678902',
'birthday':'2000-01-01'
},
{
'name':'João da Silva',
'cpf':'12345678900',
'birthday':'1980-08-05'
},
{
'name':'Luke Skywalker',
'cpf':'12345678901',
'birthday':'1975-05-10',
},
]
PATCH_DATA = {'name':'João da Silva Sauro'}
PUT_DATA = {
'name':'Lucas Andarilho do Céu',
'cpf':'12345678910',
'birthday':'1976-06-11',
}
EXPECTED_OUTPUT = [
{
'pk':1,
'name':'João da Silva Sauro',
'cpf':'12345678900',
'birthday':'1980-08-05',
'average_salary':0,
'average_discounts':0,
'bigger_salary':0,
'smaller_salary':0,
},
{
'pk':2,
'name':'Lucas Andarilho do Céu',
'cpf':'12345678910',
'birthday':'1976-06-11',
'average_salary':0,
'average_discounts':0,
'bigger_salary':0,
'smaller_salary':0,
},
]
URL = 'http://testserver/'
for i, data in enumerate(INPUT_DATA):
self.client.post(URL + f'users/{i}/', data)
self.client.patch(URL + 'users/1/', PATCH_DATA)
self.client.put(URL + 'users/2/', PUT_DATA)
self.client.delete(URL + 'users/0/')
response = self.client.get(URL + 'users/1/')
assert response.json() == EXPECTED_OUTPUT[0]
response = self.client.get(URL + 'users/2/')
assert response.json() == EXPECTED_OUTPUT[1]
response = self.client.post(URL + 'users/1/', INPUT_DATA[0])
assert response.status_code == 409
response = self.client.get(URL + 'users/0/')
assert response.status_code == 404
def test_salary(self):
INPUT_DATA = [
{
'date' : '2020-12-17',
'cpf' : '12345678900',
'salary' : '2000.00',
'discount' : '2.00',
},
{
'date' : '2019-11-01',
'cpf' : '12345678908',
'salary' : '509.00',
'discount' : '4.00',
},
{
'date' : '2020-12-17',
'cpf' : '98765432100',
'salary' : '98000.00',
'discount' : '1.00',
},
]
PATCH_DATA = {'date':'2020-09-16'}
PUT_DATA = {
'date' : '2012-11-01',
'cpf' : '12345678988',
'salary' : '220.00',
'discount' : '3.00',
}
EXPECTED_OUTPUT = [
{
'pk' : 0,
'date' : '2020-09-16',
'cpf' : '12345678900',
'salary' : '2000.00',
'discount' : '2.00',
},
{
'pk' : 2,
'date' : '2012-11-01',
'cpf' : '12345678988',
'salary' : '220.00',
'discount' : '3.00',
},
]
URL = 'http://testserver/'
for i, data in enumerate(INPUT_DATA):
self.client.post(URL + f'salaries/{i}/', data)
self.client.patch(URL + 'salaries/0/', PATCH_DATA)
self.client.put(URL + 'salaries/2/', PUT_DATA)
self.client.delete(URL + 'salaries/1/')
response = self.client.get(URL + 'salaries/0/')
assert response.json() == EXPECTED_OUTPUT[0]
response = self.client.get(URL + 'salaries/2/')
assert response.json() == EXPECTED_OUTPUT[1]
response = self.client.post(URL + 'salaries/0/', INPUT_DATA[0])
assert response.status_code == 409
response = self.client.get(URL + 'salaries/1/')
assert response.status_code == 404
class SCTFUserAPITest(TestCase):
@classmethod
def setUpClass(self):
self.client = RequestsClient()
self.u = SCTFUser.objects.create(username="******")
self.u.set_password("TestPassword")
self.u.is_verified = True
self.u.save()
resp = self.client.post(baseURL + "auth/login",
data={
"username": "******",
"password": "******"
})
if resp.status_code != 200:
raise Exception('Failed to authenticate user with status: ' +
str(resp.status_code))
data = json.loads(resp.content)
print(data["token"])
self.token = f"Token {data['token']}"
@classmethod
def tearDownClass(self):
self.u.delete()
def test_anonymous_create_user(self):
resp = self.client.post(apiURL + "users/",
data={
"username": "******",
"password": "******"
})
self.assertEqual(resp.status_code, 201)
data = json.loads(resp.content)
self.assertTrue(SCTFUser.objects.filter(pk=data["id"]).exists())
def test_anonymous_endpoint_access_get(self):
self.assertEqual(self.client.get(apiURL + "users/").status_code, 401)
def test_anonymous_endpoint_access_put(self):
self.assertEqual(
self.client.put(apiURL + f"users/{self.u.id}/",
data={
"username": "******",
"password": "******"
}).status_code, 401)
def test_anonymous_endpoint_access_delete(self):
self.assertEqual(
self.client.delete(apiURL + f"users/{self.u.id}/").status_code,
401)
def test_anonymous_login(self):
resp = self.client.post(baseURL + "auth/login",
data={
"username": "******",
"password": "******"
})
self.assertEqual(resp.status_code, 200)
def test_correct_user_get(self):
self.client.headers.update({'Authorization': self.token})
resp = self.client.get(apiURL + f"users/{self.u.id}/")
self.assertEqual(resp.status_code, 200)
d = json.loads(data.content)
self.assertEqual(d["username"], u.username)
self.assertEqual(d["first_name"], u.first_name)
self.assertEqual(d["last_name"], u.last_name)
self.assertEqual(d["display_name"], u.display_name)
class CashApiTestCase(TestCase):
def setUp(self):
with open("./resources/tests/cfg/test_cash_data.config",
"r") as cash_cfg:
test_data = cash_cfg.read()
self.investor_test = InvestorUser.objects.create_user(
username='******', password='******')
self.cash_test_data = json.loads(test_data)
self.cash_test_data_1 = self.cash_test_data.get('cash_record_1')
self.cash_test_data_2 = self.cash_test_data.get('cash_record_2')
self.cash_test_obj_1 = Cash.objects.create(owner=self.investor_test,
**self.cash_test_data_1)
self.cash_test_obj_2 = Cash.objects.create(owner=self.investor_test,
**self.cash_test_data_2)
self.client = RequestsClient()
response = self.client.post('http://127.0.0.1:8000/api/v1/auth/token',
json={
'username': '******',
'password': '******'
})
content = json.loads(response.content.decode('utf-8'))
self.token = content.get('token')
def test_len_get_cash_list(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/cash',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertEqual(len(self.cash_test_data), len(response_content))
def test_content_get_cash_list(self):
reference_data = []
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/cash',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
for item in self.cash_test_data.values():
item['my_cash'] = item['my_cash'] + '.00'
if item['my_cash_currency'] == self.investor_test.my_currency:
item['my_currency'] = self.investor_test.my_currency
del item['my_cash_currency']
item['save_date'] = item['save_date'][:item['save_date'].index(
' ')] + 'T' + item['save_date'][item['save_date'].index(' ') +
1:] + 'Z'
reference_data.append(item)
response_content.sort(key=lambda d: Decimal(d['my_cash']))
reference_data.sort(key=lambda d: Decimal(d['my_cash']))
response_js = json.dumps(response_content, sort_keys=True)
reference_js = json.dumps(reference_data, sort_keys=True)
self.assertEqual(response_js, reference_js)
def test_sum_content_get_cash(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/cash?sum=true',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
cash_sum = str(
int(self.cash_test_data_1.get('my_cash')) +
int(self.cash_test_data_2.get('my_cash')))
self.assertEqual(response_content[0]['total_cash'], cash_sum)
def test_incorrect_query_get_cash_list(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/cash?sum=abcd',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertTrue(not response_content)
def test_create_cash(self):
response = self.client.post(
'http://127.0.0.1:8000/api/v1/resources/cash',
json={
'my_cash': '1234',
'my_currency': 'PLN',
'save_date': '2019-11-26T11:00:30Z'
},
headers={'Authorization': 'JWT %s' % self.token})
g = Cash.objects.filter(my_cash='1234').first()
self.assertEqual(response.status_code, 201)
self.assertEqual(g.my_cash_currency, 'PLN')
self.assertEqual(g.my_cash.amount, 1234.00)
self.assertEqual(g.save_date.strftime('%Y-%m-%d, %H:%M:%S'),
'2019-11-26, 11:00:30')
def test_cash_delete(self):
pk = self.cash_test_obj_1.pk
response = self.client.delete(
'http://127.0.0.1:8000/api/v1/resources/cash/%s' % pk,
headers={'Authorization': 'JWT %s' % self.token})
try:
Cash.objects.get(save_date=self.cash_test_obj_1.save_date)
except Cash.DoesNotExist:
object_status = 404
self.assertEquals(response.status_code, 204)
self.assertEquals(object_status, 404)
class CurrencyApiTestCase(TestCase):
def setUp(self):
with open("./resources/tests/cfg/test_currency_data.config",
"r") as currency_cfg:
test_data = currency_cfg.read()
self.investor_test = InvestorUser.objects.create_user(
username='******', password='******')
self.currency_test_data = json.loads(test_data)
self.usd_test_data_1 = self.currency_test_data.get('usd_record_1')
self.usd_test_data_2 = self.currency_test_data.get('usd_record_2')
self.eur_test_data_1 = self.currency_test_data.get('eur_record_1')
self.eur_test_data_2 = self.currency_test_data.get('eur_record_2')
self.chf_test_data_1 = self.currency_test_data.get('chf_record_1')
self.chf_test_data_2 = self.currency_test_data.get('chf_record_2')
self.usd_test_obj_1 = Currency.objects.create(owner=self.investor_test,
**self.usd_test_data_1)
self.usd_test_obj_2 = Currency.objects.create(owner=self.investor_test,
**self.usd_test_data_2)
self.eur_test_obj_1 = Currency.objects.create(owner=self.investor_test,
**self.eur_test_data_1)
self.eur_test_obj_2 = Currency.objects.create(owner=self.investor_test,
**self.eur_test_data_2)
self.chf_test_obj_1 = Currency.objects.create(owner=self.investor_test,
**self.chf_test_data_1)
self.chf_test_obj_2 = Currency.objects.create(owner=self.investor_test,
**self.chf_test_data_2)
self.client = RequestsClient()
response = self.client.post('http://127.0.0.1:8000/api/v1/auth/token',
json={
'username': '******',
'password': '******'
})
content = json.loads(response.content.decode('utf-8'))
self.token = content.get('token')
def test_len_get_currency_list(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertEqual(len(self.currency_test_data), len(response_content))
def test_content_get_currency_list(self):
reference_data = []
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
for item in self.currency_test_data.values():
item['currency'] = item['bought_currency_currency']
del item['bought_currency_currency']
del item['bought_price_currency']
item['bought_currency'] = item['bought_currency'] + '.00'
item['bought_price'] = item['bought_price'] + '.00'
item['date_of_bought'] = item['date_of_bought'][:item[
'date_of_bought'].index(' ')] + 'T' + item['date_of_bought'][
item['date_of_bought'].index(' ') + 1:] + 'Z'
reference_data.append(item)
response_content.sort(key=lambda d: Decimal(d['bought_currency']))
reference_data.sort(key=lambda d: Decimal(d['bought_currency']))
response_js = json.dumps(response_content, sort_keys=True)
reference_js = json.dumps(reference_data, sort_keys=True)
self.assertEqual(response_js, reference_js)
def test_len_get_currency_list_usd(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=usd',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertEqual(2, len(response_content))
def test_content_get_currency_list_usd(self):
qs = Currency.objects.filter(bought_currency_currency='USD')
self.assertEqual(qs[0].bought_currency_currency, 'USD')
self.assertEqual(qs[1].bought_currency_currency, 'USD')
def test_len_get_currency_list_eur(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=eur',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertEqual(2, len(response_content))
def test_content_get_currency_list_eur(self):
qs = Currency.objects.filter(bought_currency_currency='EUR')
self.assertEqual(qs[0].bought_currency_currency, 'EUR')
self.assertEqual(qs[1].bought_currency_currency, 'EUR')
def test_len_get_currency_list_chf(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=chf',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertEqual(2, len(response_content))
def test_content_get_currency_list_chf(self):
qs = Currency.objects.filter(bought_currency_currency='CHF')
self.assertEqual(qs[0].bought_currency_currency, 'CHF')
self.assertEqual(qs[1].bought_currency_currency, 'CHF')
def test_len_get_currency_list_pln(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=pln',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertEqual(0, len(response_content))
def test_sum_content_get_usd(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=usd&sum=true',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
currency_sum = str(
int(self.usd_test_data_1.get('bought_currency')) +
int(self.usd_test_data_2.get('bought_currency')))
self.assertEqual(response_content[0]['total_currency'], currency_sum)
def test_sum_content_get_eur(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=eur&sum=true',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
currency_sum = str(
int(self.eur_test_data_1.get('bought_currency')) +
int(self.eur_test_data_2.get('bought_currency')))
self.assertEqual(response_content[0]['total_currency'], currency_sum)
def test_sum_content_get_chf(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=chf&sum=true',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
currency_sum = str(
int(self.chf_test_data_1.get('bought_currency')) +
int(self.chf_test_data_2.get('bought_currency')))
self.assertEqual(response_content[0]['total_currency'], currency_sum)
def test_incorrect_query_get_currency_list(self):
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency?name=abcd',
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
self.assertTrue(not response_content)
def test_currency_detail(self):
usd = Currency.objects.filter(bought_currency_currency='USD')
response = self.client.get(
'http://127.0.0.1:8000/api/v1/resources/currency/{}'.format(
usd[0].id),
headers={'Authorization': 'JWT %s' % self.token})
response_content = json.loads(response.content.decode('utf-8'))
currency = response_content.get('currency')
self.assertEqual(200, response.status_code)
self.assertEqual('USD', currency)
def test_create_usd(self):
response = self.client.post(
'http://127.0.0.1:8000/api/v1/resources/currency',
json={
'bought_currency': '5000',
'bought_currency_currency': 'USD',
'bought_price': '20000',
'bought_price_currency': 'PLN',
'date_of_bought': '2019-11-26T11:00:30Z'
},
headers={'Authorization': 'JWT %s' % self.token})
g = Currency.objects.filter(bought_price='20000').first()
self.assertEqual(response.status_code, 201)
self.assertEqual(g.bought_currency_currency, 'USD')
self.assertEqual(g.bought_currency.amount, 5000.00)
self.assertEqual(g.bought_price.amount, 20000.00)
self.assertEqual(g.bought_price_currency, 'PLN')
self.assertEqual(g.date_of_bought.strftime('%Y-%m-%d, %H:%M:%S'),
'2019-11-26, 11:00:30')
def test_create_eur(self):
response = self.client.post(
'http://127.0.0.1:8000/api/v1/resources/currency',
json={
'bought_currency': '5000',
'bought_currency_currency': 'EUR',
'bought_price': '20001',
'bought_price_currency': 'PLN',
'date_of_bought': '2019-11-26T11:00:30Z'
},
headers={'Authorization': 'JWT %s' % self.token})
g = Currency.objects.filter(bought_price='20001').first()
self.assertEqual(response.status_code, 201)
self.assertEqual(g.bought_currency_currency, 'EUR')
self.assertEqual(g.bought_currency.amount, 5000.00)
self.assertEqual(g.bought_price.amount, 20001.00)
self.assertEqual(g.bought_price_currency, 'PLN')
self.assertEqual(g.date_of_bought.strftime('%Y-%m-%d, %H:%M:%S'),
'2019-11-26, 11:00:30')
def test_create_chf(self):
response = self.client.post(
'http://127.0.0.1:8000/api/v1/resources/currency',
json={
'bought_currency': '5000',
'bought_currency_currency': 'CHF',
'bought_price': '20002',
'bought_price_currency': 'PLN',
'date_of_bought': '2019-11-26T11:00:30Z'
},
headers={'Authorization': 'JWT %s' % self.token})
g = Currency.objects.filter(bought_price='20002').first()
self.assertEqual(response.status_code, 201)
self.assertEqual(g.bought_currency_currency, 'CHF')
self.assertEqual(g.bought_currency.amount, 5000.00)
self.assertEqual(g.bought_price.amount, 20002.00)
self.assertEqual(g.bought_price_currency, 'PLN')
self.assertEqual(g.date_of_bought.strftime('%Y-%m-%d, %H:%M:%S'),
'2019-11-26, 11:00:30')
def test_create_pln(self):
response = self.client.post(
'http://127.0.0.1:8000/api/v1/resources/currency',
json={
'bought_currency': '5000',
'bought_currency_currency': 'PLN',
'bought_price': '20003',
'bought_price_currency': 'PLN',
'date_of_bought': '2019-11-26T11:00:30Z'
},
headers={'Authorization': 'JWT %s' % self.token})
self.assertEqual(response.status_code, 400)
def test_usd_delete(self):
pk = self.usd_test_obj_1.pk
response = self.client.delete(
'http://127.0.0.1:8000/api/v1/resources/currency/%s' % pk,
headers={'Authorization': 'JWT %s' % self.token})
try:
Currency.objects.get(
date_of_bought=self.usd_test_obj_1.date_of_bought)
except Currency.DoesNotExist:
object_status = 404
self.assertEquals(response.status_code, 204)
self.assertEquals(object_status, 404)
def test_eur_delete(self):
pk = self.eur_test_obj_1.pk
response = self.client.delete(
'http://127.0.0.1:8000/api/v1/resources/currency/%s' % pk,
headers={'Authorization': 'JWT %s' % self.token})
try:
Currency.objects.get(
date_of_bought=self.eur_test_obj_1.date_of_bought)
except Currency.DoesNotExist:
object_status = 404
self.assertEquals(response.status_code, 204)
self.assertEquals(object_status, 404)
def test_chf_delete(self):
pk = self.chf_test_obj_1.pk
response = self.client.delete(
'http://127.0.0.1:8000/api/v1/resources/currency/%s' % pk,
headers={'Authorization': 'JWT %s' % self.token})
try:
Currency.objects.get(
date_of_bought=self.chf_test_obj_1.date_of_bought)
except Currency.DoesNotExist:
object_status = 404
self.assertEquals(response.status_code, 204)
self.assertEquals(object_status, 404)
