def test_get_bills_and_query_by_service(self, new_user):
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('House'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('House'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('House'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('Membership'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('Membership'),
user=new_user)
view = BillViewSet.as_view({'get': 'list'})
Bill.objects.count() == 5
membership_request = factory.get(
BILLS_URI + '?service=Membership',
HTTP_AUTHORIZATION=get_jwt_header(new_user.email),
)
membership_response = view(membership_request)
assert membership_response.status_code == 200
assert len(membership_response.data) == 2
for bill in membership_response.data:
assert bill.get('id')
assert bill.get('service_id')
assert bill.get('user_id') == new_user.id
house_request = factory.get(
BILLS_URI + '?service=House',
HTTP_AUTHORIZATION=get_jwt_header(new_user.email),
)
house_response = view(house_request)
assert house_response.status_code == 200
assert len(house_response.data) == 3
for bill in house_response.data:
assert bill.get('id')
assert bill.get('service_id')
assert bill.get('user_id') == new_user.id
def test_bill_update_by_good_user(self, new_user, other_bill_info):
b1 = Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance(
mixer.faker.genre()),
user=new_user)
assert b1.id
assert b1.user == new_user
view = BillViewSet.as_view({'put': 'update'})
request = factory.put(BILLS_URI,
data=json.dumps(other_bill_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
new_user.email))
response = view(request, pk=b1.id)
print(response.data)
assert response.status_code == 200
assert response.data.get('id') == b1.id
assert response.data.get('name') == other_bill_info['name']
assert response.data.get(
'description') == other_bill_info['description']
assert response.data.get('due_date') == other_bill_info['due_date']
service_id = response.data.get('service_id')
assert service_id
assert Service.objects.get(id=service_id)
def test_payment_create(self, new_payment_info, new_bill):
new_payment_info['bill_id'] = new_bill.id
view = PaymentViewSet.as_view({'post': 'create'})
request = factory.post(PAYMENTS_URI,
data=json.dumps(new_payment_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
new_bill.user.email))
response = view(request)
assert response.status_code == 201
assert response.data.get('id')
assert response.data.get('amount') == new_payment_info['amount']
assert response.data.get('due_date') == new_payment_info['due_date']
assert response.data.get('date_paid') == new_payment_info['date_paid']
assert response.data.get('status') == new_payment_info['status']
assert response.data.get(
'additional_notes') == new_payment_info['additional_notes']
assert response.data.get('bill_id') == new_bill.id
assert response.data.get('user_id') == new_bill.user.id
payment_instance = Payment.objects.get(id=response.data.get('id'))
assert payment_instance.bill == new_bill
assert payment_instance.user == new_bill.user
def test_get_bills_list(self, new_user, other_user):
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance(
mixer.faker.genre()),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance(
mixer.faker.genre()),
user=new_user)
good_list_view = BillViewSet.as_view({'get': 'list'})
good_list_request = factory.get(
BILLS_URI,
HTTP_AUTHORIZATION=get_jwt_header(new_user.email),
)
good_list_response = good_list_view(good_list_request)
assert good_list_response.status_code == 200
bills = good_list_response.data
assert len(bills) == 2
for bill in bills:
assert bill.get('id')
assert bill.get('name')
assert bill.get('description')
assert bill.get('due_date')
assert bill.get('service_id')
assert bill.get('user_id') == new_user.id
def test_user_update_other_user(self, json_user_with_details,
other_json_user_with_details):
user = User.objects.create_user(
first_name=json_user_with_details['first_name'],
last_name=json_user_with_details['last_name'],
email=json_user_with_details['email'],
country=json_user_with_details['details']['country'],
mobile_number=json_user_with_details['details']['mobile_number'],
password=json_user_with_details['password'])
other_user = User.objects.create_user(
first_name=other_json_user_with_details['first_name'],
last_name=other_json_user_with_details['last_name'],
email=other_json_user_with_details['email'],
country=other_json_user_with_details['details']['country'],
mobile_number=other_json_user_with_details['details']
['mobile_number'],
password=other_json_user_with_details['password'])
view = UserViewSet.as_view({'put': 'update'})
request = factory.put(USERS_URI,
data=json.dumps({
'email': '*****@*****.**',
'password': '******',
'details': {}
}),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
other_user.email))
response = view(request, pk=user.id)
assert response.status_code == 403
def test_view_bad_permissions(self, new_user_info):
u1 = User.objects.create_user(
first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
onui = other_new_user_info()
u2 = User.objects.create_user(first_name=onui['first_name'],
last_name=onui['last_name'],
email=onui['email'],
country=onui['country'],
mobile_number=onui['mobile_number'],
goal=onui['goal'],
password=onui['password'])
retrieve_view = UserViewSet.as_view({'get': 'retrieve'})
retrieve_request = factory.get(USERS_URI + '/{}'.format(u1.id),
HTTP_AUTHORIZATION=get_jwt_header(
onui['email'], onui['password']))
retrieve_response = retrieve_view(retrieve_request, pk=u1.id)
assert retrieve_response.status_code == 403
edited_user_info = new_user_info
edited_user_info['first_name'] = 'Jack'
put_view = UserViewSet.as_view({'put': 'update'})
put_request = factory.put(USERS_URI + '/{}'.format(u1.id),
data=json.dumps(edited_user_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
onui['email'], onui['password']))
put_response = put_view(put_request, pk=u1.id)
assert put_response.status_code == 403
delete_view = UserViewSet.as_view({'delete': 'destroy'})
delete_request = factory.get(USERS_URI + '/{}'.format(u1.id),
HTTP_AUTHORIZATION=get_jwt_header(
onui['email'], onui['password']))
delete_response = delete_view(delete_request, pk=u1.id)
assert delete_response.status_code == 405
def test_retrieve_bad(self, new_payment, other_user):
view = PaymentViewSet.as_view({'get': 'retrieve'})
request = factory.get(PAYMENTS_URI,
HTTP_AUTHORIZATION=get_jwt_header(
other_user.email))
response = view(request, pk=new_payment.id)
assert response.status_code == 403
def test_user_get_other_user(self, new_user, other_user):
view = UserViewSet.as_view({'get': 'retrieve'})
request = factory.get(USERS_URI,
HTTP_AUTHORIZATION=get_jwt_header(
new_user.email))
response = view(request, pk=other_user.id)
assert response.status_code == 403
def test_service_get_list(self, new_user):
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('House'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('House'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('Medical'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('Medical'),
user=new_user)
Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance('Medical'),
user=new_user)
view = ServiceList.as_view()
request = factory.get(SERVICES_URI,
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
new_user.email))
response = view(request)
assert response.status_code == 200
assert len(response.data) == 2
for service in response.data:
assert service.get('id')
if service.get('name') == 'Medical':
assert len(service.get('bills')) == 3
elif service.get('name') == 'House':
assert len(service.get('bills')) == 2
for bill in service.get('bills'):
assert bill.get('id')
assert bill.get('name')
assert bill.get('description')
assert bill.get('due_date')
assert bill.get('service_id') == service.get('id')
assert bill.get('user_id') == new_user.id
def test_payment_update_bad(self, new_payment, new_payment_info,
other_user):
view = PaymentViewSet.as_view({'put': 'update'})
request = factory.put(PAYMENTS_URI,
data=json.dumps(new_payment_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
other_user.email))
response = view(request, pk=new_payment.id)
assert response.status_code == 403
def test_user_get_self(self, new_user):
view = UserViewSet.as_view({'get': 'retrieve'})
request = factory.get(USERS_URI,
HTTP_AUTHORIZATION=get_jwt_header(
new_user.email))
response = view(request, pk=new_user.id)
assert response.status_code == 200
assert response.data.get('id') == new_user.id
assert response.data.get('email') == new_user.email
assert response.data.get('username') == new_user.username
def test_user_get_all_users(self, new_user):
user_list_view = UserViewSet.as_view({'get': 'list'})
unauthenticated_request = factory.get(USERS_URI)
unauthenticated_response = user_list_view(unauthenticated_request)
assert unauthenticated_response.status_code == 401
authenticated_request = factory.get(USERS_URI,
HTTP_AUTHORIZATION=get_jwt_header(
new_user.email))
authenticated_response = user_list_view(unauthenticated_request)
assert authenticated_response.status_code == 401
def test_view_list_and_retrieve_users(self, new_user_info,
json_user_no_details):
# Populate the database
new_user = User.objects.create_user(
first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
# Create another user via posting data
post_view = UserViewSet.as_view({'post': 'create'})
post_request = factory.post(USERS_URI,
data=json.dumps(json_user_no_details),
content_type='application/json')
post_response = post_view(post_request)
# Assert it was created
assert post_response.status_code == 201
assert post_response.data.get('id')
assert post_response.data.get('email') == json_user_no_details['email']
assert post_response.data.get('details')
# FIX WHEN USERS GROUPS AND PERMISSIONS ADDED
# # List all users and make sure there are 2, one populated by the db and one from posted data
# get_view = UserViewSet.as_view({'get': 'list'})
# get_request = factory.get(USERS_URI)
# get_response = get_view(get_request)
# assert get_response.status_code == 200
# assert len(get_response.data) == 2
# # Make sure they are users with id's and the same emails
# assert get_response.data[0].get('id')
# assert get_response.data[0].get('email') == new_user_info['email']
# assert get_response.data[1].get('id')
# assert get_response.data[1].get('email') == json_user_no_details['email']
# Retrieve the user populated from teh database
retrieve_view = UserViewSet.as_view({'get': 'retrieve'})
retrieve_request = factory.get(USERS_URI + '/{}'.format(new_user.id),
HTTP_AUTHORIZATION=get_jwt_header(
new_user_info['email'],
new_user_info['password']))
retrieve_response = retrieve_view(retrieve_request, pk=new_user.id)
assert retrieve_response.status_code == 200
assert retrieve_response.data.get('id') == new_user.id
assert retrieve_response.data.get('email') == new_user.email
def test_retrieve_bill(self, new_bill, other_user):
view = BillViewSet.as_view({'get': 'retrieve'})
good_request = factory.get(
BILLS_URI,
HTTP_AUTHORIZATION=get_jwt_header(new_bill.user.email),
)
good_response = view(good_request, pk=new_bill.id)
assert good_response.status_code == 200
assert good_response.data.get('id') == new_bill.id
assert good_response.data.get('name') == new_bill.name
assert good_response.data.get('description') == new_bill.description
assert good_response.data.get('due_date') == new_bill.due_date
assert good_response.data.get('service_id') == new_bill.service.id
assert good_response.data.get('user_id') == new_bill.user.id
assert isinstance(good_response.data.get('payments'), list)
def test_retrieve_good(self, new_payment):
view = PaymentViewSet.as_view({'get': 'retrieve'})
request = factory.get(PAYMENTS_URI,
HTTP_AUTHORIZATION=get_jwt_header(
new_payment.user.email))
response = view(request, pk=new_payment.id)
assert response.status_code == 200
assert response.data.get('id') == new_payment.id
assert response.data.get('amount') == str(round(new_payment.amount, 2))
assert response.data.get('due_date') == new_payment.due_date
assert response.data.get('date_paid') == new_payment.date_paid
assert response.data.get('status') == new_payment.status
assert response.data.get(
'additional_notes') == new_payment.additional_notes
assert response.data.get('bill_id') == new_payment.bill.id
assert response.data.get('user_id') == new_payment.bill.user.id
def test_user_update_self(self, json_user_with_details,
other_json_user_with_details):
user = User.objects.create_user(
first_name=json_user_with_details['first_name'],
last_name=json_user_with_details['last_name'],
email=json_user_with_details['email'],
country=json_user_with_details['details']['country'],
mobile_number=json_user_with_details['details']['mobile_number'],
password=json_user_with_details['password'])
assert user.id
assert user.email == json_user_with_details['email']
assert user.username == '{}{}-{}'.format(
json_user_with_details['first_name'],
json_user_with_details['last_name'], user.id)
other_json_user_with_details['password'] = json_user_with_details[
'password']
view = UserViewSet.as_view({'put': 'update'})
request = factory.put(USERS_URI,
data=json.dumps(other_json_user_with_details),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(user.email))
response = view(request, pk=user.id)
assert response.status_code == 200
assert response.data.get('id') == user.id
assert User.objects.get(
id=response.data.get('id')) == User.objects.get(id=user.id)
assert response.data.get(
'first_name') == other_json_user_with_details['first_name']
assert response.data.get(
'last_name') == other_json_user_with_details['last_name']
assert response.data.get(
'email') == other_json_user_with_details['email']
assert response.data.get('username') == '{}{}-{}'.format(
other_json_user_with_details['first_name'],
other_json_user_with_details['last_name'], response.data.get('id'))
assert response.data.get('details', {}).get(
'country') == other_json_user_with_details['details']['country']
assert response.data.get(
'details',
{}).get('mobile_number') == other_json_user_with_details[
'details']['mobile_number']
def test_bill_post(self, new_bill_info, new_user):
view = BillViewSet.as_view({'post': 'create'})
request = factory.post(BILLS_URI,
data=json.dumps(new_bill_info),
HTTP_AUTHORIZATION=get_jwt_header(
new_user.email),
content_type='application/json')
response = view(request)
assert response.status_code == 201
assert response.data.get('id')
assert response.data.get('name') == new_bill_info['name']
assert response.data.get('description') == new_bill_info['description']
assert response.data.get('due_date') == new_bill_info['due_date']
assert response.data.get('service_id')
assert Service.objects.get(id=response.data.get('service_id'))
assert response.data.get('user_id') == new_user.id
def test_bill_update_by_bad_user(self, new_bill_info, other_bill_info,
new_user, other_user):
new_bill_instance = Bill.objects.create(
name=new_bill_info['name'],
description=new_bill_info['description'],
due_date=new_bill_info['due_date'],
service=handle_service_instance(new_bill_info['service_name']),
user=new_user)
assert new_bill_instance.id
view = BillViewSet.as_view({'put': 'update'})
request = factory.put(BILLS_URI,
data=json.dumps(other_bill_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
other_user.email))
response = view(request, pk=new_bill_instance.id)
assert response.status_code == 403
def test_payment_update_good(self, new_payment, new_payment_info):
view = PaymentViewSet.as_view({'put': 'update'})
request = factory.put(PAYMENTS_URI,
data=json.dumps(new_payment_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
new_payment.user.email))
response = view(request, pk=new_payment.id)
assert response.status_code == 200
assert response.data.get('id') == new_payment.id
assert response.data.get('bill_id') == new_payment.bill.id
assert response.data.get('user_id') == new_payment.user.id
assert response.data.get('amount') == new_payment_info['amount']
assert response.data.get('due_date') == new_payment_info['due_date']
assert response.data.get('date_paid') == new_payment_info['date_paid']
assert response.data.get('status') == new_payment_info['status']
assert response.data.get(
'additional_notes') == new_payment_info['additional_notes']
def test_get_other_bills_should_be_forbidden(self, new_user, other_user):
b1 = Bill.objects.create(name=mixer.faker.first_name(),
description=mixer.faker.text(),
due_date=randint(1, 31),
service=handle_service_instance(
mixer.faker.genre()),
user=new_user)
assert b1.id
assert b1.user == new_user
bad_retrieve_view = BillViewSet.as_view({'get': 'retrieve'})
bad_retrieve_request = factory.get(
BILLS_URI,
HTTP_AUTHORIZATION=get_jwt_header(other_user.email),
)
bad_retrieve_response = bad_retrieve_view(bad_retrieve_request,
pk=b1.id)
assert bad_retrieve_response.status_code == 403
def test_view_delete_user(self, new_user_info):
new_user = User.objects.create_user(
first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
# Delete the user with new_user.id
view = UserViewSet.as_view({'delete': 'destroy'})
request = factory.delete(USERS_URI + '/{}'.format(new_user.id),
HTTP_AUTHORIZATION=get_jwt_header(
new_user_info['email'],
new_user_info['password']))
response = view(request, pk=new_user.id)
assert response.status_code == 204
assert User.objects.filter(id=new_user.id).count() == 0
assert Details.objects.filter(user=new_user).count() == 0
def test_user_view(self, new_user_info, new_activity_info):
view = ActivityViewSet.as_view({'get': 'list'})
request = factory.get(ACTIVITIES_URI)
response = view(request)
assert response.status_code == 401
u1 = User.objects.create_user(
first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
category = handle_activity_category(
new_activity_info['category']['name'])
new_activity = Activity.objects.create(
name=new_activity_info['name'],
description=new_activity_info['description'],
start_time=new_activity_info['start_time'],
end_time=new_activity_info['end_time'],
productive=new_activity_info['productive'],
user=u1,
category=category)
view = ActivityViewSet.as_view({'get': 'list'})
request = factory.get(ACTIVITIES_URI,
HTTP_AUTHORIZATION=get_jwt_header(
new_user_info['email'],
new_user_info['password']))
response = view(request)
assert response.status_code == 200
for activity in response.data:
assert activity.get('user_details',
{}).get('email') == new_user_info['email']
def test_payment_list(self, new_bill):
Payment.objects.create(amount=mixer.faker.positive_decimal(),
due_date=mixer.faker.date(),
date_paid=mixer.faker.date(),
status=get_status(),
additional_notes=mixer.faker.text(),
bill=new_bill,
user=new_bill.user)
Payment.objects.create(amount=mixer.faker.positive_decimal(),
due_date=mixer.faker.date(),
date_paid=mixer.faker.date(),
status=get_status(),
additional_notes=mixer.faker.text(),
bill=new_bill,
user=new_bill.user)
Payment.objects.create(amount=mixer.faker.positive_decimal(),
due_date=mixer.faker.date(),
date_paid=mixer.faker.date(),
status=get_status(),
additional_notes=mixer.faker.text(),
bill=new_bill,
user=new_bill.user)
view = PaymentViewSet.as_view({'get': 'list'})
request = factory.get(PAYMENTS_URI,
HTTP_AUTHORIZATION=get_jwt_header(
new_bill.user.email))
response = view(request)
assert response.status_code == 200
assert len(response.data) == 3
for payment in response.data:
assert payment.get('id')
assert payment.get('bill_id') == new_bill.id
assert payment.get('user_id') == new_bill.user.id
def test_view_activity_permissions(self, new_user_info, new_activity_info):
# Create first user
User.objects.create_user(first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
# Make datetimes strings and create new category
new_activity_info['start_time'] = str(new_activity_info['start_time'])
new_activity_info['end_time'] = str(new_activity_info['end_time'])
new_activity_info['category']['name'] = handle_activity_category(
new_activity_info['category']['name']).name
view = ActivityViewSet.as_view({'post': 'create'})
request = factory.post(ACTIVITIES_URI,
data=json.dumps(new_activity_info),
HTTP_AUTHORIZATION=get_jwt_header(
new_user_info['email'],
new_user_info['password']),
content_type='application/json')
response = view(request)
activity_id = response.data.get('id')
assert response.status_code == 201
assert activity_id
assert response.data.get('name') == new_activity_info['name']
assert response.data.get(
'description') == new_activity_info['description']
assert response.data.get('start_time') == str(
new_activity_info['start_time'].replace(' ', 'T').split('+')[0] +
'Z')
assert response.data.get('end_time') == str(
new_activity_info['end_time'].replace(' ', 'T').split('+')[0] +
'Z')
assert response.data.get('user_details', {}).get('id')
assert response.data.get('user_details',
{}).get('email') == new_user_info['email']
assert response.data.get(
'category',
{}).get('name') == new_activity_info['category']['name']
onui = other_new_user_info()
User.objects.create_user(first_name=onui['first_name'],
last_name=onui['last_name'],
email=onui['email'],
country=onui['country'],
mobile_number=onui['mobile_number'],
goal=onui['goal'],
password=onui['password'])
# u2 can't GET created activity
bad_retrieve_view = ActivityViewSet.as_view({'get': 'retrieve'})
bad_retrieve_request = factory.get(
ACTIVITIES_URI + '/{}'.format(activity_id),
HTTP_AUTHORIZATION=get_jwt_header(onui['email'], onui['password']))
bad_retrieve_response = view(bad_retrieve_request, pk=activity_id)
assert bad_retrieve_response.status_code == 405
# u2 can't PUT created activity
edited_activity_info = new_activity_info
edited_activity_info['name'] = 'slkdjfalsdf'
edited_activity_info['description'] = 'slkdjfalsdf'
bad_put_view = ActivityViewSet.as_view({'put': 'update'})
bad_put_request = factory.put(
ACTIVITIES_URI + '/{}'.format(activity_id),
data=json.dumps(edited_activity_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(onui['email'], onui['password']))
response = view(bad_put_request, pk=activity_id)
assert response.status_code == 405
# u2 can't DELETE created activity
bad_delete_view = ActivityViewSet.as_view({'delete': 'destroy'})
bad_delete_request = factory.delete(
ACTIVITIES_URI + '/{}'.format(activity_id),
HTTP_AUTHORIZATION=get_jwt_header(onui['email'], onui['password']))
bad_delete_response = view(bad_delete_request, pk=activity_id)
assert response.status_code == 405
def test_view_activity_successful_crud(self, new_user_info,
new_activity_info):
# Create user
User.objects.create_user(first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
# Make datetimes strings and create new category
start_time = new_activity_info['start_time']
end_time = new_activity_info['end_time']
# Stringify datetimes
new_activity_info['start_time'] = str(start_time)
new_activity_info['end_time'] = str(end_time)
new_activity_info['category']['name'] = handle_activity_category(
new_activity_info['category']['name']).name
# Post activity
view = ActivityViewSet.as_view({'post': 'create'})
request = factory.post(ACTIVITIES_URI,
data=json.dumps(new_activity_info),
HTTP_AUTHORIZATION=get_jwt_header(
new_user_info['email'],
new_user_info['password']),
content_type='application/json')
response = view(request)
activity_id = response.data.get('id')
# Assert newly created activity exists
assert response.status_code == 201
assert activity_id
assert response.data.get('name') == new_activity_info['name']
assert response.data.get(
'description') == new_activity_info['description']
assert response.data.get('start_time') == str(
new_activity_info['start_time'].replace(' ', 'T').split('+')[0] +
'Z')
assert response.data.get('end_time') == str(
new_activity_info['end_time'].replace(' ', 'T').split('+')[0] +
'Z')
assert response.data.get('user_details', {}).get('id')
assert response.data.get('user_details',
{}).get('email') == new_user_info['email']
assert response.data.get(
'category',
{}).get('name') == new_activity_info['category']['name']
# Assert user who created the activity can retrieve it
good_retrieve_view = ActivityViewSet.as_view({'get': 'retrieve'})
good_retrieve_request = factory.get(
ACTIVITIES_URI + '/{}'.format(activity_id),
HTTP_AUTHORIZATION=get_jwt_header(new_user_info['email'],
new_user_info['password']))
good_retrieve_response = good_retrieve_view(good_retrieve_request,
pk=activity_id)
assert good_retrieve_response.status_code == 200
assert good_retrieve_response.data.get('id') == activity_id
# Set edited attributes
edited_activity_info = new_activity_info
edited_activity_info['end_time'] = str(end_time + timedelta(hours=1))
edited_activity_info['category']['name'] = 'Hooligans'
good_put_view = ActivityViewSet.as_view({'put': 'update'})
good_put_request = factory.put(
ACTIVITIES_URI + '/{}'.format(activity_id),
data=json.dumps(edited_activity_info),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(new_user_info['email'],
new_user_info['password']))
good_put_response = good_put_view(good_put_request, pk=activity_id)
# Assert user who created the activity can edited it
# and contains the newly edited info
assert good_put_response.status_code == 200
assert good_put_response.data.get('id') == activity_id
assert good_put_response.data.get(
'name') == edited_activity_info['name']
assert good_put_response.data.get(
'description') == edited_activity_info['description']
assert good_put_response.data.get(
'start_time') == edited_activity_info['start_time'].replace(
' ', 'T').split('+')[0] + 'Z'
assert good_put_response.data.get(
'end_time') == edited_activity_info['end_time'].replace(
' ', 'T').split('+')[0] + 'Z'
assert good_put_response.data.get(
'user_details', {}).get('email') == new_user_info['email']
assert good_put_response.data.get('category',
{}).get('name') == 'Hooligans'
assert Category.objects.get(name=new_activity_info['category']['name'])
assert Category.objects.get(
name=edited_activity_info['category']['name']).name == 'Hooligans'
# Assert user who created the activity can delete it
good_delete_view = ActivityViewSet.as_view({'delete': 'destroy'})
good_delete_request = factory.delete(
ACTIVITIES_URI + '/{}'.format(activity_id),
HTTP_AUTHORIZATION=get_jwt_header(new_user_info['email'],
new_user_info['password']))
good_delete_response = good_delete_view(good_delete_request,
pk=activity_id)
assert good_delete_response.status_code == 204
def test_view_update_user(self, new_user_info, json_user_with_details,
json_user_no_details):
# Populate the database
new_user = User.objects.create_user(
first_name=new_user_info['first_name'],
last_name=new_user_info['last_name'],
email=new_user_info['email'],
country=new_user_info['country'],
mobile_number=new_user_info['mobile_number'],
goal=new_user_info['goal'],
password=new_user_info['password'])
user_password = new_user_info['password']
# Assert user was created with same fields
assert new_user.id
assert new_user.first_name == new_user_info['first_name']
assert new_user.last_name == new_user_info['last_name']
assert new_user.email == new_user_info['email']
assert new_user.password != user_password
assert new_user.details.country == new_user_info['country']
assert new_user.details.mobile_number == new_user_info['mobile_number']
assert new_user.details.goal == new_user_info['goal']
# Update the user with new_user.id
view = UserViewSet.as_view({'put': 'update'})
request = factory.put(USERS_URI + '/{}'.format(new_user.id),
data=json.dumps(json_user_with_details),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
new_user_info['email'], user_password))
response = view(request, pk=new_user.id)
# Get User with the same new_user.id
edited_user = User.objects.get(id=new_user.id)
# Assert response is the same as the fixture value which is also
# the same with the newly created and edited user
assert response.data.get('id') == edited_user.id
assert response.data.get('first_name') == json_user_with_details[
'first_name'] == edited_user.first_name
assert response.data.get('last_name') == json_user_with_details[
'last_name'] == edited_user.last_name
assert response.data.get(
'email') == json_user_with_details['email'] == edited_user.email
assert response.data.get(
'details', {}).get('country') == json_user_with_details['details'][
'country'] == edited_user.details.country
assert response.data.get(
'details',
{}).get('mobile_number') == json_user_with_details['details'][
'mobile_number'] == edited_user.details.mobile_number
assert response.data.get(
'details', {}).get('goal') == json_user_with_details['details'][
'goal'] == edited_user.details.goal
# Edit the same user again but this time removing the details
view = UserViewSet.as_view({'put': 'update'})
request = factory.put(USERS_URI + '/{}'.format(new_user.id),
data=json.dumps(json_user_no_details),
content_type='application/json',
HTTP_AUTHORIZATION=get_jwt_header(
json_user_with_details['email'],
user_password))
response = view(request, pk=new_user.id)
edited_user = User.objects.get(id=new_user.id)
# Assert response is the same as the fixture value which is also
# the same with the newly created and edited user but having no details
assert response.data.get('id') == edited_user.id
assert response.data.get('first_name') == json_user_no_details[
'first_name'] == edited_user.first_name
assert response.data.get('last_name') == json_user_no_details[
'last_name'] == edited_user.last_name
assert response.data.get(
'email') == json_user_no_details['email'] == edited_user.email
assert response.data.get('details')
assert not response.data.get('details', {}).get('country')
assert not response.data.get('details', {}).get('goal')
assert not response.data.get('details', {}).get('mobile_number')
