def test_put_verify_job(webapp, test_repository, test_job, text_summary_lines, test_user,
failure_classifications):
client = APIClient()
client.force_authenticate(user=test_user)
TextLogErrorMetadata.objects.filter(text_log_error__step__job=test_job).update(best_is_verified=True)
FailureLine.objects.filter(job_guid=test_job.guid).update(best_is_verified=True)
text_summary_lines = TextLogSummary.objects.filter(job_guid=test_job.guid).get().lines.all()
assert len(text_summary_lines) > 0
data = [{"id": item.id, "bug_number": i + 1, "verified": True} for
i, item in enumerate(text_summary_lines)]
resp = client.put(reverse("text-log-summary-line-list"),
data, format="json")
assert resp.status_code == 200
assert test_job.is_fully_verified()
bug_job_items = BugJobMap.objects.filter(job=test_job)
assert {item.bug_id for item in bug_job_items} == set(range(1, len(text_summary_lines) + 1))
assert all(item.user == test_user for item in bug_job_items)
note = JobNote.objects.filter(job=test_job).get()
assert note.user == test_user
assert note.failure_classification.name == "intermittent"
def test_update(self, user1, node1):
client = APIClient()
client.force_authenticate(user=user1)
response = client.patch(
reverse('node-detail', kwargs={"pk": node1.id}),
data={
"meta": "different whatever",
"enc_version": 2,
})
assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
response = client.put(
reverse('node-detail', kwargs={"pk": node1.id}),
data={
"name": "whatever",
"meta": "different whatever",
"type": 1,
"enc_version": 2,
})
assert response.status_code == status.HTTP_200_OK
response = client.put(
reverse('node-detail', kwargs={"pk": 9999}),
data={
"name": "whatever",
"meta": "different whatever",
"type": 1,
"enc_version": 2,
})
assert response.status_code == status.HTTP_404_NOT_FOUND
def api_client(user, db):
"""
A rest_framework api test client not auth'd.
"""
client = APIClient()
client.force_authenticate(user=user)
return client
def test_push_cancel_all(failure_classifications,
push_with_three_jobs, pulse_action_consumer,
test_repository, test_user):
"""
Issue cancellation of a push with three unfinished jobs.
"""
client = APIClient()
client.force_authenticate(user=test_user)
# Ensure all jobs are pending..
for job in Job.objects.all():
assert job.state == 'pending'
url = reverse("push-cancel-all",
kwargs={"project": test_repository.name, "pk": push_with_three_jobs.id})
client.post(url)
# Ensure all jobs are cancelled..
for job in Job.objects.all():
assert job.state == 'completed'
assert job.result == 'usercancel'
for _ in range(0, 3):
message = pulse_action_consumer.get(block=True, timeout=2)
content = message.payload
assert content['action'] == 'cancel'
assert content['project'] == test_repository.name
def test_list(self, user1):
client = APIClient()
client.force_authenticate(user=user1)
response = client.get(reverse('node-list'))
assert response.status_code == status.HTTP_200_OK
def test_create_bug_job_map_dup(eleven_jobs_processed, mock_message_broker, jm):
"""
test creating the same bug map skips it
"""
client = APIClient()
user = User.objects.create(username="******", is_staff=True)
client.force_authenticate(user=user)
job = jm.get_job_list(0, 1)[0]
bug_job_map_obj = {
"job_id": job["id"],
"bug_id": 1,
"type": "manual"
}
client.post(
reverse("bug-job-map-list", kwargs={"project": jm.project}),
bug_job_map_obj
)
client.post(
reverse("bug-job-map-list", kwargs={"project": jm.project}),
bug_job_map_obj
)
user.delete()
assert (bug_job_map_obj,) == jm.get_bug_job_map_list(0, 1)
jm.disconnect()
def test_alert_summaries_put(webapp, test_repository, test_perf_signature,
test_perf_alert_summary, test_user, test_sheriff):
# verify that we fail if not authenticated
webapp.put_json(reverse('performance-alert-summaries-list') + '1/', {
'status': 1
}, status=403)
assert PerformanceAlertSummary.objects.get(id=1).status == 0
# verify that we fail if authenticated, but not staff
client = APIClient()
client.force_authenticate(user=test_user)
resp = client.put(reverse('performance-alert-summaries-list') + '1/', {
'status': 1
}, format='json')
assert resp.status_code == 403
assert PerformanceAlertSummary.objects.get(id=1).status == 0
# verify that we succeed if authenticated + staff
client = APIClient()
client.force_authenticate(user=test_sheriff)
resp = client.put(reverse('performance-alert-summaries-list') + '1/', {
'status': 1
}, format='json')
assert resp.status_code == 200
assert PerformanceAlertSummary.objects.get(id=1).status == 1
def test_update_save_data_by_user(self):
client = APIClient()
client.force_authenticate(user=self.user2)
response_create = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file2.txt'
})
response_update1 = client.patch('/save-data/1/', data={
'saved_file': 'file01.txt'
}, format='json') # Can not update unless their own
response_update2 = client.patch('/save-data/4/', data={
'saved_file': 'file02.txt'
}, format='json')
response1 = client.get('/save-data/1/') # Can't read unless their own
response2 = client.get('/save-data/4/')
self.assertEqual(response_create.status_code, status.HTTP_201_CREATED)
self.assertEqual(response_update1.status_code, \
status.HTTP_404_NOT_FOUND)
self.assertEqual(response_update2.status_code, status.HTTP_200_OK)
self.assertEqual(response1.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response2.data['id'], 4)
self.assertEqual(response2.data['saved_file'], 'file02.txt')
def test_bug_job_map_delete(webapp, eleven_jobs_processed,
jm, mock_message_broker):
"""
test retrieving a list of bug_job_map
"""
client = APIClient()
user = User.objects.create(username="******", is_staff=True)
client.force_authenticate(user=user)
job_id = jm.get_job_list(0, 1)[0]["id"]
bug_id = random.randint(0, 100)
jm.insert_bug_job_map(job_id, bug_id, "manual")
pk = "{0}-{1}".format(job_id, bug_id)
resp = client.delete(
reverse("bug-job-map-detail", kwargs={
"project": jm.project,
"pk": pk
})
)
user.delete()
content = json.loads(resp.content)
assert content == {"message": "Bug job map deleted"}
jm.disconnect()
def test_read_save_data_by_user(self):
client = APIClient()
client.force_authenticate(user=self.user2)
response_create = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file2.txt'
})
response1 = client.get('/save-data/')
response2 = client.get('/save-data/1/')
response3 = client.get('/save-data/?game=2')
response4 = client.get('/save-data/?user=user1')
response5 = client.get('/save-data/?user=user2')
self.assertEqual(response_create.status_code, status.HTTP_201_CREATED)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response3.status_code, status.HTTP_200_OK)
self.assertEqual(response4.status_code, status.HTTP_200_OK)
self.assertEqual(response5.status_code, status.HTTP_200_OK)
self.assertEqual(len(response1.data), 1)
self.assertEqual(len(response3.data), 0)
self.assertEqual(len(response4.data), 0)
self.assertEqual(len(response5.data), 1)
def test_update_save_data_by_operator(self):
client = APIClient()
client.force_authenticate(user=self.user1)
response_create = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file2.txt'
})
response_update1 = client.patch('/save-data/1/', data={
'saved_file': 'file01.txt'
}, format='json')
response_update2 = client.patch('/save-data/4/', data={
'saved_file': 'file02.txt'
}, format='json')
response1 = client.get('/save-data/1/')
response2 = client.get('/save-data/4/')
self.assertEqual(response_create.status_code, status.HTTP_201_CREATED)
self.assertEqual(response_update1.status_code, status.HTTP_200_OK)
self.assertEqual(response_update2.status_code, status.HTTP_200_OK)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response1.data['id'], 1)
self.assertEqual(response1.data['saved_file'], 'file01.txt')
self.assertEqual(response2.data['id'], 4)
self.assertEqual(response2.data['saved_file'], 'file02.txt')
def test_create_save_data_by_operator(self):
client = APIClient()
client.force_authenticate(user=self.user1)
response_create1 = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file1.txt'
})
response_create2 = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file2.txt'
})
response1 = client.get('/save-data/')
response2 = client.get('/save-data/?game=3')
self.assertEqual(response_create1.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response_create2.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(len(response1.data), 5)
self.assertEqual(len(response2.data), 2)
def test_create_save_data_by_user(self):
client = APIClient()
client.force_authenticate(user=self.user2)
response_create1 = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file1.txt'
}) # Access denied, can only create own
response_create2 = client.post('/save-data/', data={
'user': '******',
'game': '3',
'saved_file': 'file2.txt'
})
response1 = client.get('/save-data/')
response2 = client.get('/save-data/?game=3')
self.assertEqual(response_create1.status_code, \
status.HTTP_403_FORBIDDEN)
self.assertEqual(response_create2.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(len(response1.data), 1)
self.assertEqual(len(response2.data), 1)
def test_read_game_session_by_user(self):
client1 = APIClient()
client1.force_authenticate(user=self.user1)
client2 = APIClient()
client2.force_authenticate(user=self.user2)
# Joins game
response_create1 = client1.post('/game-session/', data={
'user': '******',
'game': self.game2.id
}, format='json')
response_create2 = client1.post('/game-session/', data={
'user': '******',
'game': self.game1.id
}, format='json')
# Read Game Session
response1 = client2.get('/game-session/')
response2 = client2.get('/game-session/?game=1')
response3 = client2.get('/game-session/?user=user1')
response4 = client2.get('/game-session/?user=user2')
response5 = client2.get('/game-session/1/')
response6 = client2.get('/game-session/2/')
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response3.status_code, status.HTTP_200_OK)
self.assertEqual(response4.status_code, status.HTTP_200_OK)
self.assertEqual(response5.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response6.status_code, status.HTTP_200_OK)
self.assertEqual(len(response1.data), 1)
self.assertEqual(len(response2.data), 1)
self.assertEqual(len(response3.data), 0)
self.assertEqual(len(response4.data), 1)
self.assertEqual(response6.data['id'], 2)
def test_update_game_session(self):
client = APIClient()
client.force_authenticate(user=self.user1)
# Joins game
response_create1 = client.post('/game-session/', data={
'user': '******',
'game': self.game2.id
}, format='json')
response_create2 = client.post('/game-session/', data={
'user': '******',
'game': self.game1.id
}, format='json')
# Update game
response_update1 = client.patch('/game-session/1/', data={
'game':self.game2.id
}, format='json')
response_update2 = client.patch('/game-ownership/2/', data={
'controller': 100
}, format='json')
self.assertEqual(response_create1.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response_create2.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response_update1.status_code, \
status.HTTP_403_FORBIDDEN)
self.assertEqual(response_update2.status_code, \
status.HTTP_403_FORBIDDEN)
def test_render_taala_detail(self):
client = APIClient()
client.force_authenticate(user=self.normaluser)
response = client.get("/api/carnatic/taala/d5285bf4-c3c5-454e-a659-fec30075990b")
data = response.data
fields = ['aliases', 'artists', 'common_name', 'composers', 'name', 'recordings', 'uuid', 'works']
self.assertEqual(fields, sorted(data.keys()))
def test_buy_game_by_operator(self):
client = APIClient()
client.force_authenticate(user=self.user1)
response_create1 = client.post('/game-ownership/', data={
'user': self.user1.username,
'game': self.game1.id
}, format='json') # Duplicate
response_create2 = client.post('/game-ownership/', data={
'user': self.user1.username,
'game': self.game3.id
}, format='json')
response_create3 = client.post('/game-ownership/', data={
'user': self.user2.username,
'game': self.game3.id
}, format='json')
response1 = client.get('/game-ownership/')
response2 = client.get('/game-ownership/?user=user1')
response3 = client.get('/game-ownership/?user=user2')
response4 = client.get('/game-ownership/?game=3')
self.assertEqual(response_create1.status_code, \
status.HTTP_400_BAD_REQUEST)
self.assertEqual(response_create2.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response_create3.status_code, \
status.HTTP_201_CREATED)
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response3.status_code, status.HTTP_200_OK)
self.assertEqual(response4.status_code, status.HTTP_200_OK)
self.assertEqual(len(response1.data), 5)
self.assertEqual(len(response2.data), 3)
self.assertEqual(len(response3.data), 2)
self.assertEqual(len(response4.data), 2)
def test_put_duplicate_multiple_repeated(webapp, classified_failures, test_user):
client = APIClient()
client.force_authenticate(user=test_user)
new = ClassifiedFailure(bug_number=1234)
new.save()
classified_failures.append(new)
client.put(reverse("classified-failure-list"),
[{"id": classified_failures[0].id, "bug_number": 1234}],
format="json")
new_classified_failures = ClassifiedFailure.objects.all()
assert [item.id for item in new_classified_failures] == [2, 3]
assert [item.bug_number for item in new_classified_failures] == [None, 1234]
resp = client.put(reverse("classified-failure-list"),
[{"id": classified_failures[0].id, "bug_number": 1234},
{"id": classified_failures[1].id, "bug_number": 1234}],
format="json")
actual = resp.data
assert len(actual) == 2
expected = [{"id": new.id,
"bug_number": 1234,
"bug": None},
{"id": new.id,
"bug_number": 1234,
"bug": None}]
assert actual == expected
def test_update_failure_line_replace(eleven_jobs_stored, jm, failure_lines,
classified_failures, test_user):
MatcherManager.register_detector(ManualDetector)
client = APIClient()
client.force_authenticate(user=test_user)
failure_line = failure_lines[0]
assert failure_line.best_classification == classified_failures[0]
assert failure_line.best_is_verified is False
body = {"project": jm.project,
"best_classification": classified_failures[1].id}
resp = client.put(
reverse("failure-line-detail", kwargs={"pk": failure_line.id}),
body, format="json")
assert resp.status_code == 200
failure_line.refresh_from_db()
assert failure_line.best_classification == classified_failures[1]
assert failure_line.best_is_verified
assert len(failure_line.classified_failures.all()) == 2
expected_matcher = Matcher.objects.get(name="ManualDetector")
assert failure_line.matches.get(classified_failure_id=classified_failures[1].id).matcher == expected_matcher
def test_put_multiple_repeat(webapp, classified_failures, test_user):
client = APIClient()
client.force_authenticate(user=test_user)
classified_failures[0].bug_number = 1234
classified_failures[0].save()
resp = client.put(reverse("classified-failure-list"),
[{"id": classified_failures[0].id, "bug_number": 1234},
{"id": classified_failures[1].id, "bug_number": 5678}],
format="json")
assert resp.status_code == 200
actual = resp.data
assert len(actual) == 2
expected = [{"id": classified_failures[0].id,
"bug_number": 1234,
"bug": None},
{"id": classified_failures[1].id,
"bug_number": 5678,
"bug": None}]
assert actual == expected
classified_failures[0].refresh_from_db()
assert classified_failures[0].bug_number == 1234
classified_failures[1].refresh_from_db()
assert classified_failures[1].bug_number == 5678
def test_put_multiple_duplicate(webapp, classified_failures, test_user):
client = APIClient()
client.force_authenticate(user=test_user)
new = ClassifiedFailure(bug_number=1234)
new.save()
classified_failures.append(new)
resp = client.put(reverse("classified-failure-list"),
[{"id": classified_failures[0].id, "bug_number": 1234},
{"id": classified_failures[1].id, "bug_number": 5678}],
format="json")
actual = resp.data
assert len(actual) == 2
expected = [{"id": classified_failures[2].id,
"bug_number": 1234,
"bug": None},
{"id": classified_failures[1].id,
"bug_number": 5678,
"bug": None}]
assert actual == expected
new_classified_failures = ClassifiedFailure.objects.all()
assert len(new_classified_failures) == len(classified_failures) - 1
class UserModelTests(TestCase):
def setUp(self):
self.client = APIClient()
# create users
self.user1 = User.objects.create(username='******', password='******', email="*****@*****.**", is_active=True)
self.user1.save()
self.user2 = User.objects.create(username='******', password='******', email="*****@*****.**", is_active=False)
self.user2.save()
def test_login_success(self):
response = self.client.post('/login/', {'username': '******', 'password': '******'}, format='json')
self.assertEqual(response.status_code, 200)
def test_login_fail_user_inactive(self):
response = self.client.post('/login/', {'username': '******', 'password': '******'}, format='json')
self.assertEquals(response.status_code, 200)
def test_login_fail_user_not_exist(self):
response = self.client.post('/login/', {'username': '******', 'password': '******'}, format='json')
print(response.content)
self.assertEquals(response.status_code, 200)
def test_login_fail_incorrect_password(self):
response = self.client.post('/login/', {'username': '******', 'password': '******'}, format='json')
self.assertTrue(response.status_code == 200)
def test_logout(self):
# authenticate before logout
self.client.force_authenticate(user=self.user1)
response = self.client.post('/logout/')
self.assertTrue(response.status_code == 200)
def synchronized_daily(request):
data = []
labels = []
chart_data = {}
client = APIClient()
client.force_authenticate(user=request.user)
response = client.get(
'/api/v1/token/stats/syncs/daily/',
HTTP_ACCEPT_LANGUAGE=request.LANGUAGE_CODE
)
if hasattr(response, 'data') and response.status_code == status.HTTP_200_OK:
labels, data = zip(*response.data)
chart_data[_('Computers')] = list(data)
return render(
request,
'includes/spline_js.html',
{
'data': chart_data,
'x_labels': list(labels),
'id': 'syncs-daily',
}
)
def test_update_failure_line_ignore(eleven_jobs_stored, jm, failure_lines,
classified_failures, test_user):
client = APIClient()
client.force_authenticate(user=test_user)
MatcherManager.register_detector(ManualDetector)
failure_line = failure_lines[0]
assert failure_line.best_classification == classified_failures[0]
assert failure_line.best_is_verified is False
body = {"project": jm.project,
"best_classification": None}
resp = client.put(
reverse("failure-line-detail", kwargs={"pk": failure_line.id}),
body, format="json")
assert resp.status_code == 200
failure_line.refresh_from_db()
assert failure_line.best_classification is None
assert failure_line.best_is_verified
def synchronized_monthly(request):
labels = {
'total': _("Totals")
}
x_labels = {}
data = {}
new_data = {}
total = []
chart_data = {}
delta = relativedelta(months=+1)
end_date = date.today() + delta
begin_date = end_date - relativedelta(months=+MONTHLY_RANGE)
client = APIClient()
client.force_authenticate(user=request.user)
url = '/api/v1/token/stats/syncs/monthly/'
platforms = Platform.objects.only("id", "name")
for platform in platforms:
new_data[platform.id] = []
labels[platform.id] = platform.name
response = client.get(
'{}?platform_id={}'.format(url, platform.id),
HTTP_ACCEPT_LANGUAGE=request.LANGUAGE_CODE
)
if hasattr(response, 'data') and response.status_code == status.HTTP_200_OK:
x_labels[platform.id], data[platform.id] = zip(*response.data)
# shuffle data series
x_axe = []
for monthly in month_year_iter(
begin_date.month, begin_date.year,
end_date.month, end_date.year
):
key = '%d-%02d' % (monthly[0], monthly[1])
x_axe.append(key)
total_month = 0
for serie in data:
new_data[serie].append(
data[serie][x_labels[serie].index(key)] if key in x_labels[serie] else 0
)
total_month += new_data[serie][-1]
total.append(total_month)
chart_data[labels['total']] = total
for item in new_data:
chart_data[labels[item]] = new_data[item]
return render(
request,
'includes/spline_js.html',
{
'data': chart_data,
'x_labels': x_axe,
'id': 'syncs-monthly',
}
)
def test_create_chapter_fail(self, registered_users):
# create client
client = APIClient()
client.force_authenticate(user=registered_users['bob'])
# create book via api
book_title = fake.name()
response = client.post(
reverse("v1:book-list"),
data={
'title': book_title,
'language_id': 1,
'owner_id': registered_users['bob'].id
}
)
book_id = response.data['id']
assert response.data['title'] == book_title
# create chapter
response = client.post(
reverse("v1:editor_chapter_list_create_api", kwargs={'pk': book_id}),
)
assert response.status_code is status.HTTP_400_BAD_REQUEST
chapter_title = fake.name()
response = client.post(
reverse("v1:editor_chapter_list_create_api", kwargs={'pk': book_id}),
data={'asdasd': chapter_title}
)
assert response.status_code is status.HTTP_400_BAD_REQUEST
def test_job_cancel_authorized(webapp, test_repository, eleven_jobs_stored,
pulse_action_consumer, test_user):
"""
Validate that job gets updated when a valid user hits this endpoint.
"""
client = APIClient()
client.force_authenticate(user=test_user)
# get the job, set its state to pending
job = Job.objects.get(id=1)
job.state = 'pending'
job.save()
url = reverse("jobs-cancel",
kwargs={"project": test_repository.name})
client.post(url, {"job_id_list": [job.id]})
message = pulse_action_consumer.get(block=True, timeout=2)
content = message.payload
assert content['project'] == test_repository.name
assert content['action'] == 'cancel'
assert content['job_guid'] == job.guid
assert content['requester'] == test_user.email
# validate that we modified the job structure appropriately
old_last_modified = job.last_modified
job.refresh_from_db()
assert old_last_modified < job.last_modified
assert job.result == 'usercancel'
def test_put_multiple(webapp, text_summary_lines, test_user):
client = APIClient()
client.force_authenticate(user=test_user)
text_summary_lines[0].bug_number = 1234
text_summary_lines[0].save()
resp = client.put(reverse("text-log-summary-line-list"),
[{"id": text_summary_lines[0].id, "bug_number": 5678, "verified": True},
{"id": text_summary_lines[1].id, "bug_number": 9012, "verified": True}],
format="json")
assert resp.status_code == 200
actual = resp.data
expected = [{"id": text_summary_lines[0].id,
"summary": text_summary_lines[0].summary.id,
"line_number": text_summary_lines[0].line_number,
"failure_line": text_summary_lines[0].failure_line.id,
"bug_number": 5678,
"verified": True,
"bug": None},
{"id": text_summary_lines[1].id,
"summary": text_summary_lines[1].summary.id,
"line_number": text_summary_lines[1].line_number,
"failure_line": text_summary_lines[1].failure_line.id,
"bug_number": 9012,
"verified": True,
"bug": None}]
assert actual == expected
text_summary_lines[0].refresh_from_db()
assert text_summary_lines[0].bug_number == 5678
text_summary_lines[1].refresh_from_db()
assert text_summary_lines[1].bug_number == 9012
def test_list_chapters(self, registered_users, books):
user_bob = registered_users['bob']
books[0].owner = user_bob
client = APIClient()
client.force_authenticate(user=user_bob)
response = client.get(
reverse("v1:editor_chapter_list_create_api", kwargs={'pk': books[0].id})
)
# we got 200 OK
assert response.status_code is status.HTTP_200_OK
# we don't have chapters yet
assert response.data['count'] is 0
# another book
response = client.get(
reverse("v1:editor_chapter_list_create_api", kwargs={'pk': books[1].id})
)
# we got 200 OK
assert response.status_code is status.HTTP_200_OK
# we don't have chapters yet
assert response.data['count'] is 0
def test_resultset_cancel_all(jm, resultset_with_three_jobs, pulse_action_consumer):
"""
Issue cancellation of a resultset with three unfinished jobs.
"""
client = APIClient()
user = User.objects.create(username="******", email="*****@*****.**")
client.force_authenticate(user=user)
# Ensure all jobs are pending..
jobs = jm.get_job_list(0, 3)
for job in jobs:
assert job['state'] == 'pending'
url = reverse("resultset-cancel-all",
kwargs={"project": jm.project, "pk": resultset_with_three_jobs})
client.post(url)
# Ensure all jobs are cancelled..
jobs = jm.get_job_list(0, 3)
for job in jobs:
assert job['state'] == 'completed'
assert job['result'] == 'usercancel'
for _ in range(0, 3):
message = pulse_action_consumer.get(block=True, timeout=2)
content = json.loads(message.body)
assert content['action'] == 'cancel'
assert content['project'] == jm.project
user.delete()
class RecipeImageUploadTest(TestCase):
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**',
'testpass'
)
self.client.force_authenticate(self.user)
self.recipe = sample_recipe(user=self.user)
def tearDown(self):
self.recipe.image.delete()
def test_upload_image_to_recipe(self):
"""Test uploading an image to recipe"""
url = image_upload_url(self.recipe.id)
with tempfile.NamedTemporaryFile(suffix='.jpg') as ntf:
img = Image.new('RGB', (10, 10))
img.save(ntf, format='JPEG')
ntf.seek(0)
res = self.client.post(url, {'image': ntf}, format='multipart')
self.recipe.refresh_from_db()
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertIn('image', res.data)
self.assertTrue(os.path.exists(self.recipe.image.path))
def test_upload_image_bad_request(self):
"""Test uploading an invalid image"""
url = image_upload_url(self.recipe.id)
res = self.client.post(url, {'image': 'notimage'}, format='multipart')
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_filter_recipes_by_tags(self):
"""Test returning recipes with specific tags"""
recipe1 = sample_recipe(user=self.user, title='Arepa con webo')
recipe2 = sample_recipe(user=self.user, title='Avocado toast')
tag = sample_tag(user=self.user, name='Vegan')
tag2 = sample_tag(user=self.user, name='Vegetarian')
recipe1.tags.add(tag)
recipe2.tags.add(tag2)
recipe3 = sample_recipe(user=self.user, title='Fish and chips')
res = self.client.get(
RECIPE_URLS,
{'tags': f'{tag.id},{tag2.id}'}
)
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def test_filter_recipe_by_ingredients(self):
"""Test returning recipes with specific ingredients"""
recipe1 = sample_recipe(user=self.user, title='Posh beans on toast')
recipe2 = sample_recipe(user=self.user, title='pollo frito')
ingredient1 = sample_ingredient(user=self.user, name='Feta cheese')
ingredient2 = sample_ingredient(user=self.user, name='pollo')
recipe1.ingredient.add(ingredient1)
recipe2.ingredient.add(ingredient2)
recipe3 = sample_recipe(user=self.user, title='Steak and mushrooms')
res = self.client.get(
RECIPE_URLS,
{'ingredient': f'{ingredient1.id},{ingredient2.id}'}
)
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3, res.data)
class PrivateRecipeApiTests(TestCase):
"""Test authenticated recipe API access"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'testpass')
self.client.force_authenticate(self.user)
def test_retrieve_recipes(self):
"""Test retrieving list of recipes"""
sample_recipe(user=self.user)
sample_recipe(user=self.user)
res = self.client.get(RECIPES_URL)
recipes = Recipe.objects.all().order_by('-id')
serializer = RecipeSerializer(recipes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_recipes_limited_to_user(self):
"""Test retrieving recipes for user"""
user2 = get_user_model().objects.create_user('*****@*****.**',
'pass')
sample_recipe(user=user2)
sample_recipe(user=self.user)
res = self.client.get(RECIPES_URL)
recipes = Recipe.objects.filter(user=self.user)
serializer = RecipeSerializer(recipes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data, serializer.data)
def test_view_recipe_detail(self):
"""Test viewing a recipe detail"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
recipe.ingredients.add(sample_ingredient(user=self.user))
url = detail_url(recipe.id)
res = self.client.get(url)
serializer = RecipeDetailSerializer(recipe)
self.assertEqual(res.data, serializer.data)
def test_create_basic_recipe(self):
"""Test creating recipe"""
payload = {
'title': 'Test recipe',
'time_minutes': 30,
'price': 10.00,
}
res = self.client.post(RECIPES_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
for key in payload.keys():
self.assertEqual(payload[key], getattr(recipe, key))
def test_create_recipe_with_tags(self):
"""Test creating a recipe with tags"""
tag1 = sample_tag(user=self.user, name='Tag 1')
tag2 = sample_tag(user=self.user, name='Tag 2')
payload = {
'title': 'Test recipe with two tags',
'tags': [tag1.id, tag2.id],
'time_minutes': 30,
'price': 10.00
}
res = self.client.post(RECIPES_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
tags = recipe.tags.all()
self.assertEqual(tags.count(), 2)
self.assertIn(tag1, tags)
self.assertIn(tag2, tags)
def test_create_recipe_with_ingredients(self):
"""Test creating recipe with ingredients"""
ingredient1 = sample_ingredient(user=self.user, name='Ingredient 1')
ingredient2 = sample_ingredient(user=self.user, name='Ingredient 2')
payload = {
'title': 'Test recipe with ingredients',
'ingredients': [ingredient1.id, ingredient2.id],
'time_minutes': 45,
'price': 15.00
}
res = self.client.post(RECIPES_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
ingredients = recipe.ingredients.all()
self.assertEqual(ingredients.count(), 2)
self.assertIn(ingredient1, ingredients)
self.assertIn(ingredient2, ingredients)
def test_partial_update_recipe(self):
"""Test updating a recipe with patch"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
new_tag = sample_tag(user=self.user, name='Curry')
payload = {'title': 'Chicken tikka', 'tags': [new_tag.id]}
url = detail_url(recipe.id)
self.client.patch(url, payload)
recipe.refresh_from_db()
self.assertEqual(recipe.title, payload['title'])
tags = recipe.tags.all()
self.assertEqual(len(tags), 1)
self.assertIn(new_tag, tags)
def test_full_update_recipe(self):
"""Test updaing a recipe with put"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
payload = {
'title': 'Spahetti carbonara',
'time_minutes': 25,
'price': 5.00
}
url = detail_url(recipe.id)
self.client.put(url, payload)
recipe.refresh_from_db()
self.assertEqual(recipe.title, payload['title'])
self.assertEqual(recipe.time_minutes, payload['time_minutes'])
self.assertEqual(recipe.price, payload['price'])
tags = recipe.tags.all()
self.assertEqual(len(tags), 0)
class RecipeImageUploadTests(TestCase):
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user('user', 'testpass')
self.client.force_authenticate(self.user)
self.recipe = sample_recipe(user=self.user)
# remover all the test system
def tearDown(self):
self.recipe.image.delete()
def test_upload_image_to_recipe(self):
"""Test upload an image t orecipe"""
url = image_upload_url(self.recipe.id)
with tempfile.NamedTemporaryFile(suffix='.jpg') as ntf:
img = Image.new('RGB', (10, 10))
img.save(ntf, format='JPEG')
# python seek, back to beginning.
ntf.seek(0)
# mulipart format ,
res = self.client.post(url, {'image': ntf}, format='multipart')
self.recipe.refresh_from_db()
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertIn('image', res.data)
self.assertTrue(os.path.exists(self.recipe.image.path))
def test_upload_image_bad_request(self):
""""Test upload an invlaid image"""
url = image_upload_url(self.recipe.id)
res = self.client.post(url, {'image': 'notimage'}, format='multipart')
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_filter_recipes_by_tags(self):
"""Test returning recipes with specific tags"""
recipe1 = sample_recipe(user=self.user, title='Thai vegetable curry')
recipe2 = sample_recipe(user=self.user, title='Aubergine with tahini')
tag1 = sample_tag(user=self.user, name='Vegan')
tag2 = sample_tag(user=self.user, name='Vegetarian')
recipe1.tags.add(tag1)
recipe2.tags.add(tag2)
recipe3 = sample_recipe(user=self.user, title='Fish and chips')
res = self.client.get(RECIPES_URL,
{'tags': '{},{}'.format(tag1.id, tag2.id)})
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def test_filter_recipes_by_ingredients(self):
"""Test returning recipes with specific ingredients"""
recipe1 = sample_recipe(user=self.user, title='Posh beans on toast')
recipe2 = sample_recipe(user=self.user, title='Chicken cacciatore')
ingredient1 = sample_ingredient(user=self.user, name='Feta cheese')
ingredient2 = sample_ingredient(user=self.user, name='Chicken')
recipe1.ingredients.add(ingredient1)
recipe2.ingredients.add(ingredient2)
recipe3 = sample_recipe(user=self.user, title='Steak and mushrooms')
res = self.client.get(
RECIPES_URL,
{'ingredients': '{},{}'.format(ingredient1.id, ingredient2.id)})
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
class PrivateIngredientsAPITests(TestCase):
"""Test ingredients API by authorized user"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
email="*****@*****.**", password="******")
self.client.force_authenticate(user=self.user)
def test_retrieve_ingredients_list(self):
"""Test retrieving a list of ingredients"""
Ingredient.objects.create(user=self.user, name='Kale')
Ingredient.objects.create(user=self.user, name='Salt')
response = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_ingredients_limited_to_user(self):
"""Test that ingredients for the authenticated user are returned"""
user2 = get_user_model().objects.create_user(
email="*****@*****.**", password="******")
Ingredient.objects.create(user=user2, name='ven')
ingredient = Ingredient.objects.create(user=self.user, name='Tum')
response = self.client.get(INGREDIENTS_URL)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['name'], ingredient.name)
def test_create_ingredient_successful(self):
"""Test creating a new ingredient"""
payload = {'name': 'Test Ingredient'}
self.client.post(INGREDIENTS_URL, payload)
exists = Ingredient.objects.filter(user=self.user,
name=payload['name']).exists()
self.assertTrue(exists)
def test_create_ingredient_invalid(self):
"""Test creating a new ingredient with invalid payload"""
payload = {'name': ''}
response = self.client.post(INGREDIENTS_URL, payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrieve_ingredients_assigned_to_recipes(self):
"""Test retrieving only ingredients that are assigned to recipes"""
ingredient1 = sample_ingredient(user=self.user, name='tomato')
ingredient2 = sample_ingredient(user=self.user, name='onion')
recipe = sample_recipe(user=self.user)
recipe.ingredients.add(ingredient1)
response = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, response.data)
self.assertNotIn(serializer2.data, response.data)
def test_retrieve_ingredients_assigned_unique(self):
"""Test filtering ingredients by assigned returns unique items"""
ingredient = Ingredient.objects.create(user=self.user,
name='Breakfast')
Ingredient.objects.create(user=self.user, name='Lunch')
recipe1 = Recipe.objects.create(title='Pancakes',
time_minutes=5,
price=3.00,
user=self.user)
recipe1.ingredients.add(ingredient)
recipe2 = Recipe.objects.create(title='Porridge',
time_minutes=3,
price=2.00,
user=self.user)
recipe2.ingredients.add(ingredient)
response = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
self.assertEqual(len(response.data), 1)
class PrivateTagsApiTest(TestCase):
# test the authorized user tags API
def setUp(self):
self.user = get_user_model().objects.create_user(
'*****@*****.**',
'testpassword',
)
self.client = APIClient()
self.client.force_authenticate(self.user)
def test_retrieve_tags(self):
# test retrieving tags
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
response = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_tags_limited_to_user(self):
# test that tags returned are for the authenticated user
# and not for the other user
user2 = get_user_model().objects.create_user(
'*****@*****.**',
'test2password2',
)
Tag.objects.create(user=user2, name='Thai')
tag = Tag.objects.create(user=self.user, name='Chinese')
response = self.client.get(TAGS_URL)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['name'], tag.name)
def test_create_tag_successful(self):
# test creating a nwe tag
payload = {
'name': 'Test Tag',
}
self.client.post(TAGS_URL, payload)
exists = Tag.objects.filter(user=self.user,
name=payload['name']).exists()
self.assertTrue(exists)
def test_create_tag_invalid(self):
# test creating a nwe tag with invalid payload
payload = {'name': ''}
response = self.client.post(TAGS_URL, payload)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrieve_tags_assigned_to_recipes(self):
# test filtering tags by those assigned to recipes
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='Lunch')
recipe = Recipe.objects.create(title='Coriander eggs on toast',
time_minutes=10,
price=5,
user=self.user)
recipe.tags.add(tag1)
response = self.client.get(TAGS_URL, {'assigned_only': 1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, response.data)
self.assertNotIn(serializer2.data, response.data)
def test_retrieve_tags_assigned_unique(self):
# test filtering tags by assigned returns unique items
tag = Tag.objects.create(user=self.user, name='Breakfast')
Tag.objects.create(user=self.user, name='Lunch')
recipe1 = Recipe.objects.create(title='Pancakes',
time_minutes=5,
price=3,
user=self.user)
recipe1.tags.add(tag)
recipe2 = Recipe.objects.create(title='Porridge',
time_minutes=3,
price=2,
user=self.user)
recipe2.tags.add(tag)
response = self.client.get(TAGS_URL, {'assigned_only': 1})
self.assertEqual(len(response.data), 1)
class PrivateTagsApiTests(TestCase):
"""Test the authorized uesr tags API"""
def setUp(self):
self.user = get_user_model().objects.create_user(
'*****@*****.**',
'pass123'
)
self.client = APIClient()
self.client.force_authenticate(self.user)
def test_retrieve_tags(self):
"""Test retrieving tags"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_tags_limited_to_user(self):
"""Test that tags returned are for the authenticated user"""
user2 = get_user_model().objects.create_user(
'*****@*****.**',
'testpass'
)
Tag.objects.create(user=user2, name='Fruity')
tag = Tag.objects.create(user=self.user, name='Comfort Food')
res = self.client.get(TAGS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]['name'], tag.name)
def test_create_tag_successful(self):
"""Test creating a new tag"""
payload = {'name': 'Test tag'}
self.client.post(TAGS_URL, payload)
exists = Tag.objects.filter(
user=self.user,
name=payload['name']
)
self.assertTrue(exists)
def test_create_tag_invalid(self):
"""Test creating a new tag with invalid payload"""
payload = {'name': ''}
res = self.client.post(TAGS_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrive_tags_assigned_to_recipes(self):
"""Test filtering tags by those assigned to recipe"""
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='Lunch')
recipe = Recipe.objects.create(
title='Corianser eggs on toast',
time_minutes=10,
price=5.00,
user=self.user
)
recipe.tags.add(tag1)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
class PrivateRecipeApiTests(TestCase):
"""Test unauthenticated recipe API access"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**',
'testpass'
)
self.client.force_authenticate(self.user)
def test_retrieve_recipes(self):
"""Test retrieving a list of recipes"""
sample_recipe(user=self.user)
sample_recipe(user=self.user)
res = self.client.get(RECIPE_URLS)
recipes = Recipe.objects.all().order_by('-id')
serializer = RecipeSerializer(recipes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_recipes_limited_to_user(self):
"""Test retrieving recipes for users"""
user2 = get_user_model().objects.create_user(
'*****@*****.**',
'pass234'
)
sample_recipe(user=user2)
sample_recipe(user=self.user)
res = self.client.get(RECIPE_URLS)
recipes = Recipe.objects.filter(user=self.user)
serializer = RecipeSerializer(recipes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data, serializer.data)
def test_view_recipe_detail(self):
"""Test viewin a recipe detail"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
recipe.ingredient.add(sample_ingredient(user=self.user))
url = detail_url(recipe.id)
res = self.client.get(url)
serializer = RecipeDetailSerializer(recipe)
self.assertEqual(res.data, serializer.data)
def test_create_basic_recipe(self):
"""Test creating recipe"""
payload = {
'title': 'Chocolate Cheesecake',
'time_minutes': 30,
'price': 5.00
}
res = self.client.post(RECIPE_URLS, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
for key in payload.keys():
self.assertEqual(payload[key], getattr(recipe, key))
def test_create_recipe_with_tags(self):
"""Test creating a recipe with tags"""
tag1 = sample_tag(user=self.user, name='Vegan')
tag2 = sample_tag(user=self.user, name='Dessert')
payload = {
'title': 'Avocado lime cheesecake',
'tags': [tag1.id, tag2.id],
'time_minutes': 60,
'price': 20.00
}
res = self.client.post(RECIPE_URLS, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
tags = recipe.tags.all()
self.assertEqual(tags.count(), 2)
self.assertIn(tag1, tags)
self.assertIn(tag2, tags)
def test_create_recipe_with_ingredients(self):
"""Test creating recipes with ingredients"""
ingredient1 = sample_ingredient(user=self.user, name='Prawns')
ingredient2 = sample_ingredient(user=self.user, name='Ginger')
payload = {
'title': 'Thai prawn red curry',
'ingredient': [ingredient1.id, ingredient2.id],
'time_minutes': 20,
'price': 7.00
}
res = self.client.post(RECIPE_URLS, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
ingredients = recipe.ingredient.all()
self.assertEqual(ingredients.count(), 2)
self.assertIn(ingredient1, ingredients)
self.assertIn(ingredient2, ingredients)
def test_partial_update_recipe(self):
"""Test updating a recipe with PATCH"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
new_tag = sample_tag(user=self.user, name='Curry')
payload = {
'title': 'Chicken tikka',
'tags': [new_tag.id]
}
url = detail_url(recipe.id)
self.client.patch(url, payload)
recipe.refresh_from_db()
self.assertEqual(recipe.title, payload['title'])
tags = recipe.tags.all()
self.assertEqual(len(tags), 1)
self.assertIn(new_tag, tags)
def test_full_update_recipe(self):
"""Test updating a recipe with PUT"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
payload = {
'title': 'Spaghetti',
'time_minutes': 25,
'price': 5.00
}
url = detail_url(recipe.id)
self.client.put(url, payload)
recipe.refresh_from_db()
self.assertEqual(recipe.title, payload['title'])
self.assertEqual(recipe.time_minutes, payload['time_minutes'])
self.assertEqual(recipe.price, payload['price'])
tags = recipe.tags.all()
self.assertEqual(len(tags), 0)
def admin_client(db, admin_user):
client = APIClient()
client.force_authenticate(user=admin_user)
return client
class BulkUserRetirementViewTests(APITestCase):
"""
Tests the bulk user retirement api
"""
def setUp(self):
super().setUp()
login_client = APIClient()
self.user1 = UserFactory.create(username='******',
email='*****@*****.**',
password='******',
profile__name="Test User1")
login_client.login(username=self.user1.username,
password='******')
self.user2 = UserFactory.create(username='******',
email='*****@*****.**',
password='******',
profile__name="Test User2")
login_client.login(username=self.user2.username,
password='******')
self.user3 = UserFactory.create(username='******',
email='*****@*****.**',
password='******',
profile__name="Test User3")
self.user4 = UserFactory.create(username='******',
email='*****@*****.**',
password='******',
profile__name="Test User4")
RetirementState.objects.create(state_name='PENDING',
state_execution_order=1,
is_dead_end_state=False,
required=True)
self.pending_state = RetirementState.objects.get(state_name='PENDING')
# Use a separate client for retirement worker (don't mix cookie state)
self.client = APIClient()
self.client.force_authenticate(user=self.user1)
def test_gdpr_user_retirement_api(self):
user_retirement_url = reverse('bulk_retirement_api')
expected_response = {
'successful_user_retirements': [self.user2.username],
'failed_user_retirements': []
}
with self.settings(
RETIREMENT_SERVICE_WORKER_USERNAME=self.user1.username):
response = self.client.post(user_retirement_url,
{"usernames": self.user2.username})
assert response.status_code == 200
assert response.data == expected_response
retirement_status = UserRetirementStatus.objects.get(
user__username=self.user2.username)
assert retirement_status.current_state == self.pending_state
def test_retirement_for_non_existing_users(self):
user_retirement_url = reverse('bulk_retirement_api')
expected_response = {
'successful_user_retirements': [],
'failed_user_retirements': ["non_existing_user"]
}
with self.settings(
RETIREMENT_SERVICE_WORKER_USERNAME=self.user1.username):
response = self.client.post(user_retirement_url,
{"usernames": "non_existing_user"})
assert response.status_code == 200
assert response.data == expected_response
def test_retirement_for_multiple_users(self):
user_retirement_url = reverse('bulk_retirement_api')
expected_response = {
'successful_user_retirements':
[self.user3.username, self.user4.username],
'failed_user_retirements': []
}
with self.settings(
RETIREMENT_SERVICE_WORKER_USERNAME=self.user1.username):
response = self.client.post(
user_retirement_url,
{"usernames": f'{self.user3.username},{self.user4.username}'})
assert response.status_code == 200
assert sorted(response.data['successful_user_retirements']) == sorted(expected_response['successful_user_retirements']) # pylint: disable=line-too-long
retirement_status_1 = UserRetirementStatus.objects.get(
user__username=self.user3.username)
assert retirement_status_1.current_state == self.pending_state
retirement_status_2 = UserRetirementStatus.objects.get(
user__username=self.user4.username)
assert retirement_status_2.current_state == self.pending_state
def test_retirement_for_multiple_users_with_some_nonexisting_users(self):
user_retirement_url = reverse('bulk_retirement_api')
expected_response = {
'successful_user_retirements':
[self.user3.username, self.user4.username],
'failed_user_retirements': ['non_existing_user']
}
with self.settings(
RETIREMENT_SERVICE_WORKER_USERNAME=self.user1.username):
response = self.client.post(
user_retirement_url, {
"usernames":
'{user1},{user2}, non_existing_user'.format(
user1=self.user3.username, user2=self.user4.username)
})
assert response.status_code == 200
assert sorted(response.data['successful_user_retirements']) == sorted(expected_response['successful_user_retirements']) # pylint: disable=line-too-long
retirement_status_1 = UserRetirementStatus.objects.get(
user__username=self.user3.username)
assert retirement_status_1.current_state == self.pending_state
retirement_status_2 = UserRetirementStatus.objects.get(
user__username=self.user4.username)
assert retirement_status_2.current_state == self.pending_state
def test_retirement_for_unauthorized_users(self):
user_retirement_url = reverse('bulk_retirement_api')
response = self.client.post(user_retirement_url,
{"usernames": self.user2.username})
assert response.status_code == 403
class PrivateIngredientsAPITests(TestCase):
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
"*****@*****.**", "testpass"
)
self.client.force_authenticate(self.user)
def test_retrieve_ingredient_list(self):
"""Test retrieving a list of ingredients"""
Ingredient.objects.create(user=self.user, name="kale")
Ingredient.objects.create(user=self.user, name="Salt")
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by("-name")
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_ingredients_limited_to_user(self):
user2 = get_user_model().objects.create_user(
"*****@*****.**", "testpass"
)
Ingredient.objects.create(user=user2, name="Vinegar")
ingredient = Ingredient.objects.create(user=self.user, name="Tumeric")
res = self.client.get(INGREDIENTS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]["name"], ingredient.name)
def test_create_ingredient_sucessful(self):
payload = {"name": "Carrot"}
self.client.post(INGREDIENTS_URL, payload)
exists = Ingredient.objects.filter(
user=self.user, name=payload["name"]
).exists()
self.assertTrue(exists)
def test_create_invalid_ingredient(self):
payload = {"name": ""}
res = self.client.post(INGREDIENTS_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrieve_ingredients_assigned_to_recipes(self):
ingredient1 = Ingredient.objects.create(user=self.user, name="Apples")
ingredient2 = Ingredient.objects.create(user=self.user, name="Turkey")
recipe = Recipe.objects.create(
title="Apple crumble", time_minutes=5, price=10, user=self.user
)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {"assigned_only": 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredient_assigned_unique(self):
ingredient = Ingredient.objects.create(user=self.user, name="Eggs")
Ingredient.objects.create(user=self.user, name="Cheese")
recipe1 = Recipe.objects.create(
title="Eggs benedict", time_minutes=30, price=12.00, user=self.user
)
recipe1.ingredients.add(ingredient)
recipe2 = Recipe.objects.create(
title="Green eggs on toast",
time_minutes=20,
price=5.00,
user=self.user,
)
recipe2.ingredients.add(ingredient)
res = self.client.get(INGREDIENTS_URL, {"assigned_only": 1})
self.assertEqual(len(res.data), 1)
class PrivateIngredientApiTests(TestCase):
'''Test private ingredients api'''
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'testpass')
self.client.force_authenticate(self.user)
def test_retrieve_ingredients_list(self):
'''retrieving a list of ingredient'''
Ingredient.objects.create(user=self.user, name='kale')
Ingredient.objects.create(user=self.user, name='Salt')
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serialzer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serialzer.data)
def test_ingredients_limited_to_user(self):
'''test that ingredients for the authenticated user are returned'''
user2 = get_user_model().objects.create_user('*****@*****.**',
'testpass')
Ingredient.objects.create(user=user2, name='vinegar')
ingredient = Ingredient.objects.create(user=self.user, name='Tumeric')
res = self.client.get(INGREDIENTS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]['name'], ingredient.name)
def test_create_ingredient_successfull(self):
'''Test create a new ingredient'''
payload = {'name': 'Cabage'}
self.client.post(INGREDIENTS_URL, payload)
exists = Ingredient.objects.filter(
user=self.user,
name=payload['name'],
).exists()
self.assertTrue(exists)
def test_create_ingredient_invalid(self):
'''Test creating invalid ingredient fails'''
payload = {'name': ''}
res = self.client.post(INGREDIENTS_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrieve_ingredient_assigned_to_recipes(self):
''' Test filtering ingredients by those assigned to recipes'''
ingredient1 = Ingredient.objects.create(
user=self.user,
name='Apples',
)
ingredient2 = Ingredient.objects.create(user=self.user, name='Turkey')
recipe = Recipe.objects.create(title='Apple crumble',
time_minutes=5,
price=10.00,
user=self.user)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredients_assign_unique(self):
''' test filtering ingredients by assigned returned unique items'''
ingredient = Ingredient.objects.create(user=self.user, name='eggs')
Ingredient.objects.create(user=self.user, name='cheese')
recipe1 = Recipe.objects.create(title='Eggs benedict',
time_minutes=30,
price=12.00,
user=self.user)
recipe1.ingredients.add(ingredient)
recipe2 = Recipe.objects.create(title='corriender eggs omellte',
time_minutes=30,
price=10.00,
user=self.user)
recipe2.ingredients.add(ingredient)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
self.assertEqual(len(res.data), 1)
class ApiTestCase(TestCase):
"""
Runs tests for the endpoints
"""
def setUp(self):
# client for simulating http requests
self.client = APIClient()
# test user for authenticaction
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
# test data used in the test cases
with open("api_tests/data.json") as data_file:
self.test_data = json.load(data_file)
self.user = user
# force authentication for all requests
self.client.force_authenticate(user=user)
def test_user_can_log_in(self):
"""
Test the login endpoint
/login/
"""
# create a user
User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
credentials = {
"username": "******",
"password": "******"
}
# use credentials of the user created to test the log in
response = self.client.post('/login/', credentials,
format='json')
# assert the login was successful
self.assertEqual(response.status_code,
status.HTTP_200_OK)
data = response.json()
# assert a token is returned for every successfull login
assert "token" in data
def test_if_user_can_retrive_drinks(self):
"""
Test the retrieve drinks enpoint
/data/drinks"
"""
# take data from the ones extracted from the json file
drinks = self.test_data["drinks"]
save_drinks = []
for drink in drinks:
drink = Drink(**drink)
save_drinks.append(drink)
Drink.objects.bulk_create(save_drinks)
drink_count = Drink.objects.count()
# assert the saving of the drinks was successful
self.assertEqual(drink_count, 10)
# retrieve the data via a request
response = self.client.get("/data/drinks/")
# assert the request was successful
self.assertEqual(response.status_code,
status.HTTP_200_OK)
recieved_data_count = len(response.json())
# assert the number of drinks recieved is correct
self.assertEqual(recieved_data_count, 10)
def test_if_user_can_add_and_retrieve_data(self):
"""
Test the add data endpoint
/data/data_collected/
"""
# take the first three drinks
drinks = self.test_data["drinks"][:3]
# create drink objects from the json data
drinks = [Drink(**i) for i in drinks]
Drink.objects.bulk_create(drinks)
data = self.test_data["data"][0]
# use drink ids added to the db for this particular
# test
data["drink_id"] = drinks[random.randint(0, 2)]._id
response = self.client.post("/data/data_collected/",
data, format='json')
# assert it data was added correctly
self.assertEqual(response.status_code,
status.HTTP_201_CREATED)
# retrieve the data added
response = self.client.get("/data/data_collected/")
# assert if the response is 200
self.assertEqual(response.status_code, 200)
# get the number of added data records
data_added_count = len(response.json())
# assert if the data added is one
self.assertEqual(data_added_count, 1)
def test_if_user_can_update_data_added(self):
"""
Test the retrieve one, update and delete endpoint
/data/record/<record_id>/
"""
drink_data = self.test_data["drinks"][0]
# save a drink
drink = Drink(**drink_data)
drink.save()
record_data = self.test_data["data"][0]
data = Data(
favorite_drink=drink,
consumer_name=record_data["consumer_name"],
location=record_data["location"],
collector=self.user,
location_longitude=record_data["location_longitude"],
location_latitude=record_data["location_latitude"]
)
# save a data record
data.save()
# retrieve the added data record
url = "/data/record/%s/" % data._id
get_response = self.client.get(url)
self.assertEqual(get_response.status_code,
status.HTTP_200_OK)
recieved_data = get_response.json()
self.assertEqual(recieved_data["consumer_name"],
"dirk nowitzki")
# update the data record
update_payload = {
"drink_id": str(drink._id),
"consumer_name": "erick omondi",
"location": "buruburu",
"location_longitude": "55.255",
"location_latitude": "74.2245"
}
put_response = self.client.put(url, update_payload, format="json")
self.assertEqual(put_response.status_code,
status.HTTP_200_OK)
# retrieve the updated record
updated_data = Data.objects.all()[0]
# assert it has been updated
self.assertNotEqual(updated_data.consumer_name,
recieved_data["consumer_name"])
# delete the record
delete_response = self.client.delete(url)
# assert the status code is 204 no content
self.assertEqual(delete_response.status_code,
status.HTTP_204_NO_CONTENT)
# assert the record was actually deleted from the database
data_count = Data.objects.count()
self.assertEqual(data_count, 0)
class MoviesAPITestCase(TestCase):
def setUp(self):
self.client = APIClient()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.expected_genre = Genre.objects.create(name='Test Movie Genre')
self.test_movie_data = {
'title': 'Hydrogen',
'release_date': '2006-01-01',
'genres': ['/api/genres/{}/'.format(self.expected_genre.id)]
}
# create
def test_movie_logged_create(self):
self.client.force_authenticate(user=self.user)
response = self.client.post('/api/movies/',
self.test_movie_data,
format='json')
self.client.force_authenticate(user=None)
data = response.data
self.assertEqual(response.status_code, 201)
self.assertEqual(data.get('title'), self.test_movie_data['title'])
self.assertEqual(data.get('release_date'),
self.test_movie_data['release_date'])
self.assertTrue('/genres/{}'.format(self.expected_genre.id) in
','.join(data.get('genres')))
def test_movie_anon_create(self):
response = self.client.post('/api/movies/',
self.test_movie_data,
format='json')
self.assertEqual(response.status_code, 403)
# read
def test_movie_logged_read(self):
test_movie = Movie.objects.create(
title=self.test_movie_data['title'],
release_date=self.test_movie_data['release_date'])
test_movie.genres.add(self.expected_genre.id)
test_movie.save()
self.client.force_authenticate(user=self.user)
response = self.client.get('/api/movies/{}/'.format(test_movie.id),
format='json')
self.client.force_authenticate(user=None)
data = response.data
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get('title'), self.test_movie_data['title'])
self.assertEqual(data.get('release_date'),
self.test_movie_data['release_date'])
def test_movie_anon_read(self):
test_movie = Movie.objects.create(
title=self.test_movie_data['title'],
release_date=self.test_movie_data['release_date'])
test_movie.genres.add(self.expected_genre.id)
test_movie.save()
self.client.force_authenticate(user=self.user)
response = self.client.get('/api/movies/{}/'.format(test_movie.id),
format='json')
data = response.data
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get('title'), self.test_movie_data['title'])
self.assertEqual(data.get('release_date'),
self.test_movie_data['release_date'])
# update
def test_movie_logged_update(self):
test_movie = Movie.objects.create(
title=self.test_movie_data['title'],
release_date=self.test_movie_data['release_date'])
test_movie.genres.add(self.expected_genre.id)
test_movie.save()
expected_movie_data = {
'title': 'Updated Title',
'release_date': '1970-01-01',
'genres': ['/api/genres/{}/'.format(self.expected_genre.id)]
}
self.client.force_authenticate(user=self.user)
response = self.client.put('/api/movies/{}/'.format(test_movie.id),
expected_movie_data,
format='json')
self.client.force_authenticate(user=None)
data = response.data
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get('title'), expected_movie_data['title'])
self.assertEqual(data.get('release_date'),
expected_movie_data['release_date'])
def test_movie_anon_update(self):
test_movie = Movie.objects.create(
title=self.test_movie_data['title'],
release_date=self.test_movie_data['release_date'])
test_movie.genres.add(self.expected_genre.id)
test_movie.save()
expected_movie_data = {
'title': 'Updated Title',
'release_date': '1970-01-01',
'genres': ['/api/genres/{}/'.format(self.expected_genre.id)]
}
response = self.client.put('/api/movies/{}/'.format(test_movie.id),
expected_movie_data,
format='json')
self.assertEqual(response.status_code, 403)
# delete
def test_movie_logged_delete(self):
test_movie = Movie.objects.create(
title=self.test_movie_data['title'],
release_date=self.test_movie_data['release_date'])
test_movie.genres.add(self.expected_genre.id)
test_movie.save()
self.client.force_authenticate(user=self.user)
response = self.client.delete('/api/movies/{}/'.format(test_movie.id),
format='json')
self.client.force_authenticate(user=None)
self.assertEqual(response.status_code, 204)
def test_movie_anon_delete(self):
test_movie = Movie.objects.create(
title=self.test_movie_data['title'],
release_date=self.test_movie_data['release_date'])
test_movie.genres.add(self.expected_genre.id)
test_movie.save()
response = self.client.delete('/api/movies/{}/'.format(test_movie.id),
format='json')
self.assertEqual(response.status_code, 403)
# list
def test_movie_logged_list(self):
test_movies = ['Helium', 'Neon', 'Argon', 'Krypton', 'Xenon', 'Radon']
for movie in test_movies:
m = Movie.objects.create(
title=movie, release_date=self.test_movie_data['release_date'])
m.genres.add(self.expected_genre)
m.save()
self.client.force_authenticate(user=self.user)
response = self.client.get('/api/movies/', format='json')
self.client.force_authenticate(user=None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('count'), len(test_movies))
def test_movie_anon_list(self):
test_movies = ['Helium', 'Neon', 'Argon', 'Krypton', 'Xenon', 'Radon']
for movie in test_movies:
m = Movie.objects.create(
title=movie, release_date=self.test_movie_data['release_date'])
m.genres.add(self.expected_genre)
m.save()
response = self.client.get('/api/movies/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('count'), len(test_movies))
# filter by genre
def test_movie_genre_filter(self):
test_movies = ['Helium', 'Neon', 'Argon', 'Krypton', 'Xenon', 'Radon']
another_genre = Genre.objects.create(name='Another Genre')
for idx, movie in enumerate(test_movies):
m = Movie.objects.create(
title=movie, release_date=self.test_movie_data['release_date'])
if idx % 2 > 0:
m.genres.add(self.expected_genre)
else:
m.genres.add(another_genre)
m.save()
# single filter
response = self.client.get('/api/movies/?genres={}'.format(
another_genre.id),
format='json')
data = response.data
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get('count'), 3)
# multiple filter
response = self.client.get('/api/movies/?genres={}&genres={}'.format(
self.expected_genre.id, another_genre.id),
format='json')
data = response.data
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get('count'), 6)
# sequels count
def test_movie_sequels_count(self):
test_movies = [
'The Godfather', 'The Godfather Part II', 'The Godfather Part III'
]
movies = []
for movie in test_movies:
m = Movie.objects.create(
title=movie, release_date=self.test_movie_data['release_date'])
m.genres.add(self.expected_genre)
m.save()
movies.append(m)
# sequels
response = self.client.get('/api/movies/{}/'.format(movies[0].id),
format='json')
data = response.data
self.assertEqual(data.get('sequels_count'), 2)
response = self.client.get('/api/movies/{}/'.format(movies[1].id),
format='json')
data = response.data
self.assertEqual(data.get('sequels_count'), 1)
# no sequels
response = self.client.get('/api/movies/{}/'.format(movies[2].id),
format='json')
data = response.data
self.assertEqual(data.get('sequels_count'), 0)
class ClanViewsTestCase(TestCase):
def setUp(self):
self.game = Game.objects.create(game='Test', slug='test')
self.user = User.objects.create(username='******',
password='******',
game=self.game)
self.client = APIClient()
self.client.force_authenticate(user=self.user)
def test_clan_list(self):
"""TEST VIEW ClanListView OK (GET): Get list of all clans"""
n = 5
users = [
User.objects.create(username=f'Test{index}',
password='******',
game=self.game) for index in range(n)
]
clans = [
GameClan.create(creator=user,
name=f'{user.username} Clan',
description='TEST',
game=self.game) for user in users
]
url = reverse('clans')
response = self.client.get(url)
self.assertEqual(n, len(response.data))
def test_creating_clan__creating_clan_member__creating_clan_chat(self):
"""TEST VIEW ClanListView OK (GET): Creating ClanMember and ClanChat while creating clan"""
url = reverse('clan-create')
data = {"name": "Test", "description": "TestClan"}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(self.user.my_clan.name, 'Test')
self.assertEqual(self.user.my_clan.chat.name, 'Test')
self.assertEqual(self.user.my_clan.creator, self.user)
self.assertTrue(self.user.clan_member)
def test_creating_clan__invalid_name(self):
"""TEST VIEW ClanListView BAD REQUEST (GET): Create clan if name not UNIQUE"""
clan_name = 'CLAN'
new_user = User.objects.create(username=f'Test1',
password='******',
game=self.game)
clan = GameClan.create(creator=new_user,
name=f'{clan_name}',
description='TEST',
game=self.game)
url = reverse('clan-create')
data = {"name": clan_name, "description": "TestClan"}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_creating_clan__invalid_creator(self):
"""TEST VIEW ClanListView BAD REQUEST (GET): Create clan, But creator must be UNIQUE and have a game"""
clan = GameClan.create(creator=self.user,
name='TEST',
description='TEST',
game=self.game)
url = reverse('clan-create')
data = {"name": 'Test1', "description": "TestClan"}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
new_client = APIClient()
new_client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_clan_detail_view(self):
"""TEST VIEW ClanView OK (GET): Get GameClan"""
new_user = User.objects.create(username=f'Test1',
password='******',
game=self.game)
clan = GameClan.create(creator=new_user,
name='TEST1',
description='TEST',
game=self.game)
clan = GameClan.create(creator=self.user,
name='TEST',
description='TEST',
game=self.game)
url = reverse('clan')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.client.get(url + '?id=2', )
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_clan_detail_view__clan_not_exist(self):
"""TEST VIEW ClanView BAD REQUEST (GET): Get GameClan, But Clan not exist"""
url = reverse('clan')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
response = self.client.get(url + '?id=2')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_clan_update(self):
"""TEST VIEW UpdateClanView OK (POST): Update GameClan"""
clan = GameClan.create(creator=self.user,
name='TEST1',
description='TEST',
game=self.game)
url = reverse('clan-update')
data = {'name': 'Test1', 'description': 'TEST!', 'max_members': 2}
response = self.client.post(url, data)
clan.refresh_from_db()
self.assertEqual(status.HTTP_200_OK, response.status_code)
self.assertEqual(data['name'], clan.name)
self.assertEqual(data['description'], clan.description)
self.assertEqual(data['max_members'], clan.max_members)
def test_clan_update__invalid_clan_id(self):
"""TEST VIEW UpdateClanView BAD REQUEST (POST): Update GameClan, But Clan do not exist"""
url = reverse('clan-update')
data = {'name': 'Test1', 'description': 'TEST!', 'max_members': 2}
response = self.client.post(url, data)
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
def test_clan_update__invalid_user(self):
"""TEST VIEW UpdateClanView BAD REQUEST (POST): Update GameClan, But not from creator"""
new_user = User.objects.create(username=f'Test1',
password='******',
game=self.game)
clan = GameClan.create(creator=new_user,
name='TEST1',
description='TEST',
game=self.game)
url = reverse('clan-update')
data = {'name': 'Test1', 'description': 'TEST!', 'max_members': 2}
response = self.client.post(url, data)
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
def test_clan_update__invalid_unique_name(self):
"""TEST VIEW UpdateClanView BAD REQUEST (POST): Update GameClan, But clan with such name already exist"""
new_user = User.objects.create(username=f'Test1',
password='******',
game=self.game)
clan2 = GameClan.create(creator=new_user,
name='TEST1',
description='TEST',
game=self.game)
clan1 = GameClan.create(creator=self.user,
name='TEST2',
description='TEST',
game=self.game)
url = reverse('clan-update')
data = {'name': 'TEST1', 'description': 'TEST!', 'max_members': 2}
response = self.client.post(url, data)
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
def test_clan_delete(self):
"""TEST VIEW DeleteClanView OK (POST): Delete GameClan"""
new_user = User.objects.create(username=f'Test1',
password='******',
game=self.game)
clan = GameClan.create(creator=self.user,
name='TEST',
description='TEST',
game=self.game)
url = reverse('clan-delete')
data = {}
response = self.client.post(url, data)
self.assertEqual(status.HTTP_200_OK, response.status_code)
def test_clan_remove_member(self):
"""TEST VIEW RemoveClanMember OK (POST): Remove User from the GameClan"""
clan = GameClan.create(creator=self.user,
name='TEST',
description='TEST',
game=self.game)
new_user = User.objects.create(username='******',
password='******',
game=self.game)
clan.add(new_user)
url = reverse('clan-remove-member')
param = f'?member_id={new_user.id}'
response = self.client.post(url + param)
self.assertEqual(status.HTTP_200_OK, response.status_code)
def test_clan_remove_invalid__user_not_exists(self):
"""TEST VIEW RemoveClanMemberView BAD REQUEST (POST): Removing User from the GameClan,
But User not exists"""
clan = GameClan.create(creator=self.user,
name='TEST',
description='TEST',
game=self.game)
url = reverse('clan-remove-member')
param = f'?member_id=10'
response = self.client.post(url + param)
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
def test_clan_remove_invalid__user_not_in_user_clan(self):
"""TEST VIEW RemoveClanMemberView BAD REQUEST (POST): Removing User from the GameClan,
But User in another GameClan"""
clan = GameClan.create(creator=self.user,
name='TEST',
description='TEST',
game=self.game)
new_user = User.objects.create(username='******',
password='******',
game=self.game)
clan = GameClan.create(creator=new_user,
name='TEST1',
description='TEST',
game=self.game)
url = reverse('clan-remove-member')
param = f'?member_id={new_user.id}'
response = self.client.post(url + param)
self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
class OrganizationTestCase(APITestCase):
def setUp(self):
self.client = APIClient()
# Create each type of user that could be making the registration request
self.system_admin = CustomUser.objects.create(
user_name='system_admin1',
email='*****@*****.**',
password='******',
first_name='system1',
last_name='admin1',
role='SA',
is_active=True)
self.inventory_manager = CustomUser.objects.create(
user_name='inventory_manager1',
email='*****@*****.**',
password='******',
first_name='inventory1',
last_name='manage1r',
role='IM',
is_active=True)
@factory.django.mute_signals(signals.pre_save, signals.post_save)
def test_create_organization_sys_admin_success(self):
""" Organization was created correctly """
self.client.force_authenticate(user=self.system_admin)
data = {'org_name': 'test_case'}
response = self.client.post("/organization/", data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create_organization_inventory_manager_success(self):
""" Inventory manager is not allowed to create an organization """
self.client.force_authenticate(user=self.inventory_manager)
data = {'org_name': 'test_case'}
response = self.client.post("/organization/", data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_create_organization_failure(self):
""" User can't create organization if missing fields """
self.client.force_authenticate(user=self.system_admin)
data = {}
response = self.client.post("/organization/", data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_organization_unauthorized_request(self):
""" User can't access any of the method if token is not in header of request """
response = self.client.get("/organization/")
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_organization_unauthorized_clearence(self):
""" IM can create or delete an organization """
self.client.force_authenticate(user=self.inventory_manager)
response = self.client.delete("/organization/")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_get_all_organization(self):
""" IM can get a list of organization """
self.client.force_authenticate(user=self.inventory_manager)
response = self.client.get("/organization/")
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
class GenreAPITestCase(APITransactionTestCase):
def setUp(self):
self.client = APIClient()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
# create
def test_genre_logged_create(self):
expected_name = 'Test Genre'
self.client.force_authenticate(user=self.user)
response = self.client.post('/api/genres/', {'name': expected_name},
format='json')
self.client.force_authenticate(user=None)
test_genre = Genre.objects.get(name=expected_name)
self.assertEqual(response.status_code, 201)
self.assertEqual(test_genre.name, expected_name)
def test_genre_anon_create(self):
expected_name = 'Test Genre'
response = self.client.post('/api/genres/', {'name': expected_name},
format='json')
self.assertEqual(response.status_code, 403)
# read
def test_genre_logged_read(self):
expected_name = 'Test Genre'
test_genre = Genre.objects.create(name=expected_name)
self.client.force_authenticate(user=self.user)
response = self.client.get('/api/genres/{}/'.format(test_genre.id),
format='json')
self.client.force_authenticate(user=None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('name'), expected_name)
def test_genre_anon_read(self):
expected_name = 'Test Genre'
test_genre = Genre.objects.create(name=expected_name)
response = self.client.get('/api/genres/{}/'.format(test_genre.id),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('name'), expected_name)
# update
def test_genre_logged_update(self):
initial_name = 'Test Genre'
expected_name = 'Updated Genre'
test_genre = Genre.objects.create(name=initial_name)
self.client.force_authenticate(user=self.user)
response = self.client.put('/api/genres/{}/'.format(test_genre.id),
{'name': expected_name},
format='json')
self.client.force_authenticate(user=None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('name'), expected_name)
def test_genre_anon_update(self):
initial_name = 'Test Genre'
expected_name = 'Updated Genre'
test_genre = Genre.objects.create(name=initial_name)
response = self.client.put('/api/genres/{}/'.format(test_genre.id),
{'name': expected_name},
format='json')
self.assertEqual(response.status_code, 403)
# delete
def test_genre_logged_delete(self):
test_genre = Genre.objects.create(name='Test Genre')
self.client.force_authenticate(user=self.user)
response = self.client.delete('/api/genres/{}/'.format(test_genre.id),
format='json')
self.client.force_authenticate(user=None)
self.assertEqual(response.status_code, 204)
def test_genre_anon_delete(self):
test_genre = Genre.objects.create(name='Test Genre')
response = self.client.delete('/api/genres/{}/'.format(test_genre.id),
format='json')
self.assertEqual(response.status_code, 403)
# list
def test_genre_logged_list(self):
test_genres = ['Helium', 'Neon', 'Argon', 'Krypton', 'Xenon', 'Radon']
for genre_name in test_genres:
Genre.objects.create(name=genre_name)
self.client.force_authenticate(user=self.user)
response = self.client.get('/api/genres/', format='json')
self.client.force_authenticate(user=None)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('count'), len(test_genres))
def test_genre_anon_list(self):
test_genres = ['Helium', 'Neon', 'Argon', 'Krypton', 'Xenon', 'Radon']
for genre_name in test_genres:
Genre.objects.create(name=genre_name)
response = self.client.get('/api/genres/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('count'), len(test_genres))
# movie counts
def test_genre_movie_count(self):
test_genre = Genre.objects.create(name='Test Genre')
another_genre = Genre.objects.create(name='Another Genre')
test_movies = ['Helium', 'Neon', 'Argon', 'Krypton', 'Xenon', 'Radon']
for idx, movie in enumerate(test_movies):
test_movie_data = {'title': movie, 'release_date': '2006-01-01'}
m = Movie.objects.create(**test_movie_data)
if idx % 2 > 0:
m.genres.add(test_genre)
else:
m.genres.add(another_genre)
m.save()
response = self.client.get('/api/genres/{}/'.format(test_genre.id),
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data.get('movie_count'), 3)
def test_delete_other_family(self):
client = APIClient(HTTP_X_REAL_IP='127.0.0.1')
client.force_authenticate(user=self.user)
url = '/api/relation/{0}/'.format(self.relation3.id)
response = client.delete(url, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class PrivateIngredientsApiTests(TestCase):
"""test ing can be retr by auth user"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**',
'pass123'
)
self.client.force_authenticate(self.user)
def test_retrieve_ingredient_list(self):
"""Test retr a list of ingr"""
Ingredient.objects.create(user=self.user, name='Kale')
Ingredient.objects.create(user=self.user, name='Salt')
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_ingredients_limited_to_user(self):
"""Test that ingr for the auth user are ret"""
user2 = get_user_model().objects.create_user(
'*****@*****.**',
'test2pass'
)
Ingredient.objects.create(user=user2, name='Vinegar')
ingredient = Ingredient.objects.create(user=self.user, name='Tumeric')
res = self.client.get(INGREDIENTS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]['name'], ingredient.name)
def test_create_ingredient_successful(self):
"""Test create a new ingredient"""
payload = {'name': 'Cabbbage'}
self.client.post(INGREDIENTS_URL, payload)
exists = Ingredient.objects.filter(
user=self.user,
name=payload['name']
).exists()
self.assertTrue(exists)
def test_create_ingredient_invalid(self):
"""createing invalid ingredient fails"""
payload = {'name': ''}
res = self.client.post(INGREDIENTS_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrieve_ingredients_assigned_to_recipes(self):
"""test filtering by those assigned to recipes"""
ingredient1 = Ingredient.objects.create(
user=self.user, name='Apples'
)
ingredient2 = Ingredient.objects.create(
user=self.user, name='Turkey'
)
recipe = Recipe.objects.create(
title='Apple crumble',
time_minutes=5,
price=10,
user=self.user
)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def test_retrieve_ingredients_assigned_unique(self):
"""Test filtering ingredients by assigned teturns unique items"""
ingredient = Ingredient.objects.create(user=self.user, name='Eggs')
Ingredient.objects.create(user=self.user, name='Chees')
recipe1 = Recipe.objects.create(
title='Eggs benedict',
time_minutes=31,
price=12.00,
user=self.user
)
recipe1.ingredients.add(ingredient)
recipe2 = Recipe.objects.create(
title='Coriander eggs on toast',
time_minutes=21,
price=4.00,
user=self.user
)
recipe2.ingredients.add(ingredient)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
self.assertEqual(len(res.data), 1)
class PrivateMasterRunApiTests(TestCase):
"""Test the master run API"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'pass123')
self.client.force_authenticate(self.user)
def test_retrieve_master_run_list(self):
"""Test retrieving master run list"""
MasterRun.objects.create(user=self.user,
date=make_aware(datetime.datetime.now()),
am=True,
vehicle=sample_vehicle(user=self.user))
MasterRun.objects.create(user=self.user,
date=make_aware(datetime.datetime.now()),
am=True,
vehicle=sample_vehicle(user=self.user))
res = self.client.get(MASTER_RUN_API)
master_runs = MasterRun.objects.all()
serializer = MasterRunSerializer(master_runs, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_create_master_run(self):
"""Test creating a master run"""
payload = {
'user': self.user,
'date': make_aware(datetime.datetime.now()),
'am': True,
'vehicle': sample_vehicle(user=self.user).id
}
res = self.client.post(MASTER_RUN_API, payload)
exists = MasterRun.objects.filter(user=self.user,
date=payload['date'],
am=payload['am'],
vehicle=payload['vehicle']).exists()
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
self.assertTrue(exists)
def test_partial_update_master_run(self):
"""Test updating a master run with patch"""
master_run = sample_master_run(user=self.user,
vehicle=sample_vehicle(user=self.user))
payload = {'am': False, 'pm': True}
url = detail_url(master_run.id)
res = self.client.patch(url, payload)
master_run.refresh_from_db()
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(master_run.am, payload['am'])
self.assertEqual(master_run.pm, payload['pm'])
def test_full_update_master_run(self):
"""Test updating master run with put"""
master_run = sample_master_run(user=self.user,
vehicle=sample_vehicle(user=self.user))
new_vehicle = sample_vehicle(user=self.user)
payload = {
'date': make_aware(datetime.datetime.now()),
'vehicle': new_vehicle.id,
'am': False,
'pm': True
}
url = detail_url(master_run.id)
res = self.client.put(url, payload)
master_run.refresh_from_db()
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(master_run.am, payload['am'])
self.assertEqual(master_run.pm, payload['pm'])
self.assertEqual(master_run.vehicle, new_vehicle)
def test_delete_master_run(self):
"""Test deleting a master run"""
master_run = sample_master_run(user=self.user,
vehicle=sample_vehicle(user=self.user))
url = detail_url(master_run.id)
res = self.client.delete(url)
self.assertEqual(res.status_code, status.HTTP_204_NO_CONTENT)
def test_create_master_run_with_drivers(self):
"""Test creating master run with drivers"""
driver1 = sample_user('*****@*****.**', 'pass222')
driver2 = sample_user('*****@*****.**', 'pass222')
payload = {
'user': self.user,
'date': make_aware(datetime.datetime.now()),
'am': True,
'vehicle': sample_vehicle(user=self.user).id,
'drivers': [driver1.id, driver2.id]
}
res = self.client.post(MASTER_RUN_API, payload)
url = detail_url(res.data['id'])
master_run = self.client.get(url)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
self.assertEqual(len(master_run.data['drivers']), 2)
self.assertIn(driver1.id, master_run.data['drivers'])
self.assertIn(driver2.id, master_run.data['drivers'])
def test_create_master_run_with_runs(self):
"""Test creating master runs with runs"""
run1 = sample_run(
user=self.user,
deposit_location=sample_address(user=self.user),
pick_up_location=sample_address(user=self.user,
address1='Mamie michon'),
master_run=sample_master_run(
user=self.user, vehicle=sample_vehicle(user=self.user)),
patient=sample_patient(user=self.user,
address=sample_address(user=self.user)))
run2 = sample_run(
user=self.user,
deposit_location=sample_address(user=self.user),
pick_up_location=sample_address(user=self.user,
address1='Mamie Fleury'),
master_run=sample_master_run(
user=self.user, vehicle=sample_vehicle(user=self.user)),
patient=sample_patient(user=self.user,
address=sample_address(user=self.user)))
payload = {
'user': self.user,
'date': make_aware(datetime.datetime.now()),
'am': True,
'vehicle': sample_vehicle(user=self.user).id,
'runs': [run1.id, run2.id]
}
res = self.client.post(MASTER_RUN_API, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
master_run = MasterRun.objects.get(id=res.data['id'])
runs = master_run.runs.all()
self.assertEqual(len(runs), 2)
self.assertIn(run1, runs)
self.assertIn(run2, runs)
class PrivateIngredientsAPITests(TestCase):
"""Test the private ingredients API."""
def setUp(self) -> None:
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'testpassword123')
self.client = APIClient()
self.client.force_authenticate(user=self.user)
def test_login_required(self):
self.client.force_authenticate(user=None, token=None)
response = self.client.get(INGREDIENTS_URL)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_retrieve_ingredients_list(self):
"""Test retrieving a list of ingredients."""
Ingredient.objects.create(user=self.user, name='Mango')
Ingredient.objects.create(user=self.user, name='Banana')
# valid data for comparison
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
# api response
response = self.client.get(INGREDIENTS_URL)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_ingredients_limited_to_user(self):
"""Test that ingredients only for the authenticated user are returned."""
another_user = get_user_model().objects.create_user(
email='*****@*****.**', password='******')
# ingredient assigned to another user that we won't be abl to see
Ingredient.objects.create(user=another_user, name='Papaya')
# The only visible ingredient
lime = Ingredient.objects.create(user=self.user, name='Lime')
# api response
response = self.client.get(INGREDIENTS_URL)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['name'], lime.name)
def test_create_ingredient_successful(self):
"""Test creating a new ingredient."""
payload = {'name': 'Pineapple'}
response = self.client.post(INGREDIENTS_URL, payload)
exists = Ingredient.objects.filter(user=self.user,
name=payload['name']).exists()
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertTrue(exists)
def test_create_ingredient_invalid(self):
"""Test create an invalid ingredient fails."""
payload = {'name': ''}
response = self.client.post(INGREDIENTS_URL, payload)
self.assertTrue(response.status_code, status.HTTP_400_BAD_REQUEST)
class PrivateRecipeApiTest(TestCase):
"""Test unauthenticated recipe API access"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'testpass')
self.client.force_authenticate(self.user)
def test_retrieve_recipes(self):
"""Test retrivieng a list of recipes"""
sample_recipe(user=self.user)
sample_recipe(user=self.user)
res = self.client.get(RECIPES_URL)
recipes = Recipe.objects.all().order_by('-id')
serializer = RecipeSerializer(recipes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_recipes_limited_to_user(self):
"""Test retrieving recipes for user"""
user2 = get_user_model().objects.create_user('*****@*****.**',
'pass123')
sample_recipe(user=user2)
sample_recipe(user=self.user)
res = self.client.get(RECIPES_URL)
recipes = Recipe.objects.filter(user=self.user)
serializer = RecipeSerializer(recipes, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data, serializer.data)
def test_view_recipe_detail(self):
"""Test viewing a recipe detail"""
recipe = sample_recipe(user=self.user)
recipe.tags.add(sample_tag(user=self.user))
recipe.ingredients.add(sample_ingredient(user=self.user))
url = detail_url(recipe.id)
res = self.client.get(url)
serializer = RecipeDetailSerializer(recipe)
self.assertEqual(res.data, serializer.data)
def test_create_basic_recipe(self):
"""Test creating recipe"""
payload = {
'title': 'Chocolate cheesecake',
'time_minutes': 30,
'price': 5.00
}
res = self.client.post(RECIPES_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
for key in payload.keys():
self.assertEqual(payload[key], getattr(recipe, key))
def test_create_recipe_with_tags(self):
"""Test creating a recipe with tags"""
tag1 = sample_tag(user=self.user, name='Vegan')
tag2 = sample_tag(user=self.user, name='Dessert')
payload = {
'title': 'Avocado lime cheesecake',
'tags': [tag1.id, tag2.id],
'time_minutes': 60,
'price': 20.00
}
res = self.client.post(RECIPES_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
tags = recipe.tags.all()
self.assertEqual(tags.count(), 2)
self.assertIn(tag1, tags)
self.assertIn(tag2, tags)
def test_create_recipe_with_ingredients(self):
"""Test creating recipe with ingredients"""
ingredient1 = sample_ingredient(user=self.user, name='Tomato')
ingredient2 = sample_ingredient(user=self.user, name='Ginger')
payload = {
'title': 'Thay curry',
'ingredients': [ingredient1.id, ingredient2.id],
'time_minutes': 20,
'price': 7.00
}
res = self.client.post(RECIPES_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
ingredients = recipe.ingredients.all()
self.assertEqual(ingredients.count(), 2)
self.assertIn(ingredient1, ingredients)
self.assertIn(ingredient2, ingredients)
class TestViews(APITestCase):
def setUp(self):
self.client = APIClient()
"""Define url"""
self.login_url = reverse('login')
self.leaderboard_url = reverse('leaderboard')
self.students_url = reverse('students')
self.questions_url = reverse('questions')
self.questions_submit_url = reverse('questions_submit')
self.create_questions_url = reverse('create-questions')
self.game_summary_url = reverse('gameSummary')
"""create a user"""
self.credentials = {
'email': '*****@*****.**',
'password': '******',
'name': 'testuser',
}
self.user = User.objects.create_user(**self.credentials)
"""create World"""
world1 = World.objects.create(name="1")
world2 = World.objects.create(name="2")
"""create section"""
section1 = Section.objects.create(name="1")
section2 = Section.objects.create(name="2")
"""create questions"""
question1 = Questions_teacher.objects.create(questionBody="1+1 = ?",
worldID=world1,
sectionID=section1,
role="frontend",
questionLevel=1)
""" create question answers for the question"""
Questions_answer.objects.create(questionID=question1,
questionText="1",
isCorrect=False)
Questions_answer.objects.create(questionID=question1,
questionText="2",
isCorrect=True)
Questions_answer.objects.create(questionID=question1,
questionText="3",
isCorrect=False)
Questions_answer.objects.create(questionID=question1,
questionText="4",
isCorrect=False)
self.question = question1
"""create questions"""
question2 = Questions_teacher.objects.create(questionBody="2+2 = ?",
worldID=world1,
sectionID=section1,
role="frontend",
questionLevel=1)
""" create question answers for the question"""
Questions_answer.objects.create(questionID=question2,
questionText="1",
isCorrect=False)
Questions_answer.objects.create(questionID=question2,
questionText="2",
isCorrect=False)
Questions_answer.objects.create(questionID=question2,
questionText="3",
isCorrect=False)
Questions_answer.objects.create(questionID=question2,
questionText="4",
isCorrect=True)
"""create question History for the questions"""
questionHistory.objects.create(worldID=question2.worldID,
sectionID=question2.sectionID,
questionID=question2,
studentID=self.user,
isAnsweredCorrect=True,
studentAnswer='4')
""" create a question """
question3 = Questions_teacher.objects.create(questionBody="1*1 = ?",
worldID=world1,
sectionID=section2,
role="frontend",
questionLevel=1)
""" create question answer for question """
Questions_answer.objects.create(questionID=question3,
questionText="1",
isCorrect=True)
Questions_answer.objects.create(questionID=question3,
questionText="2",
isCorrect=False)
Questions_answer.objects.create(questionID=question3,
questionText="3",
isCorrect=False)
Questions_answer.objects.create(questionID=question3,
questionText="4",
isCorrect=False)
""" create question History for question"""
questionHistory.objects.create(worldID=question3.worldID,
sectionID=question3.sectionID,
questionID=question3,
studentID=self.user,
isAnsweredCorrect=False,
studentAnswer='4')
""" create a question """
question4 = Questions_teacher.objects.create(questionBody="2*2 = ?",
worldID=world1,
sectionID=section2,
role="frontend",
questionLevel=1)
""" create question answer for question """
Questions_answer.objects.create(questionID=question4,
questionText="1",
isCorrect=False)
Questions_answer.objects.create(questionID=question4,
questionText="2",
isCorrect=False)
Questions_answer.objects.create(questionID=question4,
questionText="3",
isCorrect=False)
Questions_answer.objects.create(questionID=question4,
questionText="4",
isCorrect=True)
""" create question history for the question """
questionHistory.objects.create(worldID=question4.worldID,
sectionID=question4.sectionID,
questionID=question4,
studentID=self.user,
isAnsweredCorrect=True,
studentAnswer='4')
""" create question """
question5 = Questions_teacher.objects.create(questionBody="10+10 = ?",
worldID=world1,
sectionID=section1,
role="frontend",
questionLevel=2)
""" create question answer for question"""
Questions_answer.objects.create(questionID=question5,
questionText="10",
isCorrect=False)
Questions_answer.objects.create(questionID=question5,
questionText="20",
isCorrect=True)
Questions_answer.objects.create(questionID=question5,
questionText="30",
isCorrect=False)
Questions_answer.objects.create(questionID=question5,
questionText="40",
isCorrect=False)
""" create question history for question"""
questionHistory.objects.create(worldID=question5.worldID,
sectionID=question5.sectionID,
questionID=question5,
studentID=self.user,
isAnsweredCorrect=False,
studentAnswer='40')
""" create question """
question6 = Questions_teacher.objects.create(questionBody="10+20 = ?",
worldID=world1,
sectionID=section1,
role="frontend",
questionLevel=2)
""" create question answer for question """
Questions_answer.objects.create(questionID=question6,
questionText="10",
isCorrect=False)
Questions_answer.objects.create(questionID=question6,
questionText="20",
isCorrect=False)
Questions_answer.objects.create(questionID=question6,
questionText="30",
isCorrect=True)
Questions_answer.objects.create(questionID=question6,
questionText="40",
isCorrect=False)
""" create question history for question"""
questionHistory.objects.create(worldID=question6.worldID,
sectionID=question6.sectionID,
questionID=question6,
studentID=self.user,
isAnsweredCorrect=True,
studentAnswer='30')
""" create question """
question7 = Questions_teacher.objects.create(questionBody="10*10 = ?",
worldID=world1,
sectionID=section2,
role="frontend",
questionLevel=2)
""" create question answer for question"""
Questions_answer.objects.create(questionID=question7,
questionText="100",
isCorrect=True)
Questions_answer.objects.create(questionID=question7,
questionText="200",
isCorrect=False)
Questions_answer.objects.create(questionID=question7,
questionText="300",
isCorrect=False)
Questions_answer.objects.create(questionID=question7,
questionText="400",
isCorrect=False)
""" create question history for question"""
questionHistory.objects.create(worldID=question7.worldID,
sectionID=question7.sectionID,
questionID=question7,
studentID=self.user,
isAnsweredCorrect=True,
studentAnswer='100')
""" create question """
question8 = Questions_teacher.objects.create(questionBody="20*10 = ?",
worldID=world1,
sectionID=section1,
role="frontend",
questionLevel=2)
""" create question answer for question"""
Questions_answer.objects.create(questionID=question8,
questionText="100",
isCorrect=False)
Questions_answer.objects.create(questionID=question8,
questionText="200",
isCorrect=True)
Questions_answer.objects.create(questionID=question8,
questionText="300",
isCorrect=False)
Questions_answer.objects.create(questionID=question8,
questionText="400",
isCorrect=False)
""" create question histroy for question"""
questionHistory.objects.create(worldID=question8.worldID,
sectionID=question8.sectionID,
questionID=question8,
studentID=self.user,
isAnsweredCorrect=True,
studentAnswer='200')
""" create question """
question9 = Questions_teacher.objects.create(questionBody=" x + y = ?",
worldID=world2,
sectionID=section1,
role="frontend",
questionLevel=1)
""" create question answer for question """
Questions_answer.objects.create(questionID=question9,
questionText="x",
isCorrect=False)
Questions_answer.objects.create(questionID=question9,
questionText="x+y",
isCorrect=True)
Questions_answer.objects.create(questionID=question9,
questionText="y",
isCorrect=False)
Questions_answer.objects.create(questionID=question9,
questionText="y",
isCorrect=False)
""" create question history for question """
questionHistory.objects.create(worldID=question9.worldID,
sectionID=question9.sectionID,
questionID=question9,
studentID=self.user,
isAnsweredCorrect=False,
studentAnswer='x')
""" create question"""
question10 = Questions_teacher.objects.create(questionBody="y+x = ?",
worldID=world2,
sectionID=section1,
role="frontend",
questionLevel=2)
""" create question answer """
Questions_answer.objects.create(questionID=question10,
questionText="x",
isCorrect=False)
Questions_answer.objects.create(questionID=question10,
questionText="x+y",
isCorrect=True)
Questions_answer.objects.create(questionID=question10,
questionText="y",
isCorrect=False)
Questions_answer.objects.create(questionID=question10,
questionText="x",
isCorrect=False)
""" create question history for question """
questionHistory.objects.create(worldID=question10.worldID,
sectionID=question10.sectionID,
questionID=question10,
studentID=self.user,
isAnsweredCorrect=False,
studentAnswer='x')
def test_user_login_with_no_data(self):
"""test user login with no input is not successful """
res = self.client.post(self.login_url)
self.assertEqual(res.status_code, 401)
def test_user_login_with_correct_data(self):
""" test user login with correct username/password is succsessful"""
res = self.client.post(self.login_url, self.credentials, format='json')
token, created = Token.objects.get_or_create(user=self.user)
res_data = json.loads(res.content)
self.assertEqual(
res_data,
{
'user': StudentAccountSerializer(self.user).data,
'token': token.key
},
)
self.assertEqual(res.status_code, 200)
def test_user_login_with_wrong_data(self):
""" test user login with incorect username/password is not successful"""
res = self.client.post(self.login_url, {
'email': '*****@*****.**',
'password': '******'
},
format='json')
self.assertEqual(res.status_code, 401)
def test_get_student_withoutQuery(self):
""" test get student list is successful"""
self.client.force_authenticate(user=self.user)
res = self.client.get(self.students_url)
res_data = json.loads(res.content)
students = User.objects.filter(is_staff=False)
self.assertEqual(res.status_code, 200)
self.assertEqual(res_data,
StudentAccountSerializer(students, many=True).data)
def test_get_student_withQuery(self):
""" test get student data with id is successful"""
self.client.force_authenticate(user=self.user)
res = self.client.get(self.students_url, {'id': self.user.id},
content_type='application/json')
res_data = json.loads(res.content)
student = User.objects.get(id=self.user.id)
self.assertEqual(res.status_code, 200)
self.assertEqual(res_data, StudentAccountSerializer(student).data)
def test_get_leaderboard(self):
""" test get student data to display leader is successful """
self.client.force_authenticate(user=self.user)
res = self.client.get(self.leaderboard_url)
res_data = json.loads(res.content)
user = User.objects.filter(is_staff=False)
self.assertEqual(res_data, LeaderBoardSerializer(user, many=True).data)
self.assertEqual(res.status_code, 200)
def test_post_question_list_withoutQuery(self):
""" test get question without data is unsccessful """
self.client.force_authenticate(user=self.user)
#res = self.client.get(self.questions_url)
res = self.client.post(self.questions_url)
res_data = json.loads(res.content)
self.assertEqual(res.status_code, 400)
def test_post_question_list_withQuery(self):
""" test get question with corect data input is successful """
self.client.force_authenticate(user=self.user)
data = {"world": "1", "section": "1", "role": "2", "questionLevel": 1}
#res = self.client.generic(method="GET", path=self.questions_url, data=json.dumps(
# data), content_type='application/json')
res = self.client.post(self.questions_url, data=data, format='json')
res_data = json.loads(res.content)
world = World.objects.get(name='1')
section = Section.objects.get(name='1')
questions = Questions_teacher.objects.filter(
worldID=world, sectionID=section, role='frontend',
questionLevel=1).order_by('?')[:5]
self.assertEqual(res.status_code, 200)
self.assertEqual(res_data,
QuestionTeacherSerializer(questions, many=True).data)
# Post Question Answer
def test_post_questionAns(self):
""" test post question answer with data is successful """
self.client.force_authenticate(user=self.user)
data = {
'world': self.question.worldID.name,
'section': self.question.sectionID.name,
'questionID': self.question.id,
'studentID': self.user.id,
'studentAnswer': '2',
'isAnsweredCorrect': True,
'pointGain': 1
}
res = self.client.post(self.questions_submit_url,
data=data,
format='json')
res_data = json.loads(res.content)
self.assertEqual(res_data, {'pass': True})
self.assertEqual(res.status_code, 201)
def test_post_questionAns_Without_Data(self):
""" test post question answer without data is unsuccessful"""
self.client.force_authenticate(user=self.user)
res = self.client.post(self.questions_submit_url)
res_data = json.loads(res.content)
self.assertEqual(res_data, {'pass': False})
self.assertEqual(res.status_code, 400)
# Student Post new Question
def test_post_create_StudentQuestion_Without_Data(self):
""" test post create new question by student without data is unsucessful """
self.client.force_authenticate(user=self.user)
res = self.client.post(self.create_questions_url)
res_data = json.loads(res.content)
self.assertEqual(res_data, {'submitted': False})
self.assertEqual(res.status_code, 400)
def test_post_create_StudentQuestion_With_Data(self):
""" test post create new question by student with correct data is successful """
self.client.force_authenticate(user=self.user)
data = {
'Proposer':
'*****@*****.**',
'questionBody':
'10*10 = ?',
'questionAns': [{
'questionText': '1',
'isCorrect': False
}, {
'questionText': '10',
'isCorrect': False
}, {
'questionText': '10',
'isCorrect': False
}, {
'questionText': '100',
'isCorrect': True
}]
}
res = self.client.post(self.create_questions_url,
data=data,
format='json')
res_data = json.loads(res.content)
self.assertEqual(res_data, {'submitted': True})
self.assertEqual(res.status_code, 201)
def test_get_game_summary(self):
""" test get game summary based on correct username is successful """
self.client.force_authenticate(user=self.user)
data = {'email': self.user.email}
res = self.client.generic(method="GET",
path=self.game_summary_url,
data=json.dumps(data),
content_type='application/json')
res_data = json.loads(res.content)
student = User.objects.get(email=self.user.email)
self.assertEqual(res_data, gameSummarySerializer(student).data)
self.assertEqual(res.status_code, 200)
def test_game_summary_with_no_input(self):
""" test get game summary based on no input is successful """
self.client.force_authenticate(user=self.user)
res = self.client.generic(method="GET",
path=self.game_summary_url,
content_type='application/json')
res_data = json.loads(res.content)
self.assertEqual(res_data, {'Error Message': 'record not found'})
self.assertEqual(res.status_code, 400)
class PrivateIngredientsAPITests(TestCase):
"""Test the private ingredient API"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'testpass')
self.client.force_authenticate(self.user)
def test_retrieve_ingredient_list(self):
"""Test retrieving a list of ingredients"""
Ingredient.objects.create(user=self.user, name='kale')
Ingredient.objects.create(user=self.user, name='salt')
res = self.client.get(INGREDIENTS_URL)
ingredients = Ingredient.objects.all().order_by('-name')
serializer = IngredientSerializer(ingredients, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_ingredients_limited_to_user(self):
"""Test that only ingredients for authenticated user are returned"""
user2 = get_user_model().objects.create_user('*****@*****.**',
'testpass')
Ingredient.objects.create(user=user2, name='Vinegar')
ingredient = Ingredient.objects.create(user=self.user, name='tumeric')
res = self.client.get(INGREDIENTS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]['name'], ingredient.name)
def test_create_ingredient_successful(self):
"""Test creating a new ingredient"""
payload = {'name': 'Cabbage'}
self.client.post(INGREDIENTS_URL, payload)
exists = Ingredient.objects.filter(user=self.user,
name=payload['name']).exists()
self.assertTrue(exists)
def test_create_ingredient_invalid(self):
"""Test creating invalid ingredient fails"""
payload = {'name': ''}
res = self.client.post(INGREDIENTS_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_retrieve_ingredients_assigned_to_recipes(self):
"""Test filtering ingredients by those assigned to recipes"""
ingredient1 = Ingredient.objects.create(user=self.user, name='Apples')
ingredient2 = Ingredient.objects.create(user=self.user, name='Turkey')
recipe = Recipe.objects.create(title='Apple crumble',
time_minutes=5,
price=10.00,
user=self.user)
recipe.ingredients.add(ingredient1)
res = self.client.get(INGREDIENTS_URL, {'assigned_only': 1})
serializer1 = IngredientSerializer(ingredient1)
serializer2 = IngredientSerializer(ingredient2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
def _get_client(admin_user):
client = APIClient()
client.force_authenticate(user=admin_user)
return client
def api_client(user_factory):
client = APIClient()
client.force_authenticate(user=user_factory())
return client
class OrderTest:
def __init__(self, options, stdout_success):
self.client = APIClient()
self.stdout = stdout_success
self.action = options.get('action')
organization_name = options.get('organization')
offering_uuid = options.get('offering')
attributes_path = options.get('attributes')
self.attributes = {}
if attributes_path:
with open(attributes_path) as attributes_file:
attributes = attributes_file.read()
self.attributes = json.loads(attributes)
try:
self.offering = marketplace_models.Offering.objects.get(
uuid=offering_uuid)
except marketplace_models.Offering.DoesNotExist:
raise OrderTestException('Offering does not exist.')
try:
self.customer = structure_models.Customer.objects.get(
name=organization_name)
self.project = structure_models.Project.objects.get(
customer=self.customer)
self.owner = self.customer.get_owners().first()
self.admin = self.project.get_users(
role=structure_models.ProjectRole.ADMINISTRATOR).first()
except structure_models.Customer.DoesNotExist:
self.customer = structure_factories.CustomerFactory(
name=organization_name)
self.owner = structure_factories.UserFactory(username='******')
self.customer.add_user(self.owner,
structure_models.CustomerRole.OWNER)
self.project = structure_factories.ProjectFactory(
customer=self.customer)
self.admin = structure_factories.UserFactory(username='******')
self.project.add_user(self.admin,
structure_models.ProjectRole.ADMINISTRATOR)
self.stdout('Organization is created.')
for i in range(1, 2 - self.offering.plans.count()):
factories.PlanFactory(offering=self.offering)
self.plan_1 = self.offering.plans.first()
self.plan_2 = self.offering.plans.last()
@property
def order_item(self):
order_item_queryset = marketplace_models.OrderItem.objects.filter(
offering=self.offering, order__project=self.project)
if order_item_queryset.exists():
return order_item_queryset.last()
@property
def order(self):
if self.order_item:
return self.order_item.order
@contextlib.contextmanager
def mute_stdout(self):
stdout = self.stdout
self.stdout = lambda x: x
try:
yield {}
finally:
self.stdout = stdout
def get_request_type(self):
choices = marketplace_models.RequestTypeMixin.Types.CHOICES
return filter(lambda x: x[0] == self.order_item.type,
choices)[0][1].lower()
def get_issue(self):
if self.get_request_type() == 'create':
return self.order_item.resource.scope.issue
else:
ct = ContentType.objects.get_for_model(
marketplace_models.OrderItem)
return support_models.Issue.objects.get(
resource_content_type=ct,
resource_object_id=self.order_item.pk)
def get_response(
self,
user,
url_name,
data=None,
action=None,
uuid=None,
status_code=status.HTTP_200_OK,
):
if uuid:
url = 'http://localhost%s' % reverse(url_name,
kwargs={'uuid': uuid})
else:
url = 'http://localhost%s' % reverse(url_name)
if action:
url += action + '/'
self.client.force_authenticate(user)
response = self.client.post(url, data)
if response.status_code != status_code:
raise OrderTestException('Request %s failed. %s' %
(action, response.rendered_content))
return response
def approve_order(self):
self.get_response(
self.owner,
'marketplace-order-detail',
action='approve',
uuid=self.order.uuid,
)
process_order_item(self.order_item, self.owner)
self.stdout('A %s order has been approved.' % self.get_request_type())
self.stdout('Order UUID: %s' % self.order.uuid)
self.stdout('Request UUID: %s' % self.order_item.resource.scope.uuid)
issue = self.get_issue()
self.stdout('Issue UUID: %s, PK: %s' % (issue.uuid.hex, issue.pk))
def validate_order_done(self):
if self.order.state != marketplace_models.Order.States.DONE:
raise OrderTestException('An order is not done.')
def validate_request_state(self, issue_resolved, request_state,
request_type):
if (request_type == 'create' and issue_resolved
and request_state == support_models.Offering.States.OK):
return
if (request_type == 'create' and not issue_resolved and request_state
== support_models.Offering.States.TERMINATED):
return
if request_type == 'terminate' and issue_resolved and request_state is None:
return
if (request_type == 'terminate' and not issue_resolved
and request_state == support_models.Offering.States.OK):
return
if (request_type == 'update'
and request_state == support_models.Offering.States.OK):
return
raise OrderTestException('Request state is wrong.')
def issue_info(self):
if self.order.state == marketplace_models.Order.States.EXECUTING:
self.stdout('STEP 2: resolve or cancel an issue.')
self.stdout('A %s order UUID: %s' %
(self.get_request_type(), self.order.uuid))
self.stdout('Request UUID: %s' %
self.order_item.resource.scope.uuid)
issue = self.get_issue()
self.stdout('Issue UUID: %s, PK: %s' % (issue.uuid.hex, issue.pk))
self.stdout('Please, resolve or cancel an issue.')
if self.order.state == marketplace_models.Order.States.DONE:
issue = self.get_issue()
if issue.resolved is None:
raise OrderTestException(
'An order is done, but the issue is not resolved or canceled.'
)
elif issue.resolved:
self.stdout('FINISH: A %s order has been resolved.' %
self.get_request_type())
else:
self.stdout('FINISH: A %s order has been canceled.' %
self.get_request_type())
if self.order_item.resource.scope:
self.stdout('Request state is: %s.' %
self.order_item.resource.scope.state)
else:
self.stdout('Request with ID %s has been deleted.' %
self.order_item.resource.object_id)
self.stdout('Resource plan is: %s' %
self.order_item.resource.plan.name)
request_state = (self.order_item.resource.scope
and self.order_item.resource.scope.state)
self.validate_request_state(issue.resolved, request_state,
self.get_request_type())
if self.order.state == marketplace_models.Order.States.REJECTED:
self.stdout('A %s order has been rejected.' %
self.get_request_type())
if self.order.state == marketplace_models.Order.States.ERRED:
self.stdout('A %s order has failed.' % self.get_request_type())
def create_request(self):
self.stdout('STEP 1: Make an order.')
data = {
'project':
'http://localhost' +
reverse('project-detail', kwargs={'uuid': self.project.uuid}),
'items': [
{
'offering':
'http://localhost' + reverse(
'marketplace-offering-detail',
kwargs={'uuid': self.offering.uuid},
),
'attributes':
self.attributes,
'limits': {},
'plan':
'http://localhost' +
reverse('marketplace-plan-detail',
kwargs={'uuid': self.plan_1.uuid}),
},
],
}
self.get_response(
self.admin,
'marketplace-order-list',
data=data,
status_code=status.HTTP_201_CREATED,
)
self.approve_order()
def choice_step(func):
def wrapped(self):
if self.order_item:
self.issue_info()
else:
func(self)
return wrapped
@choice_step
def create(self):
self.create_request()
@choice_step
def terminate(self):
self.stdout('STEP 1: Make an order to terminate a resource.')
with self.mute_stdout():
self.create_request()
self.order_item.resource.scope.issue.set_resolved()
self.validate_order_done()
self.get_response(
self.admin,
'marketplace-resource-detail',
action='terminate',
uuid=self.order_item.resource.uuid,
)
self.approve_order()
@choice_step
def update(self):
self.stdout('STEP 1: Make an order to switch plan of a resource.')
with self.mute_stdout():
self.create_request()
self.order_item.resource.scope.issue.set_resolved()
self.validate_order_done()
self.stdout('Resource plan is: %s' %
self.order_item.resource.plan.name)
data = {
'plan':
'http://localhost' + reverse('marketplace-plan-detail',
kwargs={'uuid': self.plan_2.uuid}),
}
self.get_response(
self.admin,
'marketplace-resource-detail',
data=data,
action='switch_plan',
uuid=self.order_item.resource.uuid,
)
self.approve_order()
def delete(self):
order_item_queryset = marketplace_models.OrderItem.objects.filter(
offering=self.offering, order__project=self.project)
if not order_item_queryset.exists():
self.stdout('The order has already been deleted.')
return
for order_item in order_item_queryset.all():
order_item.order.delete()
self.stdout('Order has been deleted.')
def run(self):
getattr(self, self.action, lambda: None)()
class PrivateRecipeApiTest(TestCase):
"""Test unauthenticated recipe api access"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create(email='*****@*****.**',
password='******')
self.client.force_authenticate(self.user)
def test_retrieve_recipe(self):
""""Test retrieving a list of recipes"""
sample_recipe(user=self.user)
sample_recipe(user=self.user)
res = self.client.get(RECIPE_URL)
recipe = Recipe.objects.all()
serializer = RecipeSerializer(recipe, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_recipes_limited_to_user(self):
"""Test retrieving recipes for user"""
sample_recipe(user=self.user)
user2 = get_user_model().objects.create(email='*****@*****.**',
password='******')
sample_recipe(user=user2)
recipe = Recipe.objects.filter(user=self.user)
serializer = RecipeSerializer(recipe, many=True)
res = self.client.get(RECIPE_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data, serializer.data)
def test_view_recipe_detail(self):
"""Test viewing recipe detail"""
recipe = sample_recipe(user=self.user)
recipe.tag.add(sample_tag(user=self.user))
recipe.ingredient.add(sample_ingredient(user=self.user))
res = self.client.get(detail_url(recipe.pk))
self.assertEqual(res.status_code, status.HTTP_200_OK)
serializer = RecipeDetailSerializer(recipe)
self.assertEqual(res.data, serializer.data)
def test_create_basic_recipe(self):
"""Test creating a recipe"""
payload = {'title': 'chocolate cake', 'time': 10, 'price': 15.00}
res = self.client.post(RECIPE_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
for key in payload.keys():
self.assertEqual(payload[key], getattr(recipe, key))
def test_create_recipe_with_tag(self):
"""Test creating recipe with tags"""
tag1 = sample_tag(user=self.user, name='italian')
tag2 = sample_tag(user=self.user, name='pasta')
payload = {
'title': 'pasta alfredo',
'time': 10,
'price': 15.00,
'tag': [tag2.id, tag1.id]
}
res = self.client.post(RECIPE_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
tags = recipe.tag.all()
self.assertEqual(tags.count(), 2)
self.assertIn(tag1, tags)
self.assertIn(tag2, tags)
def test_create_recipe_with_ingredient(self):
"""Test creating recipe with ingredient"""
ingredient1 = sample_ingredient(user=self.user, name="salt")
ingredient2 = sample_ingredient(user=self.user, name="tomato")
payload = {
'title': 'pasta',
'time': 20,
'price': 10.00,
'ingredient': [ingredient1.id, ingredient2.id]
}
res = self.client.post(RECIPE_URL, payload)
self.assertEqual(res.status_code, status.HTTP_201_CREATED)
recipe = Recipe.objects.get(id=res.data['id'])
ingredients = recipe.ingredient.all()
self.assertEqual(ingredients.count(), 2)
self.assertIn(ingredient1, ingredients)
self.assertIn(ingredient2, ingredients)
def test_partial_update_recipe(self):
""""Test updating recipe with patch"""
recipe = sample_recipe(user=self.user)
recipe.tag.add(sample_tag(user=self.user))
new_tag = sample_tag(user=self.user, name='chinese')
payload = {'title': 'italian pizza', 'tag': [new_tag.id]}
res = self.client.patch(detail_url(recipe.id), payload)
recipe.refresh_from_db()
self.assertEqual(res.data['title'], payload['title'])
tags = recipe.tag.all()
self.assertEqual(len(tags), 1)
self.assertIn(new_tag, tags)
def test_full_update_recipe(self):
"""Test updating recipe with put"""
recipe = sample_recipe(user=self.user)
recipe.tag.add(sample_tag(user=self.user))
recipe.ingredient.add(sample_ingredient(user=self.user))
new_ingredient = sample_ingredient(user=self.user, name='cream')
new_tag = sample_tag(user=self.user, name='iran')
payload = {
'title': 'ghorme sabzi',
'time': 24,
'price': 500.00,
'tag': [new_tag.id],
'ingredient': [new_ingredient.id]
}
self.client.put(detail_url(recipe.id), payload)
recipe.refresh_from_db()
tags = recipe.tag.all()
ingredients = recipe.ingredient.all()
self.assertEqual(len(tags), 1)
self.assertEqual(len(ingredients), 1)
self.assertEqual(recipe.price, payload['price'])
self.assertEqual(recipe.title, payload['title'])
def make():
client = APIClient()
client.force_authenticate(user=user_factory())
return client
class RecipeImageUploadTest(TestCase):
"""Test for uploading image"""
def setUp(self):
self.client = APIClient()
self.user = get_user_model().objects.create_user(email='*****@*****.**',
password='******')
self.client.force_authenticate(self.user)
self.recipe = sample_recipe(user=self.user)
def tearDown(self):
self.recipe.image.delete()
def tes_uploading_image_recipe(self):
"""test uploading an image to recipe"""
with tempfile.NamedTemporaryFile(suffix='jpg') as ntf:
img = Image.new('RGB', (10, 10))
img.save(ntf, format='JPEG')
ntf.seek(0)
res = self.client.post(image_upload_url(self.recipe.id),
{'image': ntf},
format='multipart')
self.recipe.refresh_from_db()
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertIn('image', res.data)
self.assertTrue(os.path.exists(self.recipe.image.path))
def test_upload_image_bad_request(self):
"""Test uploading invalid an image"""
res = self.client.post(image_upload_url(self.recipe.id),
{'image': 'not image'},
format='multipart')
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
def test_filter_recipes_by_tags(self):
"""Test returning recipes with specific tags"""
recipe1 = sample_recipe(user=self.user, title='thai food')
recipe2 = sample_recipe(user=self.user, title='burger')
tag1 = sample_tag(user=self.user, name='persian')
tag2 = sample_tag(user=self.user, name='thailand')
recipe1.tag.add(tag1)
recipe2.tag.add(tag2)
recipe3 = sample_recipe(user=self.user, title='fish and chips')
res = self.client.get(RECIPE_URL, {'tag': f'{tag1.id}, {tag2.id}'})
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def test_filter_recipes_by_ingredient(self):
"""Test returning recipes with specific ingredient"""
recipe1 = sample_recipe(user=self.user, title='thai food')
recipe2 = sample_recipe(user=self.user, title='burger')
recipe3 = sample_recipe(user=self.user, title='fish and chips')
ingredient1 = sample_ingredient(user=self.user, name='salt')
ingredient2 = sample_ingredient(user=self.user, name='carry')
recipe1.ingredient.add(ingredient1)
recipe2.ingredient.add(ingredient2)
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
res = self.client.get(
RECIPE_URL, {'ingredient': f'{ingredient1.id},{ingredient2.id}'})
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
class PrivateTagsApiTests(TestCase):
"""Test the authorized user tags API"""
def setUp(self):
self.user = get_user_model().objects.create_user(
'*****@*****.**', 'test123')
self.client = APIClient()
self.client.force_authenticate(self.user)
# タグ検索
def test_retrieve_tags(self):
"""Test retrieving tags"""
Tag.objects.create(user=self.user, name='Vegan')
Tag.objects.create(user=self.user, name='Dessert')
res = self.client.get(TAGS_URL)
tags = Tag.objects.all().order_by('-name')
serializer = TagSerializer(tags, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
# ログインユーザーにのみ、タグ検索をする
def test_tags_limited_to_user(self):
"""Test that tags returned are for the authenticated user"""
user2 = get_user_model().objects.create_user('*****@*****.**',
'test123')
Tag.objects.create(user=user2, name='Fruity')
tag = Tag.objects.create(user=self.user, name='Comfort Food')
res = self.client.get(TAGS_URL)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data[0]['name'], tag.name)
# タグが作成できているか
def test_create_tag_successful(self):
"""Test creating a new tag"""
payload = {'name': 'Test tag'}
self.client.post(TAGS_URL, payload)
exists = Tag.objects.filter(user=self.user,
name=payload['name']).exists()
self.assertTrue(exists)
# タグがバリデーションで無効になるか
def test_create_tag_invalid(self):
"""Test creating a new tag with invalid payload"""
payload = {'name': ''}
res = self.client.post(TAGS_URL, payload)
self.assertEqual(res.status_code, status.HTTP_400_BAD_REQUEST)
# レシピに紐づいているタグを返す
def test_retrieve_tags_assigned_to_recipes(self):
"""Test filtering tags by those assigned to recipes"""
tag1 = Tag.objects.create(user=self.user, name='Breakfast')
tag2 = Tag.objects.create(user=self.user, name='Lunch')
recipe = Recipe.objects.create(
title='Coriander eggs on toast',
time_minutes=10,
price=5.00,
user=self.user,
)
recipe.tags.add(tag1)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
serializer1 = TagSerializer(tag1)
serializer2 = TagSerializer(tag2)
self.assertIn(serializer1.data, res.data)
self.assertNotIn(serializer2.data, res.data)
# レシピに紐づいているタグがユニークかどうか
def test_retrieve_tags_assigned_unique(self):
"""Test filtering tags by assigned return unique items"""
tag = Tag.objects.create(user=self.user, name='Breakfast')
Tag.objects.create(user=self.user, name='Lunch')
recipe1 = Recipe.objects.create(title='Pancakes',
time_minutes=5,
price=3.00,
user=self.user)
recipe1.tags.add(tag)
recipe2 = Recipe.objects.create(title='Porridge',
time_minutes=3,
price=2.00,
user=self.user)
recipe2.tags.add(tag)
res = self.client.get(TAGS_URL, {'assigned_only': 1})
self.assertEqual(len(res.data), 1)
