class SyncOrgVenuesTestSuite(EventTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_sync_org_venues_without_cohort(self):
"""Test /answer without auth"""
model = self.generate_models(organization=True)
try:
sync_org_venues(model['organization'])
except Exception as e:
self.assertEquals(str(e), (
'First you must specify to which academy this organization belongs'
))
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_sync_org_venues_without_cohort(self):
"""Test /answer without auth"""
model = self.generate_models(organization=True, academy=True)
try:
sync_org_venues(model['organization'])
except Exception as e:
self.assertEquals(str(e),
('The path you requested does not exist.'))
class AnswerIdTrackerTestSuite(FeedbackTestCase):
"""Test /answer/:id/tracker.png"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_tracker_without_auth(self):
"""Test /answer/:id/tracker.png without auth"""
url = reverse_lazy('feedback:answer_id_tracker', kwargs={'answer_id': 9999})
response = self.client.get(url)
self.assertEqual(response['content-type'], 'image/png')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_answer(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_tracker_without_data(self):
"""Test /answer/:id/tracker.png without auth"""
self.generate_models(authenticate=True)
url = reverse_lazy('feedback:answer_id_tracker', kwargs={'answer_id': 9999})
response = self.client.get(url)
self.assertEqual(response['content-type'], 'image/png')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_answer(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_tracker_with_data_without_status(self):
"""Test /answer/:id/tracker.png without auth"""
model = self.generate_models(authenticate=True, answer=True)
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id_tracker', kwargs={'answer_id': model['answer'].id})
response = self.client.get(url)
# db['status'] = 'OPENED'
self.assertEqual(response['content-type'], 'image/png')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_tracker_with_data(self):
"""Test /answer/:id/tracker.png without auth"""
model = self.generate_models(authenticate=True, answer=True, answer_status='SENT')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id_tracker', kwargs={'answer_id': model['answer'].id})
response = self.client.get(url)
db['status'] = 'OPENED'
self.assertEqual(response['content-type'], 'image/png')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.check_all_opened_at_and_remove_it(self.all_answer_dict()), [db])
class academyTestSuite(AdmissionsTestCase):
"""Test /academy"""
def test_academy_without_auth(self):
"""Test /academy without auth"""
url = reverse_lazy('admissions:academy')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_academy_without_data(self):
"""Test /academy without auth"""
url = reverse_lazy('admissions:academy')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_academy(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_with_data(self):
"""Test /academy without auth"""
self.generate_models(authenticate=True, academy=True)
url = reverse_lazy('admissions:academy')
model_dict = self.remove_dinamics_fields(self.academy.__dict__)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'id': self.academy.id,
'name': self.academy.name,
'slug': self.academy.slug,
'street_address': self.academy.street_address,
'country': self.academy.country.code,
'city': self.academy.city.id,
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_academy(), 1)
self.assertEqual(self.get_academy_dict(1), model_dict)
class AcademyCohortTestSuite(AdmissionsTestCase):
"""Test /academy/cohort"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_delete_duplicates(self):
"""Test /academy/cohort without auth"""
self.generate_models(cohort=True, user=True)
models = [
mixer.blend('admissions.CohortUser',
user=self.user,
cohort=self.cohort) for _ in range(0, 10)
]
model_dict = self.remove_dinamics_fields(models[0].__dict__)
command = Command()
self.assertEqual(command.handle(), None)
self.assertEqual(self.count_cohort_user(), 1)
self.assertEqual(self.all_cohort_user_dict(), [model_dict])
class MediaTestSuite(MediaTestCase):
"""Test /answer"""
"""
🔽🔽🔽 Auth
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_type_slug__without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('activity:type_slug',
kwargs={'activity_slug': 'they-killed-kenny'})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_type_slug__wrong_academy(self):
"""Test /answer without auth"""
self.headers(academy=1)
url = reverse_lazy('activity:type_slug',
kwargs={'activity_slug': 'they-killed-kenny'})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_type_slug__without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('activity:type_slug',
kwargs={'activity_slug': 'they-killed-kenny'})
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail':
"You (user: 1) don't have this capability: read_activity for academy 1",
'status_code': 403,
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
"""
🔽🔽🔽 Bad slug
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_type_slug__without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
self.generate_models(authenticate=True,
profile_academy=True,
capability='read_activity',
role='potato')
url = reverse_lazy('activity:type_slug',
kwargs={'activity_slug': 'they-killed-kenny'})
response = self.client.get(url)
json = response.json()
expected = {'detail': 'activity-not-found', 'status_code': 400}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
"""
🔽🔽🔽 Get
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_type_slug(self):
"""Test /answer without auth"""
self.headers(academy=1)
self.generate_models(authenticate=True,
profile_academy=True,
capability='read_activity',
role='potato')
url = reverse_lazy('activity:type_slug',
kwargs={'activity_slug': 'academy-registration'})
response = self.client.get(url)
json = response.json()
expected = {
'description': 'When student successfuly join to academy',
'slug': 'academy-registration',
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class AnswerTestSuite(FeedbackTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('feedback:answer')
response = self.client.get(url)
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_wrong_academy(self):
"""Test /answer without auth"""
url = reverse_lazy('feedback:answer')
response = self.client.get(url, **{'HTTP_Academy': 1 })
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('feedback:answer')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': "You (user: 1) don't have this capability: read_nps_answers for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
models = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
url = reverse_lazy('feedback:answer')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_answer(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, answer=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer')
response = self.client.get(url)
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['answer'].cohort.id,
'name': model['answer'].cohort.name,
'slug': model['answer'].cohort.slug,
},
'comment': model['answer'].comment,
'event': model['answer'].event,
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['answer'].mentor.first_name,
'id': model['answer'].mentor.id,
'last_name': model['answer'].mentor.last_name,
},
'score': model['answer'].score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_bad_param_user_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, answer=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'user': 9999
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_param_user_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, answer=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'user': model['user'].id,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['answer'].cohort.id,
'name': model['answer'].cohort.name,
'slug': model['answer'].cohort.slug,
},
'comment': model['answer'].comment,
'event': model['answer'].event,
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['answer'].mentor.first_name,
'id': model['answer'].mentor.id,
'last_name': model['answer'].mentor.last_name,
},
'score': model['answer'].score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_bad_param_cohort_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, answer=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'cohort': 'they-killed-kenny',
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_param_cohort_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, answer=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'cohort': model['cohort'].slug,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['cohort'].id,
'name': model['cohort'].name,
'slug': model['cohort'].slug,
},
'comment': model['answer'].comment,
'event': model['answer'].event,
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['answer'].mentor.first_name,
'id': model['answer'].mentor.id,
'last_name': model['answer'].mentor.last_name,
},
'score': model['answer'].score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_param_academy_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
answer=True, profile_academy=True, capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'academy': model['academy'].id,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['cohort'].id,
'name': model['cohort'].name,
'slug': model['cohort'].slug,
},
'comment': model['answer'].comment,
'event': model['answer'].event,
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['answer'].mentor.first_name,
'id': model['answer'].mentor.id,
'last_name': model['answer'].mentor.last_name,
},
'score': model['answer'].score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_bad_param_mentor_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
answer=True, profile_academy=True, capability='read_nps_answers',
role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'mentor': 9999,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_param_mentor_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
answer=True, profile_academy=True, capability='read_nps_answers',
role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'mentor': model['user'].id,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url, headers={"Academy": model['academy'].id})
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['cohort'].id,
'name': model['cohort'].name,
'slug': model['cohort'].slug,
},
'comment': model['answer'].comment,
'event': model['answer'].event,
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
'score': model['answer'].score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_bad_param_event_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
answer=True, event=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'event': 9999,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_param_event_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
answer=True, event=True, profile_academy=True,
capability='read_nps_answers', role='potato')
db = self.model_to_dict(model, 'answer')
params = {
'event': model['event'].id,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['cohort'].id,
'name': model['cohort'].name,
'slug': model['cohort'].slug,
},
'comment': model['answer'].comment,
'event': {
'id': model['event'].id,
'description': model['event'].description,
'excerpt': model['event'].excerpt,
'lang': model['event'].lang,
'title': model['event'].title,
},
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
'score': model['answer'].score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_bad_param_score_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
event=True, profile_academy=True, capability='read_nps_answers', role='potato')
for number in range(1, 10):
self.remove_all_answer()
score = str(number)
answer_kwargs = {
'score': score
}
model = self.generate_models(answer=True, answer_kwargs=answer_kwargs, models=base)
db = self.model_to_dict(model, 'answer')
params = {
'score': 1 if number == 10 else number + 1,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
db['score'] = score
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_param_score_with_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, user=True, cohort=True, academy=True,
event=True, profile_academy=True, capability='read_nps_answers', role='potato')
for number in range(1, 10):
self.remove_all_answer()
score = str(number)
answer_kwargs = {
'score': score
}
model = self.generate_models(answer=True, answer_kwargs=answer_kwargs, models=base)
db = self.model_to_dict(model, 'answer')
params = {
'score': score,
}
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?{urllib.parse.urlencode(params)}'
response = self.client.get(url, headers={"Academy", model['academy'].id })
json = response.json()
json = [{**x, 'created_at': None} for x in json if self.assertDatetime(x['created_at'])]
self.assertEqual(json, [{
'created_at': None,
'academy': {
'id': model['answer'].academy.id,
'name': model['answer'].academy.name,
'slug': model['answer'].academy.slug,
},
'cohort': {
'id': model['cohort'].id,
'name': model['cohort'].name,
'slug': model['cohort'].slug,
},
'comment': model['answer'].comment,
'event': {
'id': model['event'].id,
'description': model['event'].description,
'excerpt': model['event'].excerpt,
'lang': model['event'].lang,
'title': model['event'].title,
},
'highest': model['answer'].highest,
'id': model['answer'].id,
'lang': model['answer'].lang,
'lowest': model['answer'].lowest,
'mentor': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
'score': score,
'status': model['answer'].status,
'title': model['answer'].title,
'user': {
'first_name': model['user'].first_name,
'id': model['user'].id,
'last_name': model['user'].last_name,
},
}])
db['score'] = score
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_data_without_pagination_get_just_100(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
models = [self.generate_models(answer=True, models=base) for _ in range(0, 105)]
ordened_models = sorted(models, key=lambda x: x['answer'].created_at,
reverse=True)
url = reverse_lazy('feedback:answer')
response = self.client.get(url)
json = response.json()
json = [{**x, 'created_at': None} for x in json
if self.assertDatetime(x['created_at'])]
expected = [{
'id': model['answer'].id,
'title': model['answer'].title,
'lowest': model['answer'].lowest,
'highest': model['answer'].highest,
'lang': model['answer'].lang,
'comment': model['answer'].comment,
'score': model['answer'].score,
'status': model['answer'].status,
'created_at': None,
'user': {
'id': model['user'].id,
'first_name': model['user'].first_name,
'last_name': model['user'].last_name,
},
'academy': {
'id': model['answer'].academy.id,
'slug': model['answer'].academy.slug,
'name': model['answer'].academy.name,
},
'cohort': {
'id': model['answer'].cohort.id,
'slug': model['answer'].cohort.slug,
'name': model['answer'].cohort.name,
},
'mentor': {
'id': model['answer'].mentor.id,
'first_name': model['answer'].mentor.first_name,
'last_name': model['answer'].mentor.last_name,
},
'event': model['answer'].event,
} for model in ordened_models][:100]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [{
**self.model_to_dict(model, 'answer'),
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_data_with_pagination_first_five(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
models = [self.generate_models(answer=True, models=base) for _ in range(0, 10)]
ordened_models = sorted(models, key=lambda x: x['answer'].created_at,
reverse=True)
url = reverse_lazy('feedback:answer') + '?limit=5&offset=0'
response = self.client.get(url)
json = response.json()
prev_results = json['results']
json['results'] = [{**x, 'created_at': None} for x in prev_results
if self.assertDatetime(x['created_at'])]
results = [{
'id': model['answer'].id,
'title': model['answer'].title,
'lowest': model['answer'].lowest,
'highest': model['answer'].highest,
'lang': model['answer'].lang,
'comment': model['answer'].comment,
'score': model['answer'].score,
'status': model['answer'].status,
'created_at': None,
'user': {
'id': model['user'].id,
'first_name': model['user'].first_name,
'last_name': model['user'].last_name,
},
'academy': {
'id': model['answer'].academy.id,
'slug': model['answer'].academy.slug,
'name': model['answer'].academy.name,
},
'cohort': {
'id': model['answer'].cohort.id,
'slug': model['answer'].cohort.slug,
'name': model['answer'].cohort.name,
},
'mentor': {
'id': model['answer'].mentor.id,
'first_name': model['answer'].mentor.first_name,
'last_name': model['answer'].mentor.last_name,
},
'event': model['answer'].event,
} for model in ordened_models][:5]
expected = {
'count': 10,
'first': None,
'next': 'http://testserver/v1/feedback/academy/answer?limit=5&'
f'offset=5',
'previous': None,
'last': 'http://testserver/v1/feedback/academy/answer?limit=5&'
f'offset=5',
'results': results
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [{
**self.model_to_dict(model, 'answer'),
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_data_with_pagination_last_five(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
models = [self.generate_models(answer=True, models=base) for _ in range(0, 10)]
ordened_models = sorted(models, key=lambda x: x['answer'].created_at,
reverse=True)
url = reverse_lazy('feedback:answer') + '?limit=5&offset=5'
response = self.client.get(url)
json = response.json()
prev_results = json['results']
json['results'] = [{**x, 'created_at': None} for x in prev_results
if self.assertDatetime(x['created_at'])]
results = [{
'id': model['answer'].id,
'title': model['answer'].title,
'lowest': model['answer'].lowest,
'highest': model['answer'].highest,
'lang': model['answer'].lang,
'comment': model['answer'].comment,
'score': model['answer'].score,
'status': model['answer'].status,
'created_at': None,
'user': {
'id': model['user'].id,
'first_name': model['user'].first_name,
'last_name': model['user'].last_name,
},
'academy': {
'id': model['answer'].academy.id,
'slug': model['answer'].academy.slug,
'name': model['answer'].academy.name,
},
'cohort': {
'id': model['answer'].cohort.id,
'slug': model['answer'].cohort.slug,
'name': model['answer'].cohort.name,
},
'mentor': {
'id': model['answer'].mentor.id,
'first_name': model['answer'].mentor.first_name,
'last_name': model['answer'].mentor.last_name,
},
'event': model['answer'].event,
} for model in ordened_models][5:]
expected = {
'count': 10,
'first': 'http://testserver/v1/feedback/academy/answer?limit=5',
'next': None,
'previous': 'http://testserver/v1/feedback/academy/answer?limit=5',
'last': None,
'results': results,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [{
**self.model_to_dict(model, 'answer'),
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_data_with_pagination_last_five(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
models = [self.generate_models(answer=True, models=base) for _ in range(0, 10)]
url = reverse_lazy('feedback:answer') + '?limit=5&offset=10'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/feedback/academy/answer?limit=5',
'next': None,
'previous': 'http://testserver/v1/feedback/academy/answer?limit=5&offset=5',
'last': None,
'results': [],
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [{
**self.model_to_dict(model, 'answer'),
} for model in models])
"""
🔽🔽🔽 With full like querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_query_like_full_name(self):
"""Test /answer with like full name"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Reinaldo',
'last_name': 'Descarado',
}
models = [
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs, models=base),
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs_2, models=base),
]
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?like=Rene Descartes'
response = self.client.get(url)
json = response.json()
expected = [
{
'created_at': self.datetime_to_iso(models[0].answer.created_at),
'academy': {
'id': models[0].answer.academy.id,
'name': models[0].answer.academy.name,
'slug': models[0].answer.academy.slug,
},
'cohort': {
'id': models[0].cohort.id,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
},
'comment': models[0].answer.comment,
'event': models[0].answer.event,
'highest': models[0].answer.highest,
'id': models[0].answer.id,
'lang': models[0].answer.lang,
'lowest': models[0].answer.lowest,
'mentor': {
'first_name': models[0].answer.mentor.first_name,
'id': models[0].answer.mentor.id,
'last_name': models[0].answer.mentor.last_name,
},
'score': models[0].answer.score,
'status': models[0].answer.status,
'title': models[0].answer.title,
'user': {
'first_name': 'Rene',
'id': 2,
'last_name': 'Descartes',
},
}
]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_query_like_first_name(self):
"""Test /answer with like first name"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Reinaldo',
'last_name': 'Descarado',
}
models = [
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs, models=base),
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs_2, models=base),
]
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?like=Rene'
response = self.client.get(url)
json = response.json()
expected = [
{
'created_at': self.datetime_to_iso(models[0].answer.created_at),
'academy': {
'id': models[0].answer.academy.id,
'name': models[0].answer.academy.name,
'slug': models[0].answer.academy.slug,
},
'cohort': {
'id': models[0].cohort.id,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
},
'comment': models[0].answer.comment,
'event': models[0].answer.event,
'highest': models[0].answer.highest,
'id': models[0].answer.id,
'lang': models[0].answer.lang,
'lowest': models[0].answer.lowest,
'mentor': {
'first_name': models[0].answer.mentor.first_name,
'id': models[0].answer.mentor.id,
'last_name': models[0].answer.mentor.last_name,
},
'score': models[0].answer.score,
'status': models[0].answer.status,
'title': models[0].answer.title,
'user': {
'first_name': 'Rene',
'id': 2,
'last_name': 'Descartes',
},
}
]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_query_like_last_name(self):
"""Test /answer with like last name"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Reinaldo',
'last_name': 'Descarado',
}
models = [
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs, models=base),
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs_2, models=base),
]
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}?like=Descartes'
response = self.client.get(url)
json = response.json()
expected = [
{
'created_at': self.datetime_to_iso(models[0].answer.created_at),
'academy': {
'id': models[0].answer.academy.id,
'name': models[0].answer.academy.name,
'slug': models[0].answer.academy.slug,
},
'cohort': {
'id': models[0].cohort.id,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
},
'comment': models[0].answer.comment,
'event': models[0].answer.event,
'highest': models[0].answer.highest,
'id': models[0].answer.id,
'lang': models[0].answer.lang,
'lowest': models[0].answer.lowest,
'mentor': {
'first_name': models[0].answer.mentor.first_name,
'id': models[0].answer.mentor.id,
'last_name': models[0].answer.mentor.last_name,
},
'score': models[0].answer.score,
'status': models[0].answer.status,
'title': models[0].answer.title,
'user': {
'first_name': 'Rene',
'id': 2,
'last_name': 'Descartes',
},
}
]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_with_query_like_email(self):
"""Test /answer with like email"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_nps_answers', role='potato')
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Reinaldo',
'last_name': 'Descarado',
}
models = [
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs, models=base),
self.generate_models(user=True, answer=True, user_kwargs=user_kwargs_2, models=base),
]
base_url = reverse_lazy('feedback:answer')
url = f'{base_url}[email protected]'
response = self.client.get(url)
json = response.json()
expected = [
{
'created_at': self.datetime_to_iso(models[0].answer.created_at),
'academy': {
'id': models[0].answer.academy.id,
'name': models[0].answer.academy.name,
'slug': models[0].answer.academy.slug,
},
'cohort': {
'id': models[0].cohort.id,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
},
'comment': models[0].answer.comment,
'event': models[0].answer.event,
'highest': models[0].answer.highest,
'id': models[0].answer.id,
'lang': models[0].answer.lang,
'lowest': models[0].answer.lowest,
'mentor': {
'first_name': models[0].answer.mentor.first_name,
'id': models[0].answer.mentor.id,
'last_name': models[0].answer.mentor.last_name,
},
'score': models[0].answer.score,
'status': models[0].answer.status,
'title': models[0].answer.title,
'user': {
'first_name': 'Rene',
'id': 2,
'last_name': 'Descartes',
},
}
]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class CohortUserTestSuite(MarketingTestCase):
"""Test /academy/lead"""
"""
🔽🔽🔽 Auth
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__without_auth(self):
"""Test /cohort/:id/user without auth"""
url = reverse_lazy('marketing:lead_all')
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__without_profile_acedemy(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:lead_all')
model = self.generate_models(authenticate=True, form_entry=True)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
"""
🔽🔽🔽 Without data
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__without_data(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:lead_all')
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [])
"""
🔽🔽🔽 With data
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:lead_all')
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True,
form_entry_kwargs=generate_form_entry_kwargs())
response = self.client.get(url)
json = response.json()
self.assertDatetime(json[0]['created_at'])
del json[0]['created_at']
expected = [{
'academy': {
'id': model.form_entry.academy.id,
'name': model.form_entry.academy.name,
'slug': model.form_entry.academy.slug
},
'country': model.form_entry.country,
'course': model.form_entry.course,
'email': model.form_entry.email,
'first_name': model.form_entry.first_name,
'gclid': model.form_entry.gclid,
'id': model.form_entry.id,
'language': model.form_entry.language,
'last_name': model.form_entry.last_name,
'lead_type': model.form_entry.lead_type,
'location': model.form_entry.location,
'storage_status': model.form_entry.storage_status,
'tags': model.form_entry.tags,
'utm_campaign': model.form_entry.utm_campaign,
'utm_medium': model.form_entry.utm_medium,
'utm_source': model.form_entry.utm_source,
'utm_url': model.form_entry.utm_url,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
"""
🔽🔽🔽 Academy in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_bad_academy_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:lead_all') + '?academy=freyja'
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_academy_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
academy_kwargs = {'slug': 'freyja'}
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True,
academy_kwargs=academy_kwargs)
url = reverse_lazy('marketing:lead_all') + '?academy=freyja'
response = self.client.get(url)
json = response.json()
self.assertDatetime(json[0]['created_at'])
del json[0]['created_at']
expected = [{
'academy': {
'id': model.form_entry.academy.id,
'name': model.form_entry.academy.name,
'slug': model.form_entry.academy.slug
},
'country': model.form_entry.country,
'course': model.form_entry.course,
'email': model.form_entry.email,
'first_name': model.form_entry.first_name,
'gclid': model.form_entry.gclid,
'id': model.form_entry.id,
'language': model.form_entry.language,
'last_name': model.form_entry.last_name,
'lead_type': model.form_entry.lead_type,
'location': model.form_entry.location,
'storage_status': model.form_entry.storage_status,
'tags': model.form_entry.tags,
'utm_campaign': model.form_entry.utm_campaign,
'utm_medium': model.form_entry.utm_medium,
'utm_source': model.form_entry.utm_source,
'utm_url': model.form_entry.utm_url,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_two_academy_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
base = self.generate_models(user=True)
models = [self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True, models=base,
academy_kwargs={'slug': 'konan' if index == 0 else 'freyja'})
for index in range(0, 2)]
models.sort(key=lambda x: x.form_entry.created_at)
url = reverse_lazy('marketing:lead_all') + '?academy=' + ','.join([x.academy.slug for x in models])
response = self.client.get(url)
json = response.json()
self.assertDatetime(json[0]['created_at'])
del json[0]['created_at']
self.assertDatetime(json[1]['created_at'])
del json[1]['created_at']
expected = [{
'academy': {
'id': model.form_entry.academy.id,
'name': model.form_entry.academy.name,
'slug': model.form_entry.academy.slug
},
'country': model.form_entry.country,
'course': model.form_entry.course,
'email': model.form_entry.email,
'first_name': model.form_entry.first_name,
'gclid': model.form_entry.gclid,
'id': model.form_entry.id,
'language': model.form_entry.language,
'last_name': model.form_entry.last_name,
'lead_type': model.form_entry.lead_type,
'location': model.form_entry.location,
'storage_status': model.form_entry.storage_status,
'tags': model.form_entry.tags,
'utm_campaign': model.form_entry.utm_campaign,
'utm_medium': model.form_entry.utm_medium,
'utm_source': model.form_entry.utm_source,
'utm_url': model.form_entry.utm_url,
} for model in models]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
} for model in models])
"""
🔽🔽🔽 Start in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_bad_start_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:lead_all') + '?start=2100-01-01'
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_start_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
query_date = (timezone.now() - timedelta(hours=48)).strftime("%Y-%m-%d")
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True)
url = reverse_lazy('marketing:lead_all') + f'?start={query_date}'
response = self.client.get(url)
json = response.json()
self.assertDatetime(json[0]['created_at'])
del json[0]['created_at']
expected = [{
'academy': {
'id': model.form_entry.academy.id,
'name': model.form_entry.academy.name,
'slug': model.form_entry.academy.slug
},
'country': model.form_entry.country,
'course': model.form_entry.course,
'email': model.form_entry.email,
'first_name': model.form_entry.first_name,
'gclid': model.form_entry.gclid,
'id': model.form_entry.id,
'language': model.form_entry.language,
'last_name': model.form_entry.last_name,
'lead_type': model.form_entry.lead_type,
'location': model.form_entry.location,
'storage_status': model.form_entry.storage_status,
'tags': model.form_entry.tags,
'utm_campaign': model.form_entry.utm_campaign,
'utm_medium': model.form_entry.utm_medium,
'utm_source': model.form_entry.utm_source,
'utm_url': model.form_entry.utm_url,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
"""
🔽🔽🔽 End in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_bad_end_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:lead_all') + '?end=1900-01-01'
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_lead_all__with_end_in_querystring(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
query_date = (timezone.now() + timedelta(hours=48)).strftime("%Y-%m-%d")
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True)
url = reverse_lazy('marketing:lead_all') + f'?end={query_date}'
response = self.client.get(url)
json = response.json()
self.assertDatetime(json[0]['created_at'])
del json[0]['created_at']
expected = [{
'academy': {
'id': model.form_entry.academy.id,
'name': model.form_entry.academy.name,
'slug': model.form_entry.academy.slug
},
'country': model.form_entry.country,
'course': model.form_entry.course,
'email': model.form_entry.email,
'first_name': model.form_entry.first_name,
'gclid': model.form_entry.gclid,
'id': model.form_entry.id,
'language': model.form_entry.language,
'last_name': model.form_entry.last_name,
'lead_type': model.form_entry.lead_type,
'location': model.form_entry.location,
'storage_status': model.form_entry.storage_status,
'tags': model.form_entry.tags,
'utm_campaign': model.form_entry.utm_campaign,
'utm_medium': model.form_entry.utm_medium,
'utm_source': model.form_entry.utm_source,
'utm_url': model.form_entry.utm_url,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
class AcademyEventTestSuite(EventTestCase):
cache = EventCache()
def test_all_academy_events_no_auth(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events')
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 401)
def test_all_academy_events_without_capability(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
expected = {
'detail':
"You (user: 1) don't have this capability: read_event for academy 1",
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 403)
def test_all_academy_events_wrong_city(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue=True,
event=True)
url = reverse_lazy('events:academy_all_events') + "?city=patata"
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_all_academy_events_correct_city(self):
self.headers(academy=1)
venue_kwargs = {"city": "santiago"}
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue_kwargs=venue_kwargs,
venue=True,
event=True)
url = reverse_lazy('events:academy_all_events') + "?city=santiago"
response = self.client.get(url)
json = response.json()
expected = [{
'banner':
model['event'].banner,
'ending_at':
datetime_to_iso_format(model['event'].ending_at),
'event_type':
model['event'].event_type,
'excerpt':
model['event'].excerpt,
'id':
model['event'].id,
'lang':
model['event'].lang,
'online_event':
model['event'].online_event,
'starting_at':
datetime_to_iso_format(model['event'].starting_at),
'status':
model['event'].status,
'title':
model['event'].title,
'url':
model['event'].url,
'venue': {
'city': model['event'].venue.city,
'id': model['event'].id,
'state': model['event'].venue.state,
'street_address': model['event'].venue.street_address,
'title': model['event'].venue.title,
'zip_code': model['event'].venue.zip_code
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_all_academy_events_wrong_country(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue=True,
event=True)
url = reverse_lazy('events:academy_all_events') + "?country=patata"
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_all_academy_events_correct_country(self):
self.headers(academy=1)
venue_kwargs = {"country": "chile"}
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue_kwargs=venue_kwargs,
venue=True,
event=True)
url = reverse_lazy('events:academy_all_events') + "?country=chile"
response = self.client.get(url)
json = response.json()
expected = [{
'banner':
model['event'].banner,
'ending_at':
datetime_to_iso_format(model['event'].ending_at),
'event_type':
model['event'].event_type,
'excerpt':
model['event'].excerpt,
'id':
model['event'].id,
'lang':
model['event'].lang,
'online_event':
model['event'].online_event,
'starting_at':
datetime_to_iso_format(model['event'].starting_at),
'status':
model['event'].status,
'title':
model['event'].title,
'url':
model['event'].url,
'venue': {
'city': model['event'].venue.city,
'id': model['event'].id,
'state': model['event'].venue.state,
'street_address': model['event'].venue.street_address,
'title': model['event'].venue.title,
'zip_code': model['event'].venue.zip_code
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_all_academy_events_wrong_zip_code(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue=True,
event=True)
url = reverse_lazy(
'events:academy_all_events') + "?zip_code=12345678965412"
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_all_academy_events_correct_zip_code(self):
self.headers(academy=1)
venue_kwargs = {"zip_code": "33178"}
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue_kwargs=venue_kwargs,
venue=True,
event=True)
url = reverse_lazy('events:academy_all_events') + "?zip_code=33178"
response = self.client.get(url)
json = response.json()
expected = [{
'banner':
model['event'].banner,
'ending_at':
datetime_to_iso_format(model['event'].ending_at),
'event_type':
model['event'].event_type,
'excerpt':
model['event'].excerpt,
'id':
model['event'].id,
'lang':
model['event'].lang,
'online_event':
model['event'].online_event,
'starting_at':
datetime_to_iso_format(model['event'].starting_at),
'status':
model['event'].status,
'title':
model['event'].title,
'url':
model['event'].url,
'venue': {
'city': model['event'].venue.city,
'id': model['event'].id,
'state': model['event'].venue.state,
'street_address': model['event'].venue.street_address,
'title': model['event'].venue.title,
'zip_code': model['event'].venue.zip_code
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_all_academy_events_upcoming(self):
self.headers(academy=1)
event_kwargs = {"starting_at": timezone.now()}
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
venue=True,
event=True,
event_kwargs=event_kwargs)
url = reverse_lazy('events:academy_all_events') + "?past=true"
response = self.client.get(url)
json = response.json()
expected = [{
'banner':
model['event'].banner,
'ending_at':
datetime_to_iso_format(model['event'].ending_at),
'event_type':
model['event'].event_type,
'excerpt':
model['event'].excerpt,
'id':
model['event'].id,
'lang':
model['event'].lang,
'online_event':
model['event'].online_event,
'starting_at':
datetime_to_iso_format(model['event'].starting_at),
'status':
model['event'].status,
'title':
model['event'].title,
'url':
model['event'].url,
'venue': {
'city': model['event'].venue.city,
'id': model['event'].id,
'state': model['event'].venue.state,
'street_address': model['event'].venue.street_address,
'title': model['event'].venue.title,
'zip_code': model['event'].venue.zip_code
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_not_found(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events')
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events(self, models=None):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events')
if models is None:
models = [
self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
event=True)
]
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model['event'].id,
'banner':
model['event'].banner,
'ending_at':
datetime_to_iso_format(model['event'].ending_at),
'event_type':
model['event'].event_type,
'excerpt':
model['event'].excerpt,
'lang':
model['event'].lang,
'online_event':
model['event'].online_event,
'starting_at':
datetime_to_iso_format(model['event'].starting_at),
'status':
model['event'].status,
'title':
model['event'].title,
'url':
model['event'].url,
'venue':
model['event'].venue
} for model in models]
expected.reverse()
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_dict(), [{
**self.model_to_dict(model, 'event'),
} for model in models])
return models
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_post_without_required_fields(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_event',
role='potato')
url = reverse_lazy('events:academy_all_events')
data = {}
response = self.client.post(url, data)
json = response.json()
expected = {
'url': ['This field is required.'],
'banner': ['This field is required.'],
'capacity': ['This field is required.'],
'starting_at': ['This field is required.'],
'ending_at': ['This field is required.']
}
self.assertEqual(json, expected)
self.assertEqual(self.all_event_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_post_without_required_fields____(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_event',
role='potato')
url = reverse_lazy('events:academy_all_events')
current_date = self.datetime_now()
data = {
'url': 'https://www.google.com/',
'banner': 'https://www.google.com/banner',
'capacity': 11,
'starting_at': self.datetime_to_iso(current_date),
'ending_at': self.datetime_to_iso(current_date),
}
response = self.client.post(url, data)
json = response.json()
self.assertDatetime(json['created_at'])
self.assertDatetime(json['updated_at'])
del json['created_at']
del json['updated_at']
expected = {
'academy': 1,
'author': None,
'description': None,
'event_type': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host': None,
'id': 1,
'lang': None,
'online_event': False,
'organization': None,
'published_at': None,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'venue': None,
**data,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 201)
self.assertEqual(self.all_event_dict(), [{
'academy_id': 1,
'author_id': None,
'banner': 'https://www.google.com/banner',
'capacity': 11,
'description': None,
'ending_at': current_date,
'event_type_id': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host_id': None,
'id': 1,
'lang': None,
'online_event': False,
'organization_id': None,
'published_at': None,
'starting_at': current_date,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'url': 'https://www.google.com/',
'venue_id': None,
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_pagination(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events')
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
event=True)
base = model.copy()
del base['event']
models = [model] + [
self.generate_models(event=True, models=base)
for _ in range(0, 105)
]
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model['event'].id,
'excerpt':
model['event'].excerpt,
'title':
model['event'].title,
'lang':
model['event'].lang,
'url':
model['event'].url,
'banner':
model['event'].banner,
'starting_at':
self.datetime_to_iso(model['event'].starting_at),
'ending_at':
self.datetime_to_iso(model['event'].ending_at),
'status':
model['event'].status,
'event_type':
model['event'].event_type,
'online_event':
model['event'].online_event,
'venue':
model['event'].venue
} for model in models]
expected.sort(key=lambda x: x['starting_at'], reverse=True)
expected = expected[0:100]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_dict(),
[{
'academy_id': model['event'].academy_id,
'author_id': model['event'].author_id,
'banner': model['event'].banner,
'capacity': model['event'].capacity,
'description': None,
'ending_at': model['event'].ending_at,
'event_type_id': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host_id': model['event'].host_id,
'id': model['event'].id,
'lang': None,
'online_event': False,
'organization_id': None,
'published_at': None,
'starting_at': model['event'].starting_at,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'url': model['event'].url,
'venue_id': None
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_pagination_first_five(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events') + '?limit=5&offset=0'
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
event=True)
base = model.copy()
del base['event']
models = [model] + [
self.generate_models(event=True, models=base) for _ in range(0, 9)
]
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model['event'].id,
'excerpt':
model['event'].excerpt,
'title':
model['event'].title,
'lang':
model['event'].lang,
'url':
model['event'].url,
'banner':
model['event'].banner,
'starting_at':
self.datetime_to_iso(model['event'].starting_at),
'ending_at':
self.datetime_to_iso(model['event'].ending_at),
'status':
model['event'].status,
'event_type':
model['event'].event_type,
'online_event':
model['event'].online_event,
'venue':
model['event'].venue
} for model in models]
expected.sort(key=lambda x: x['starting_at'], reverse=True)
expected = expected[0:5]
expected = {
'count': 10,
'first': None,
'next':
'http://testserver/v1/events/academy/event?limit=5&offset=5',
'previous': None,
'last':
'http://testserver/v1/events/academy/event?limit=5&offset=5',
'results': expected
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_dict(),
[{
'academy_id': model['event'].academy_id,
'author_id': model['event'].author_id,
'banner': model['event'].banner,
'capacity': model['event'].capacity,
'description': None,
'ending_at': model['event'].ending_at,
'event_type_id': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host_id': model['event'].host_id,
'id': model['event'].id,
'lang': None,
'online_event': False,
'organization_id': None,
'published_at': None,
'starting_at': model['event'].starting_at,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'url': model['event'].url,
'venue_id': None
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_pagination_last_five(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events') + '?limit=5&offset=5'
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
event=True)
base = model.copy()
del base['event']
models = [model] + [
self.generate_models(event=True, models=base) for _ in range(0, 9)
]
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model['event'].id,
'excerpt':
model['event'].excerpt,
'title':
model['event'].title,
'lang':
model['event'].lang,
'url':
model['event'].url,
'banner':
model['event'].banner,
'starting_at':
self.datetime_to_iso(model['event'].starting_at),
'ending_at':
self.datetime_to_iso(model['event'].ending_at),
'status':
model['event'].status,
'event_type':
model['event'].event_type,
'online_event':
model['event'].online_event,
'venue':
model['event'].venue
} for model in models]
expected.sort(key=lambda x: x['starting_at'], reverse=True)
expected = expected[5:10]
expected = {
'count': 10,
'first': 'http://testserver/v1/events/academy/event?limit=5',
'next': None,
'previous': 'http://testserver/v1/events/academy/event?limit=5',
'last': None,
'results': expected
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_dict(),
[{
'academy_id': model['event'].academy_id,
'author_id': model['event'].author_id,
'banner': model['event'].banner,
'capacity': model['event'].capacity,
'description': None,
'ending_at': model['event'].ending_at,
'event_type_id': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host_id': model['event'].host_id,
'id': model['event'].id,
'lang': None,
'online_event': False,
'organization_id': None,
'published_at': None,
'starting_at': model['event'].starting_at,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'url': model['event'].url,
'venue_id': None
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_pagination_after_last_five(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_all_events') + '?limit=5&offset=10'
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_event',
role='potato',
syllabus=True,
event=True)
base = model.copy()
del base['event']
models = [model] + [
self.generate_models(event=True, models=base) for _ in range(0, 9)
]
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/events/academy/event?limit=5',
'next': None,
'previous':
'http://testserver/v1/events/academy/event?limit=5&offset=5',
'last': None,
'results': []
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_dict(),
[{
'academy_id': model['event'].academy_id,
'author_id': model['event'].author_id,
'banner': model['event'].banner,
'capacity': model['event'].capacity,
'description': None,
'ending_at': model['event'].ending_at,
'event_type_id': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host_id': model['event'].host_id,
'id': model['event'].id,
'lang': None,
'online_event': False,
'organization_id': None,
'published_at': None,
'starting_at': model['event'].starting_at,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'url': model['event'].url,
'venue_id': None
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_all_academy_events_with_data_testing_cache(self):
"""Test /cohort without auth"""
cache_keys = [
'Event__academy_id=1&event_id=None&city=None&'
'country=None&zip_code=None&upcoming=None&past=None&limit=None&offset=None'
]
self.assertEqual(self.cache.keys(), [])
old_models = self.test_all_academy_events()
self.assertEqual(self.cache.keys(), cache_keys)
self.test_all_academy_events(old_models)
self.assertEqual(self.cache.keys(), cache_keys)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_event_type_no_results(self):
self.headers(academy=1)
url = reverse_lazy('events:type')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_cohort_with_data_testing_cache_and_remove_in_post(self):
"""Test /cohort without auth"""
cache_keys = [
'Event__academy_id=1&event_id=None&city=None&'
'country=None&zip_code=None&upcoming=None&past=None&limit=None&offset=None'
]
self.assertEqual(self.cache.keys(), [])
old_model = self.test_all_academy_events()
self.assertEqual(self.cache.keys(), cache_keys)
self.headers(academy=1)
base = old_model[0].copy()
del base['profile_academy']
del base['capability']
del base['role']
del base['user']
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_event',
role='potato2',
models=base)
url = reverse_lazy('events:academy_all_events')
current_date = self.datetime_now()
data = {
'url': 'https://www.google.com/',
'banner': 'https://www.google.com/banner',
'capacity': 11,
'starting_at': self.datetime_to_iso(current_date),
'ending_at': self.datetime_to_iso(current_date),
}
response = self.client.post(url, data)
json = response.json()
self.assertDatetime(json['created_at'])
self.assertDatetime(json['updated_at'])
del json['created_at']
del json['updated_at']
expected = {
'academy': 1,
'author': None,
'description': None,
'event_type': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host': None,
'id': 2,
'lang': None,
'online_event': False,
'organization': None,
'published_at': None,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'venue': None,
**data,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 201)
self.assertEqual(self.all_event_dict(), [{
**self.model_to_dict(old_model[0], 'event'),
}, {
'academy_id': 1,
'author_id': None,
'banner': 'https://www.google.com/banner',
'capacity': 11,
'description': None,
'ending_at': current_date,
'event_type_id': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host_id': None,
'id': 2,
'lang': None,
'online_event': False,
'organization_id': None,
'published_at': None,
'starting_at': current_date,
'status': 'DRAFT',
'sync_desc': None,
'sync_status': 'PENDING',
'title': None,
'url': 'https://www.google.com/',
'venue_id': None,
}])
self.assertEqual(self.cache.keys(), [])
base = [
self.generate_models(authenticate=True, models=old_model[0]),
self.generate_models(event=self.get_event(2), models=base),
]
self.test_all_academy_events(base)
self.assertEqual(self.cache.keys(), cache_keys)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_event_type_with_results(self):
self.headers(academy=1)
url = reverse_lazy('events:type')
event_type_kwargs = {
"slug": "potato",
"name": "Potato",
"created_at": timezone.now(),
"updated_at": timezone.now()
}
model = self.generate_models(authenticate=True,
event=True,
event_type=True,
event_type_kwargs=event_type_kwargs)
response = self.client.get(url)
json = response.json()
expected = [{
'academy': model['event_type'].academy,
'id': model['event_type'].id,
'name': model['event_type'].name,
'slug': model['event_type'].slug
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_type_dict(), [{
**self.model_to_dict(model, 'event_type'),
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_event_type_no_match_slug(self):
self.headers(academy=1)
url = reverse_lazy('events:type') + '?academy=banana'
event_type_kwargs = {
"slug": "potato",
"name": "Potato",
"created_at": timezone.now(),
"updated_at": timezone.now()
}
model = self.generate_models(authenticate=True,
event=True,
event_type=True,
event_type_kwargs=event_type_kwargs)
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_type_dict(), [{
**self.model_to_dict(model, 'event_type'),
}])
class MediaTestSuite(MediaTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_wrong_academy(self):
"""Test /answer without auth"""
url = reverse_lazy('media:root')
response = self.client.get(url, **{'HTTP_Academy': 1})
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('media:root')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail':
"You (user: 1) don't have this capability: read_media for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
models = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato')
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True)
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_with_category(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True,
category=True)
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.print_model(model, 'media')
self.print_model(model, 'category')
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash':
model['media'].hash,
'hits':
model['media'].hits,
'id':
model['media'].id,
'mime':
model['media'].mime,
'name':
model['media'].name,
'slug':
model['media'].slug,
'url':
model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_with_category_with_bad_academy_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True,
category=True)
url = reverse_lazy('media:root') + '?academy=0'
response = self.client.get(url)
json = response.json()
self.print_model(model, 'media')
self.print_model(model, 'category')
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_with_category_with_academy_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True,
category=True)
url = reverse_lazy('media:root') + '?academy=1'
response = self.client.get(url)
json = response.json()
self.print_model(model, 'media')
self.print_model(model, 'category')
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash':
model['media'].hash,
'hits':
model['media'].hits,
'id':
model['media'].id,
'mime':
model['media'].mime,
'name':
model['media'].name,
'slug':
model['media'].slug,
'url':
model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_with_category_with_bad_mime_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True,
category=True)
url = reverse_lazy('media:root') + '?mime=application/hitman'
response = self.client.get(url)
json = response.json()
self.print_model(model, 'media')
self.print_model(model, 'category')
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root_with_category_with_mime_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True,
category=True)
url = reverse_lazy('media:root') + '?mime=' + model['media'].mime
response = self.client.get(url)
json = response.json()
self.print_model(model, 'media')
self.print_model(model, 'category')
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash':
model['media'].hash,
'hits':
model['media'].hits,
'id':
model['media'].id,
'mime':
model['media'].mime,
'name':
model['media'].name,
'slug':
model['media'].slug,
'url':
model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
def test_root_pagination_with_105(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(media=True, models=base)
for _ in range(0, 105)
]
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
expected = [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models if model['media'].id < 101]
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
def test_root_pagination_first_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(media=True, models=base)
for _ in range(0, 10)
]
url = reverse_lazy('media:root') + '?limit=5&offset=0'
response = self.client.get(url)
json = response.json()
expected = {
'count':
10,
'first':
None,
'last':
'http://testserver/v1/media/?limit=5&offset=5',
'next':
'http://testserver/v1/media/?limit=5&offset=5',
'previous':
None,
'results': [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models if model['media'].id < 6]
}
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
def test_root_pagination_last_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(media=True, models=base)
for _ in range(0, 10)
]
url = reverse_lazy('media:root') + '?limit=5&offset=5'
response = self.client.get(url)
json = response.json()
expected = {
'count':
10,
'first':
'http://testserver/v1/media/?limit=5',
'last':
None,
'next':
None,
'previous':
'http://testserver/v1/media/?limit=5',
'results': [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models if model['media'].id > 5]
}
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
def test_root_pagination_after_last_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(media=True, models=base)
for _ in range(0, 10)
]
url = reverse_lazy('media:root') + '?limit=5&offset=10'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/media/?limit=5',
'last': None,
'next': None,
'previous': 'http://testserver/v1/media/?limit=5&offset=5',
'results': []
}
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
class CohortAllTestSuite(AdmissionsTestCase):
"""Test /cohort/all"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_without_auth(self):
"""Test /cohort/all without auth"""
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_without_data(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True)
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_cohort_but_without_profile_academy(self):
"""Test /cohort/all without auth"""
url = reverse_lazy('admissions:cohort_all')
model = self.generate_models(authenticate=True, cohort=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
"""
🔽🔽🔽 Sort querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all__with_data__with_sort(self):
"""Test /cohort/all without auth"""
base = self.generate_models(authenticate=True,
profile_academy=True,
skip_cohort=True)
models = [
self.generate_models(cohort=True, syllabus=True, models=base)
for _ in range(0, 2)
]
ordened_models = sorted(models,
key=lambda x: x['cohort'].slug,
reverse=True)
url = reverse_lazy('admissions:cohort_all') + '?sort=-slug'
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'current_day':
model.cohort.current_day,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model.cohort.kickoff_date.isoformat()),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
} for model in ordened_models]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_bad_get_academy(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?academy=they-killed-kenny'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_academy(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
syllabus=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?academy={model.academy.slug}'
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model.cohort.kickoff_date.isoformat()),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'current_day':
model.cohort.current_day,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_bad_get_location(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?location=they-killed-kenny'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_location(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
syllabus=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?location={model.academy.slug}'
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model.cohort.kickoff_date.isoformat()),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'current_day':
model.cohort.current_day,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_location_with_comma(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
syllabus=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?location={model.academy.slug},they-killed-kenny'
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model.cohort.kickoff_date.isoformat()),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'current_day':
model.cohort.current_day,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_upcoming_false(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
syllabus=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?upcoming=false'
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model.cohort.kickoff_date.isoformat()),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'current_day':
model.cohort.current_day,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_upcoming_true_without_current_data(
self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?upcoming=true'
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_upcoming_true_with_current_data(
self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
impossible_kickoff_date=True,
syllabus=True)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?upcoming=true'
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
self.datetime_to_iso(model['cohort'].kickoff_date),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'current_day':
model.cohort.current_day,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data(self):
"""Test /cohort/all without auth"""
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
syllabus=True)
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
expected = [{
'id':
model.cohort.id,
'slug':
model.cohort.slug,
'name':
model.cohort.name,
'never_ends':
model['cohort'].never_ends,
'private':
model['cohort'].private,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model.cohort.kickoff_date.isoformat()),
'ending_date':
model.cohort.ending_date,
'stage':
model.cohort.stage,
'language':
model.cohort.language,
'current_day':
model.cohort.current_day,
'syllabus': {
'version': model.cohort.syllabus.version,
'certificate': {
'id':
model.cohort.syllabus.certificate.id,
'slug':
model.cohort.syllabus.certificate.slug,
'name':
model.cohort.syllabus.certificate.name,
'duration_in_days':
model.cohort.syllabus.certificate.duration_in_days,
}
},
'academy': {
'id': model.cohort.academy.id,
'slug': model.cohort.academy.slug,
'name': model.cohort.academy.name,
'country': {
'code': model.cohort.academy.country.code,
'name': model.cohort.academy.country.name,
},
'city': {
'name': model.cohort.academy.city.name,
},
'logo_url': model.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_but_is_private(self):
"""Test /cohort/all without auth"""
cohort_kwargs = {'private': True}
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
syllabus=True,
cohort_kwargs=cohort_kwargs)
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_cohort_dict(), [{
**self.model_to_dict(model, 'cohort')
}])
class AcademyCohortTestSuite(MonitoringTestCase):
"""
🔽🔽🔽 With bad entity 🔽🔽🔽
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def tests_send_survey_reminder_no_survey(self):
monitor_script_kwargs = {"script_slug": "send_survey_reminder"}
model = self.generate_models(academy=True, monitor_script=True,
monitor_script_kwargs=monitor_script_kwargs
)
script = run_script(model.monitor_script)
del script['slack_payload']
del script['text']
expected = {
"severity_level": 5,
"status": 'OPERATIONAL',
}
self.assertEqual(script, expected)
self.assertEqual(self.all_monitor_script_dict(), [{
**self.model_to_dict(model, 'monitor_script'),
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def tests_send_survey_ending_date_less_than_now(self):
monitor_script_kwargs = {"script_slug": "send_survey_reminder"}
ending_date = timezone.now() - timedelta(weeks=1)
sent_at = timezone.now() - timedelta(weeks=5)
model = self.generate_models(cohort=True, monitor_script=True,
monitor_script_kwargs=monitor_script_kwargs,
cohort_kwargs={
'ending_date': ending_date},
survey=True, survey_kwargs={'sent_at': sent_at})
script = run_script(model.monitor_script)
del script['slack_payload']
del script['text']
expected = {
"severity_level": 5,
"status": 'OPERATIONAL',
}
self.assertEqual(script, expected)
self.assertEqual(self.all_monitor_script_dict(), [{
**self.model_to_dict(model, 'monitor_script'),
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def tests_send_survey_kickoff_date_greater_than_now(self):
monitor_script_kwargs = {"script_slug": "send_survey_reminder"}
kickoff_date = timezone.now() + timedelta(weeks=1)
sent_at = timezone.now() - timedelta(weeks=5)
model = self.generate_models(cohort=True, monitor_script=True,
monitor_script_kwargs=monitor_script_kwargs,
cohort_kwargs={
'kickoff_date': kickoff_date},
survey=True, survey_kwargs={'sent_at': sent_at})
script = run_script(model.monitor_script)
del script['slack_payload']
del script['text']
expected = {
"severity_level": 5,
"status": 'OPERATIONAL'
}
self.assertEqual(script, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def tests_send_survey_latest_survey_less_four_weeks(self):
monitor_script_kwargs = {"script_slug": "send_survey_reminder"}
ending_date = timezone.now() + timedelta(weeks=2)
kickoff_date = timezone.now() - timedelta(weeks=12)
base = self.generate_models(academy=True, cohort=True, monitor_script=True,
monitor_script_kwargs=monitor_script_kwargs,
cohort_kwargs={'ending_date': ending_date,
"kickoff_date": kickoff_date})
sent_at = timezone.now() - timedelta(weeks=2)
models = [self.generate_models(survey=True, survey_kwargs={'sent_at': sent_at},
models=base)
for _ in range(0, 2)]
script = run_script(models[1].monitor_script)
del script['slack_payload']
del script['text']
expected = {
"severity_level": 5,
"status": 'OPERATIONAL',
}
self.assertEqual(script, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def tests_send_survey_latest_survey_greater_four_weeks(self):
monitor_script_kwargs = {"script_slug": "send_survey_reminder"}
ending_date = timezone.now() + timedelta(days=2)
kickoff_date = timezone.now() - timedelta(days=2)
base = self.generate_models(academy=True, cohort=True, monitor_script=True,
monitor_script_kwargs=monitor_script_kwargs,
cohort_kwargs={'ending_date': ending_date,
"kickoff_date": kickoff_date})
sent_at = timezone.now() - timedelta(weeks=6)
models = [self.generate_models(survey=True, survey_kwargs={'sent_at': sent_at},
models=base)
for _ in range(0, 2)]
script = run_script(models[1].monitor_script)
del script['slack_payload']
del script['text']
expected = {
'severity_level': 5,
'error_slug': None,
'status': 'MINOR',
}
self.assertEqual(script, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def tests_send_survey_latest_survey_greater_four_weeks_two_cohorts_two_survey(self):
monitor_script_kwargs = {"script_slug": "send_survey_reminder"}
ending_date = timezone.now() + timedelta(days=2)
kickoff_date = timezone.now() - timedelta(days=2)
base = self.generate_models(academy=True, monitor_script=True,
monitor_script_kwargs=monitor_script_kwargs,
)
sent_at = timezone.now() - timedelta(weeks=6)
models = [self.generate_models(survey=True, cohort=True, survey_kwargs={'sent_at': sent_at},
models=base, cohort_kwargs={'ending_date': ending_date,
"kickoff_date": kickoff_date})
for _ in range(0, 2)]
script = run_script(models[1].monitor_script)
del script['slack_payload']
del script['text']
expected = {
'severity_level': 5,
'status': 'MINOR',
'error_slug': None,
}
self.assertEqual(script, expected)
class MediaTestSuite(MediaTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_file_slug_without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
models = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
url = reverse_lazy('media:file_slug', kwargs={'media_slug': 'they-killed-kenny'})
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'Resource not found',
'status_code': 404
})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_media_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_file_slug_without_data_with_mask_true(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
url = reverse_lazy('media:file_slug', kwargs={'media_slug': 'they-killed-kenny'}) + '?mask=true'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'Resource not found',
'status_code': 404
})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_media_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_file_slug(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True)
url = reverse_lazy('media:file_slug', kwargs={'media_slug': model['media'].slug})
response = self.client.get(url)
self.assertEqual(response.url, model['media'].url)
self.assertEqual(response.status_code, status.HTTP_301_MOVED_PERMANENTLY)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media'),
'hits': model['media'].hits + 1,
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(REQUESTS_PATH['get'], apply_requests_get_mock([(200, 'https://potato.io', 'ok')]))
def test_file_slug_with_mask_true(self):
"""Test /answer without auth"""
self.headers(academy=1)
media_kwargs = {'url': 'https://potato.io'}
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True,
media_kwargs=media_kwargs)
url = reverse_lazy('media:file_slug', kwargs={'media_slug': model['media'].slug}) + '?mask=true'
response = self.client.get(url)
self.assertEqual(response.getvalue().decode("utf-8"), 'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media'),
'hits': model['media'].hits + 1,
}])
class CohortUserTestSuite(MarketingTestCase):
"""Test /academy/lead"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_without_auth(self):
"""Test /cohort/:id/user without auth"""
url = reverse_lazy('marketing:academy_lead')
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_without_academy_header(self):
"""Test /cohort/:id/user without auth"""
url = reverse_lazy('marketing:academy_lead')
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'Missing academy_id parameter expected for the endpoint url or '
"'Academy' header",
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_without_data(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:academy_lead')
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
url = reverse_lazy('marketing:academy_lead')
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato', form_entry=True)
response = self.client.get(url)
json = response.json()
self.assertDatetime(json[0]['created_at'])
del json[0]['created_at']
expected = [{
'country': None,
'course': None,
'email': None,
'first_name': '',
'id': 1,
'language': 'en',
'last_name': '',
'lead_type': None,
'location': None,
'storage_status': 'PENDING',
'tags': '',
'utm_campaign': None,
'utm_medium': None,
'utm_source': None,
'utm_url': None,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
}])
# TODO: we need test get method with the querystring
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_delete_without_auth(self):
"""Test /cohort/:id/user without auth"""
url = reverse_lazy('marketing:academy_lead')
response = self.client.delete(url)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_without_args_in_url_or_bulk(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_lead', role='potato')
url = reverse_lazy('marketing:academy_lead')
response = self.client.delete(url)
json = response.json()
expected = {
'detail': "Missing parameters in the querystring",
'status_code': 400
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_in_bulk_with_one(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
many_fields = ['id']
base = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_lead', role='potato', academy=True,
active_campaign_academy=True)
for field in many_fields:
form_entry_kwargs = generate_form_entry_kwargs()
model = self.generate_models(form_entry=True, contact=True,
automation=True, form_entry_kwargs=form_entry_kwargs, models=base)
url = (reverse_lazy('marketing:academy_lead') + f'?{field}=' +
str(getattr(model['form_entry'], field)))
response = self.client.delete(url)
if response.status_code != 204:
print(response.json())
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_lead_in_bulk_with_two(self):
"""Test /cohort/:id/user without auth"""
self.headers(academy=1)
many_fields = ['id']
base = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_lead', role='potato', academy=True,
active_campaign_academy=True)
for field in many_fields:
form_entry_kwargs = generate_form_entry_kwargs()
model1 = self.generate_models(form_entry=True, contact=True,
automation=True, form_entry_kwargs=form_entry_kwargs, models=base)
form_entry_kwargs = generate_form_entry_kwargs()
model2 = self.generate_models(form_entry=True, contact=True,
automation=True, form_entry_kwargs=form_entry_kwargs, models=base)
url = (reverse_lazy('marketing:academy_lead') + f'?{field}=' +
str(getattr(model1['form_entry'], field)) + ',' +
str(getattr(model2['form_entry'], field)))
response = self.client.delete(url)
if response.status_code != 204:
print(response.json())
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.all_form_entry_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_cohort_with_ten_datas_with_location_with_comma_just_get_100(self):
"""Test /cohort without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
models = [self.generate_models(form_entry=True, models=base) for _ in range(0, 105)]
ordened_models = sorted(models, key=lambda x: x['form_entry'].created_at,
reverse=True)
url = reverse_lazy('marketing:academy_lead')
response = self.client.get(url)
json = response.json()
expected = [{
'country': model['form_entry'].country,
'course': model['form_entry'].course,
'email': model['form_entry'].email,
'first_name': model['form_entry'].first_name,
'id': model['form_entry'].id,
'language': model['form_entry'].language,
'last_name': model['form_entry'].last_name,
'lead_type': model['form_entry'].lead_type,
'location': model['form_entry'].location,
'storage_status': model['form_entry'].storage_status,
'tags': model['form_entry'].tags,
'utm_campaign': model['form_entry'].utm_campaign,
'utm_medium': model['form_entry'].utm_medium,
'utm_source': model['form_entry'].utm_source,
'utm_url': model['form_entry'].utm_url,
'created_at': self.datetime_to_iso(model['form_entry'].created_at),
} for model in ordened_models][:100]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_cohort_with_ten_datas_with_location_with_comma_pagination_first_five(self):
"""Test /cohort without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
models = [self.generate_models(form_entry=True, models=base) for _ in range(0, 10)]
ordened_models = sorted(models, key=lambda x: x['form_entry'].created_at,
reverse=True)
url = reverse_lazy('marketing:academy_lead') + '?limit=5&offset=0'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': None,
'next': 'http://testserver/v1/marketing/academy/lead?limit=5&'
f'offset=5',
'previous': None,
'last': 'http://testserver/v1/marketing/academy/lead?limit=5&'
f'offset=5',
'results': [{
'country': model['form_entry'].country,
'course': model['form_entry'].course,
'email': model['form_entry'].email,
'first_name': model['form_entry'].first_name,
'id': model['form_entry'].id,
'language': model['form_entry'].language,
'last_name': model['form_entry'].last_name,
'lead_type': model['form_entry'].lead_type,
'location': model['form_entry'].location,
'storage_status': model['form_entry'].storage_status,
'tags': model['form_entry'].tags,
'utm_campaign': model['form_entry'].utm_campaign,
'utm_medium': model['form_entry'].utm_medium,
'utm_source': model['form_entry'].utm_source,
'utm_url': model['form_entry'].utm_url,
'created_at': self.datetime_to_iso(model['form_entry'].created_at),
} for model in ordened_models][:5],
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_cohort_with_ten_datas_with_location_with_comma_pagination_last_five(self):
"""Test /cohort without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
models = [self.generate_models(form_entry=True, models=base) for _ in range(0, 10)]
ordened_models = sorted(models, key=lambda x: x['form_entry'].created_at,
reverse=True)
url = reverse_lazy('marketing:academy_lead') + '?limit=5&offset=5'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/marketing/academy/lead?limit=5',
'next': None,
'previous': 'http://testserver/v1/marketing/academy/lead?limit=5',
'last': None,
'results': [{
'country': model['form_entry'].country,
'course': model['form_entry'].course,
'email': model['form_entry'].email,
'first_name': model['form_entry'].first_name,
'id': model['form_entry'].id,
'language': model['form_entry'].language,
'last_name': model['form_entry'].last_name,
'lead_type': model['form_entry'].lead_type,
'location': model['form_entry'].location,
'storage_status': model['form_entry'].storage_status,
'tags': model['form_entry'].tags,
'utm_campaign': model['form_entry'].utm_campaign,
'utm_medium': model['form_entry'].utm_medium,
'utm_source': model['form_entry'].utm_source,
'utm_url': model['form_entry'].utm_url,
'created_at': self.datetime_to_iso(model['form_entry'].created_at),
} for model in ordened_models][5:],
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_cohort_with_ten_datas_with_location_with_comma_pagination_after_last_five(self):
"""Test /cohort without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_lead', role='potato')
models = [self.generate_models(form_entry=True, models=base) for _ in range(0, 10)]
url = reverse_lazy('marketing:academy_lead') + '?limit=5&offset=10'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/marketing/academy/lead?limit=5',
'next': None,
'previous': 'http://testserver/v1/marketing/academy/lead?limit=5&'
f'offset=5',
'last': None,
'results': [],
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_form_entry_dict(), [{
**self.model_to_dict(model, 'form_entry')
} for model in models])
class SendSurveyTestSuite(FeedbackTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_question_without_cohort(self):
"""Test /answer without auth"""
model = self.generate_models(user=True)
try:
send_question(model['user'])
except Exception as e:
self.assertEquals(
str(e),
('Impossible to determine the student cohort, maybe it has '
'more than one, or cero.'))
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(MAILGUN_PATH['post'], apply_requests_post_mock())
def test_send_question_with_one_user_with_two_cohort(self):
"""Test /answer without auth"""
model = self.generate_models(cohort_user=True, cohort_user_two=True)
try:
send_question(model['user'])
except Exception as e:
self.assertEquals(
str(e),
('Impossible to determine the student cohort, maybe it has '
'more than one, or cero.'))
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(MAILGUN_PATH['post'], apply_requests_post_mock())
def test_send_question_with_cohort_with_slack_user_with_slack_team(self):
"""Test /answer without auth"""
mock_mailgun = MAILGUN_INSTANCES['post']
mock_mailgun.call_args_list = []
mock_slack = SLACK_INSTANCES['request']
mock_slack.call_args_list = []
model = self.generate_models(user=True,
cohort_user=True,
lang='en',
slack_user=True,
slack_team=True)
academy = model['cohort'].academy.name
certificate = model['cohort'].certificate.name
send_question(model['user'])
expected = [{
'academy_id': None,
'cohort_id': 1,
'comment': None,
'event_id': None,
'highest': 'very good',
'id': 1,
'lang': 'en',
'lowest': 'not good',
'mentor_id': None,
'opened_at': None,
'score': None,
'status': 'SENT',
'survey_id': None,
'title':
f'How has been your experience studying {certificate} so far?',
'token_id': 1,
'user_id': 1,
}]
dicts = [
answer for answer in self.all_answer_dict()
if isinstance(answer['created_at'], datetime)
and answer.pop('created_at')
]
self.assertEqual(dicts, expected)
# TODO: this function is broken, we have to fix it
# self.check_email_contain_a_correct_token('en', academy, dicts, mock_mailgun, model)
self.assertEqual(mock_slack.call_args_list, [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(MAILGUN_PATH['post'], apply_requests_post_mock())
@patch(SLACK_PATH['request'], apply_slack_requests_request_mock())
def test_send_question_with_cohort_with_slack_user_with_slack_team_with_credentials_slack(
self):
"""Test /answer without auth"""
mock_mailgun = MAILGUN_INSTANCES['post']
mock_mailgun.call_args_list = []
mock_slack = SLACK_INSTANCES['request']
mock_slack.call_args_list = []
model = self.generate_models(user=True,
cohort_user=True,
lang='en',
slack_user=True,
slack_team=True,
credentials_slack=True,
academy=True)
academy = model['cohort'].academy.name
certificate = model['cohort'].certificate.name
try:
send_question(model['user'])
except Exception as e:
self.assertEqual(str(e), f"Team owner not has slack credentials")
expected = [{
'id': 1,
'title':
f'How has been your experience studying {certificate} so far?',
'lowest': 'not good',
'highest': 'very good',
'lang': 'en',
'cohort_id': 1,
'academy_id': None,
'mentor_id': None,
'event_id': None,
'token_id': 1,
'score': None,
'comment': None,
'survey_id': None,
'status': 'PENDING',
'user_id': 1,
'opened_at': None,
}]
dicts = [
answer for answer in self.all_answer_dict()
if isinstance(answer['created_at'], datetime)
and answer.pop('created_at')
]
self.assertEqual(dicts, expected)
# TODO: this function is broken, we have to fix it
# self.check_email_contain_a_correct_token('en', academy, dicts, mock_mailgun, model)
self.assertEqual(mock_slack.call_args_list, [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(MAILGUN_PATH['post'], apply_requests_post_mock())
@patch(SLACK_PATH['request'], apply_slack_requests_request_mock())
def test_send_question_with_cohort_lang_en(self):
"""Test /answer without auth"""
mock_mailgun = MAILGUN_INSTANCES['post']
mock_mailgun.call_args_list = []
mock_slack = SLACK_INSTANCES['request']
mock_slack.call_args_list = []
model = self.generate_models(user=True,
cohort_user=True,
lang='en',
slack_user=True,
slack_team=True,
credentials_slack=True,
academy=True,
slack_team_owner=True)
academy = model['cohort'].academy.name
certificate = model['cohort'].certificate.name
try:
send_question(model['user'])
except Exception as e:
self.assertEqual(str(e), f"Team owner not has slack credentials")
expected = [{
'id': 1,
'title':
f'How has been your experience studying {certificate} so far?',
'lowest': 'not good',
'highest': 'very good',
'lang': 'en',
'cohort_id': 1,
'academy_id': None,
'mentor_id': None,
'event_id': None,
'token_id': 1,
'score': None,
'comment': None,
'status': 'SENT',
'user_id': 1,
'survey_id': None,
'opened_at': None,
}]
print('asdasd', model['slack_team'].__dict__)
dicts = [
answer for answer in self.all_answer_dict()
if isinstance(answer['created_at'], datetime)
and answer.pop('created_at')
]
self.assertEqual(dicts, expected)
# TODO: this function is broken, we have to fix it
# self.check_email_contain_a_correct_token('en', academy, dicts, mock_mailgun, model)
# TODO: this function is broken, we have to fix it
# self.check_stack_contain_a_correct_token('en', academy, mock_slack, model)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(MAILGUN_PATH['post'], apply_requests_post_mock())
@patch(SLACK_PATH['request'], apply_slack_requests_request_mock())
def test_send_question_with_cohort_lang_es(self):
"""Test /answer without auth"""
mock_mailgun = MAILGUN_INSTANCES['post']
mock_mailgun.call_args_list = []
mock_slack = SLACK_INSTANCES['request']
mock_slack.call_args_list = []
model = self.generate_models(user=True,
cohort_user=True,
lang='es',
slack_user=True,
slack_team=True,
credentials_slack=True,
academy=True,
slack_team_owner=True)
academy = model['cohort'].academy.name
certificate = model['cohort'].certificate.name
send_question(model['user'])
expected = [{
'academy_id': None,
'cohort_id': 1,
'comment': None,
'event_id': None,
'highest': 'muy buena',
'id': 1,
'lang': 'es',
'lowest': 'mala',
'mentor_id': None,
'opened_at': None,
'score': None,
'status': 'SENT',
'survey_id': None,
'title': f'¿Cómo ha sido tu experiencia estudiando {certificate}?',
'token_id': 1,
'user_id': 1,
}]
dicts = [
answer for answer in self.all_answer_dict()
if isinstance(answer['created_at'], datetime)
and answer.pop('created_at')
]
self.assertEqual(dicts, expected)
self.assertEqual(self.count_token(), 1)
class academyTestSuite(AdmissionsTestCase):
"""Test /academy"""
def test_academy_without_auth(self):
"""Test /academy without auth"""
url = reverse_lazy('admissions:academy')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_academy_without_data(self):
"""Test /academy without auth"""
url = reverse_lazy('admissions:academy')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_academy(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_with_data(self):
"""Test /academy without auth"""
self.generate_models(authenticate=True, academy=True)
url = reverse_lazy('admissions:academy')
model_dict = self.remove_dinamics_fields(self.academy.__dict__)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'id': self.academy.id,
'name': self.academy.name,
'slug': self.academy.slug,
'street_address': self.academy.street_address,
'country': self.academy.country.code,
'city': self.academy.city.id,
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_academy(), 1)
self.assertEqual(self.get_academy_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_new_without_require_fields(self):
"""Test /academy without auth"""
url = reverse_lazy('admissions:academy')
self.generate_models(authenticate=True, academy=True)
data = {}
response = self.client.post(url, data)
json = response.json()
self.assertEqual(json, {
# 'city': ['This field is required.'],
# 'country': ['This field is required.'],
'slug': ['This field is required.'],
'name': ['This field is required.'],
'street_address': ['This field is required.']
})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_academy_new_element(self):
"""Test /academy without auth"""
url = reverse_lazy('admissions:academy')
self.generate_models(authenticate=True, country=True)
data = {
'slug': 'oh-my-god',
'name': 'they killed kenny',
'street_address': 'you bastards',
'country': self.country.code,
'city': self.city.id,
}
response = self.client.post(url, data)
json = response.json()
expected = {
'id': 1,
}
expected.update(data)
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
model_dict = self.get_academy_dict(1)
data['country_id'] = data['country']
data['city_id'] = data['city']
del data['country']
del data['city']
model_dict.update(data)
self.assertEqual(self.count_academy(), 1)
self.assertEqual(self.get_academy_dict(1), model_dict)
class MediaTestSuite(MediaTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category_without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('media:category')
response = self.client.get(url)
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category_wrong_academy(self):
"""Test /answer without auth"""
url = reverse_lazy('media:category')
response = self.client.get(url, **{'HTTP_Academy': 1})
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category_without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('media:category')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail':
"You (user: 1) don't have this capability: read_media for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category_without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
models = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato')
url = reverse_lazy('media:category')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_category_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
category=True)
url = reverse_lazy('media:category')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'id': 1,
'medias': 0,
'name': model['category'].name,
'slug': model['category'].slug,
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_category_dict(), [{
**self.model_to_dict(model, 'category')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category_with_media(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_media',
role='potato',
media=True,
category=True)
url = reverse_lazy('media:category')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}])
self.assertEqual(self.all_category_dict(), [{
**self.model_to_dict(model, 'category')
}])
def test_category_pagination_with_105(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(category=True, models=base)
for _ in range(0, 105)
]
url = reverse_lazy('media:category')
response = self.client.get(url)
json = response.json()
expected = [{
'id': model['category'].id,
'medias': 0,
'name': model['category'].name,
'slug': model['category'].slug,
} for model in models if model['category'].id < 101]
self.assertEqual(json, expected)
self.assertEqual(self.all_category_dict(), [{
**self.model_to_dict(model, 'category')
} for model in models])
def test_category_pagination_first_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(category=True, models=base)
for _ in range(0, 10)
]
url = reverse_lazy('media:category') + '?limit=5&offset=0'
response = self.client.get(url)
json = response.json()
expected = {
'count':
10,
'first':
None,
'last':
'http://testserver/v1/media/category?limit=5&offset=5',
'next':
'http://testserver/v1/media/category?limit=5&offset=5',
'previous':
None,
'results': [{
'id': model['category'].id,
'medias': 0,
'name': model['category'].name,
'slug': model['category'].slug,
} for model in models if model['category'].id < 6]
}
self.assertEqual(json, expected)
self.assertEqual(self.all_category_dict(), [{
**self.model_to_dict(model, 'category')
} for model in models])
def test_category_pagination_last_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(category=True, models=base)
for _ in range(0, 10)
]
url = reverse_lazy('media:category') + '?limit=5&offset=5'
response = self.client.get(url)
json = response.json()
expected = {
'count':
10,
'first':
'http://testserver/v1/media/category?limit=5',
'last':
None,
'next':
None,
'previous':
'http://testserver/v1/media/category?limit=5',
'results': [{
'id': model['category'].id,
'medias': 0,
'name': model['category'].name,
'slug': model['category'].slug,
} for model in models if model['category'].id > 5]
}
self.assertEqual(json, expected)
self.assertEqual(self.all_category_dict(), [{
**self.model_to_dict(model, 'category')
} for model in models])
def test_category_pagination_after_last_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True,
role=role,
capability='read_media',
profile_academy=True)
models = [
self.generate_models(category=True, models=base)
for _ in range(0, 10)
]
url = reverse_lazy('media:category') + '?limit=5&offset=10'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/media/category?limit=5',
'last': None,
'next': None,
'previous': 'http://testserver/v1/media/category?limit=5&offset=5',
'results': []
}
self.assertEqual(json, expected)
self.assertEqual(self.all_category_dict(), [{
**self.model_to_dict(model, 'category')
} for model in models])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_category_post(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_media',
role='potato')
url = reverse_lazy('media:category')
data = {
'name': 'They killed kenny',
'slug': 'they-killed-kenny',
}
response = self.client.post(url, data)
json = response.json()
expected = {
'id': 1,
**data,
}
self.assertDatetime(json['created_at'])
self.assertDatetime(json['updated_at'])
del json['created_at']
del json['updated_at']
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(self.all_category_dict(), [expected])
class CertificateTestSuite(CertificateTestCase):
"""Test /certificate"""
"""
🔽🔽🔽 Auth
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_cohort_user__without_auth(self):
"""Test /root without auth"""
self.headers(academy=1)
url = reverse_lazy('certificate:root')
response = self.client.post(url, {})
json = response.json()
self.assertEqual(
json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
"""
🔽🔽🔽 Post method
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_re_attemps_without_capability(self):
"""Test /root with auth"""
""" No capability for the request"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
user=True,
profile_academy=True)
url = reverse_lazy('certificate:root')
data = [{
'cohort_slug': model['cohort'].slug,
'user_id': model['user'].id,
}]
response = self.client.post(url, data, format='json')
json = response.json()
expected = {
'detail':
"You (user: 1) don't have this capability: crud_certificate for academy 1",
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 403)
self.assertEqual(self.all_user_specialty_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_re_attemps_without_cohort_user(self):
"""Test /root with auth"""
""" No cohort_user for the request"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
user=True,
profile_academy=True,
role="STUDENT",
capability='crud_certificate')
url = reverse_lazy('certificate:root')
data = [{
'cohort_slug': model['cohort'].slug,
'user_id': model['user'].id,
}]
response = self.client.post(url, data, format='json')
json = response.json()
expected = {
'detail': 'student-not-found-in-cohort',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 404)
self.assertEqual(self.all_user_specialty_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_re_attemps_without_user_specialty(self):
"""Test /root with auth"""
""" No user_specialty for the request"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
user=True,
profile_academy=True,
role="STUDENT",
capability='crud_certificate',
cohort_user=True)
url = reverse_lazy('certificate:root')
data = [{
'cohort_slug': model['cohort'].slug,
'user_id': model['user'].id,
}]
response = self.client.post(url, data, format='json')
json = response.json()
expected = {'detail': 'no-user-specialty', 'status_code': 404}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 404)
self.assertEqual(self.all_user_specialty_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_re_attemps(self):
"""Test /root with auth"""
""" Good Request """
self.headers(academy=1)
model = self.generate_models(
authenticate=True,
cohort=True,
user=True,
profile_academy=True,
capability='crud_certificate',
role='STUDENT',
cohort_user=True,
syllabus=True,
specialty=True,
layout_design=True,
cohort_stage="ENDED",
cohort_user_finantial_status='UP_TO_DATE',
cohort_user_educational_status='GRADUATED',
user_specialty=True,
cohort_finished=True)
base = model.copy()
del base['user']
del base['cohort_user']
teacher_model = self.generate_models(user=True,
cohort_user=True,
cohort_user_role='TEACHER',
models=base)
url = reverse_lazy('certificate:root')
data = [{
'cohort_slug': model['cohort'].slug,
'user_id': model['user'].id,
}]
response = self.client.post(url, data, format='json')
json = response.json()
self.assertDatetime(json[0]['updated_at'])
del json[0]['updated_at']
del json[0]['signed_by']
expected = [{
'academy': {
'id': 1,
'logo_url': model['academy'].logo_url,
'name': model['academy'].name,
'slug': model['academy'].slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': model['cohort'].name,
'slug': model['cohort'].slug,
'syllabus': {
'certificate': {
'duration_in_hours':
model['certificate'].duration_in_hours
}
}
},
'created_at':
self.datetime_to_iso(model['user_specialty'].created_at),
'expires_at':
model['user_specialty'].expires_at,
'id':
1,
'layout': {
'name': model['layout_design'].name,
'slug': model['layout_design'].slug
},
'preview_url':
model['user_specialty'].preview_url,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(model['specialty'].created_at),
'id': 1,
'logo_url': None,
'name': model['specialty'].name,
'slug': model['specialty'].slug,
'updated_at':
self.datetime_to_iso(model['specialty'].updated_at),
},
'status':
'PENDING',
'status_text':
None,
'user': {
'first_name': model['user'].first_name,
'id': 1,
'last_name': model['user'].last_name
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_user_specialty_dict(), [{
'academy_id':
1,
'cohort_id':
1,
'expires_at':
None,
'id':
1,
'layout_id':
1,
'preview_url':
model['user_specialty'].preview_url,
'signed_by':
teacher_model['user'].first_name + " " +
teacher_model['user'].last_name,
'signed_by_role':
'Director',
'specialty_id':
1,
'status':
'PERSISTED',
'status_text':
'Certificate successfully queued for PDF generation',
'user_id':
1,
'token':
"9e76a2ab3bd55454c384e0a5cdb5298d17285949"
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_re_attemps_two_certificates(self):
"""Test /root with auth"""
""" Good Request """
self.headers(academy=1)
base = self.generate_models(authenticate=True,
cohort=True,
cohort_finished=True,
capability='crud_certificate',
role='STUDENT',
profile_academy=True,
syllabus=True,
specialty=True,
layout_design=True,
cohort_stage="ENDED")
del base['user']
user_specialty_1_kwargs = {"token": "qwerrty"}
user_specialty_2_kwargs = {"token": "huhuhuhuhu"}
models = [
self.generate_models(user=True,
cohort_user=True,
cohort_user_educational_status='GRADUATED',
cohort_user_finantial_status='UP_TO_DATE',
user_specialty=True,
user_specialty_kwargs=user_specialty_2_kwargs,
models=base),
self.generate_models(user=True,
cohort_user=True,
cohort_user_educational_status='GRADUATED',
cohort_user_finantial_status='UP_TO_DATE',
user_specialty=True,
user_specialty_kwargs=user_specialty_1_kwargs,
models=base),
]
teacher_model = self.generate_models(user=True,
cohort_user=True,
cohort_user_role='TEACHER',
models=base)
url = reverse_lazy('certificate:root')
data = [
{
'cohort_slug': models[0].cohort.slug,
'user_id': models[0].user.id,
},
{
'cohort_slug': models[1].cohort.slug,
'user_id': models[1].user.id,
},
]
response = self.client.post(url, data, format='json')
json = response.json()
self.assertDatetime(json[0]['updated_at'])
del json[0]['updated_at']
del json[0]['signed_by']
self.assertDatetime(json[1]['updated_at'])
del json[1]['updated_at']
del json[1]['signed_by']
expected = [{
'academy': {
'id': 1,
'logo_url': models[0].academy.logo_url,
'name': models[0].academy.name,
'slug': models[0].academy.slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
'syllabus': {
'certificate': {
'duration_in_hours':
models[0].certificate.duration_in_hours
}
}
},
'created_at':
self.datetime_to_iso(models[0].user_specialty.created_at),
'expires_at':
models[0].user_specialty.expires_at,
'id':
1,
'layout': {
'name': models[0].layout_design.name,
'slug': models[0].layout_design.slug
},
'preview_url':
models[0].user_specialty.preview_url,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(models[0].specialty.created_at),
'id': 1,
'logo_url': None,
'name': models[0].specialty.name,
'slug': models[0].specialty.slug,
'updated_at':
self.datetime_to_iso(models[0].specialty.updated_at),
},
'status':
'PENDING',
'status_text':
None,
'user': {
'first_name': models[0].user.first_name,
'id': 2,
'last_name': models[0].user.last_name
}
}, {
'academy': {
'id': 1,
'logo_url': models[1].academy.logo_url,
'name': models[1].academy.name,
'slug': models[1].academy.slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': models[1].cohort.name,
'slug': models[1].cohort.slug,
'syllabus': {
'certificate': {
'duration_in_hours':
models[1].certificate.duration_in_hours
}
}
},
'created_at':
self.datetime_to_iso(models[1].user_specialty.created_at),
'expires_at':
models[1].user_specialty.expires_at,
'id':
2,
'layout': {
'name': models[1].layout_design.name,
'slug': models[1].layout_design.slug
},
'preview_url':
models[1].user_specialty.preview_url,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(models[1].specialty.created_at),
'id': 1,
'logo_url': None,
'name': models[1].specialty.name,
'slug': models[1].specialty.slug,
'updated_at':
self.datetime_to_iso(models[1].specialty.updated_at),
},
'status':
'PENDING',
'status_text':
None,
'user': {
'first_name': models[1].user.first_name,
'id': 3,
'last_name': models[1].user.last_name
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_user_specialty_dict(), [
{
'academy_id':
1,
'cohort_id':
1,
'expires_at':
None,
'id':
1,
'layout_id':
1,
'preview_url':
models[0].user_specialty.preview_url,
'signed_by':
teacher_model['user'].first_name + " " +
teacher_model['user'].last_name,
'signed_by_role':
'Director',
'specialty_id':
1,
'status':
'PERSISTED',
'status_text':
'Certificate successfully queued for PDF generation',
'user_id':
2,
'token':
"huhuhuhuhu"
},
{
'academy_id':
1,
'cohort_id':
1,
'expires_at':
None,
'id':
2,
'layout_id':
1,
'preview_url':
models[1].user_specialty.preview_url,
'signed_by':
teacher_model['user'].first_name + " " +
teacher_model['user'].last_name,
'signed_by_role':
'Director',
'specialty_id':
1,
'status':
'PERSISTED',
'status_text':
'Certificate successfully queued for PDF generation',
'user_id':
3,
'token':
"qwerrty"
},
])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate__with_full_name_in_querystring(self):
"""Test /root """
self.headers(academy=1)
base = self.generate_models(authenticate=True,
cohort=True,
cohort_finished=True,
capability='read_certificate',
role='potato',
academy=True,
profile_academy=True,
specialty=True)
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Michael',
'last_name': 'Jordan',
}
user_specialty_kwargs_1 = {"token": "123dfefef1123rerf346g"}
user_specialty_kwargs_2 = {"token": "jojfsdknjbs1123rerf346g"}
models = [
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs,
user_specialty_kwargs=user_specialty_kwargs_1,
models=base),
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs_2,
user_specialty_kwargs=user_specialty_kwargs_2,
models=base)
]
base_url = reverse_lazy('certificate:root')
url = f'{base_url}?like=Rene Descartes'
response = self.client.get(url)
json = response.json()
expected = [{
'academy': {
'id': 1,
'logo_url': models[0].academy.logo_url,
'name': models[0].academy.name,
'slug': models[0].academy.slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
'syllabus': {}
},
'created_at':
self.datetime_to_iso(models[0].user_specialty.created_at),
'expires_at':
models[0].user_specialty.expires_at,
'id':
1,
'layout':
None,
'preview_url':
models[0].user_specialty.preview_url,
'signed_by':
models[0].user_specialty.signed_by,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(models[0].specialty.created_at),
'id': 1,
'logo_url': None,
'name': models[0].specialty.name,
'slug': models[0].specialty.slug,
'updated_at':
self.datetime_to_iso(models[0].specialty.updated_at),
},
'status':
'PENDING',
'status_text':
None,
'updated_at':
self.datetime_to_iso(models[0].user_specialty.updated_at),
'user': {
'first_name': models[0].user.first_name,
'id': 2,
'last_name': models[0].user.last_name
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
"""
🔽🔽🔽 With full like querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate__with_first_name_in_querystring(self):
"""Test /root """
self.headers(academy=1)
base = self.generate_models(authenticate=True,
cohort=True,
cohort_finished=True,
capability='read_certificate',
role='potato',
academy=True,
profile_academy=True,
specialty=True)
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Michael',
'last_name': 'Jordan',
}
user_specialty_kwargs_1 = {"token": "123dfefef1123rerf346g"}
user_specialty_kwargs_2 = {"token": "jojfsdknjbs1123rerf346g"}
models = [
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs,
user_specialty_kwargs=user_specialty_kwargs_1,
models=base),
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs_2,
user_specialty_kwargs=user_specialty_kwargs_2,
models=base)
]
base_url = reverse_lazy('certificate:root')
url = f'{base_url}?like=Rene'
response = self.client.get(url)
json = response.json()
expected = [{
'academy': {
'id': 1,
'logo_url': models[0].academy.logo_url,
'name': models[0].academy.name,
'slug': models[0].academy.slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
'syllabus': {}
},
'created_at':
self.datetime_to_iso(models[0].user_specialty.created_at),
'expires_at':
models[0].user_specialty.expires_at,
'id':
1,
'layout':
None,
'preview_url':
models[0].user_specialty.preview_url,
'signed_by':
models[0].user_specialty.signed_by,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(models[0].specialty.created_at),
'id': 1,
'logo_url': None,
'name': models[0].specialty.name,
'slug': models[0].specialty.slug,
'updated_at':
self.datetime_to_iso(models[0].specialty.updated_at),
},
'status':
'PENDING',
'status_text':
None,
'updated_at':
self.datetime_to_iso(models[0].user_specialty.updated_at),
'user': {
'first_name': models[0].user.first_name,
'id': 2,
'last_name': models[0].user.last_name
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate__with_last_name_in_querystring(self):
"""Test /root """
self.headers(academy=1)
base = self.generate_models(authenticate=True,
cohort=True,
cohort_finished=True,
capability='read_certificate',
role='potato',
academy=True,
profile_academy=True,
specialty=True)
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Michael',
'last_name': 'Jordan',
}
user_specialty_kwargs_1 = {"token": "123dfefef1123rerf346g"}
user_specialty_kwargs_2 = {"token": "jojfsdknjbs1123rerf346g"}
models = [
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs,
user_specialty_kwargs=user_specialty_kwargs_1,
models=base),
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs_2,
user_specialty_kwargs=user_specialty_kwargs_2,
models=base)
]
base_url = reverse_lazy('certificate:root')
url = f'{base_url}?like=Descartes'
response = self.client.get(url)
json = response.json()
expected = [{
'academy': {
'id': 1,
'logo_url': models[0].academy.logo_url,
'name': models[0].academy.name,
'slug': models[0].academy.slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
'syllabus': {}
},
'created_at':
self.datetime_to_iso(models[0].user_specialty.created_at),
'expires_at':
models[0].user_specialty.expires_at,
'id':
1,
'layout':
None,
'preview_url':
models[0].user_specialty.preview_url,
'signed_by':
models[0].user_specialty.signed_by,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(models[0].specialty.created_at),
'id': 1,
'logo_url': None,
'name': models[0].specialty.name,
'slug': models[0].specialty.slug,
'updated_at':
self.datetime_to_iso(models[0].specialty.updated_at),
},
'status':
'PENDING',
'status_text':
None,
'updated_at':
self.datetime_to_iso(models[0].user_specialty.updated_at),
'user': {
'first_name': models[0].user.first_name,
'id': 2,
'last_name': models[0].user.last_name
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate__with_email_in_querystring(self):
"""Test /root """
self.headers(academy=1)
base = self.generate_models(authenticate=True,
cohort=True,
cohort_finished=True,
capability='read_certificate',
role='potato',
academy=True,
profile_academy=True,
specialty=True)
del base['user']
user_kwargs = {
'email': '*****@*****.**',
'first_name': 'Rene',
'last_name': 'Descartes',
}
user_kwargs_2 = {
'email': '*****@*****.**',
'first_name': 'Michael',
'last_name': 'Jordan',
}
user_specialty_kwargs_1 = {"token": "123dfefef1123rerf346g"}
user_specialty_kwargs_2 = {"token": "jojfsdknjbs1123rerf346g"}
models = [
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs,
user_specialty_kwargs=user_specialty_kwargs_1,
models=base),
self.generate_models(user=True,
user_specialty=True,
cohort_user=True,
user_kwargs=user_kwargs_2,
user_specialty_kwargs=user_specialty_kwargs_2,
models=base)
]
base_url = reverse_lazy('certificate:root')
url = f'{base_url}[email protected]'
response = self.client.get(url)
json = response.json()
expected = [{
'academy': {
'id': 1,
'logo_url': models[0].academy.logo_url,
'name': models[0].academy.name,
'slug': models[0].academy.slug,
'website_url': None
},
'cohort': {
'id': 1,
'name': models[0].cohort.name,
'slug': models[0].cohort.slug,
'syllabus': {}
},
'created_at':
self.datetime_to_iso(models[0].user_specialty.created_at),
'expires_at':
models[0].user_specialty.expires_at,
'id':
1,
'layout':
None,
'preview_url':
models[0].user_specialty.preview_url,
'signed_by':
models[0].user_specialty.signed_by,
'signed_by_role':
'Director',
'specialty': {
'created_at':
self.datetime_to_iso(models[0].specialty.created_at),
'id': 1,
'logo_url': None,
'name': models[0].specialty.name,
'slug': models[0].specialty.slug,
'updated_at':
self.datetime_to_iso(models[0].specialty.updated_at),
},
'status':
'PENDING',
'status_text':
None,
'updated_at':
self.datetime_to_iso(models[0].user_specialty.updated_at),
'user': {
'first_name': models[0].user.first_name,
'id': 2,
'last_name': models[0].user.last_name
}
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class EventbriteWebhookTestSuite(EventTestCase):
"""Test /eventbrite/webhook"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(EVENTBRITE_PATH['get'], apply_eventbrite_requests_post_mock())
def test_eventbrite_webhook_without_data(self):
"""Test /eventbrite/webhook without auth"""
# self.generate_models(authenticate=True)
url = reverse_lazy('events:eventbrite_webhook_id', kwargs={'organization_id': 1})
response = self.client.post(url, {}, headers=self.headers(), format='json')
content = response.content
self.assertEqual(content, b'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [])
self.assertEqual(self.all_eventbrite_webhook_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(EVENTBRITE_PATH['get'], apply_eventbrite_requests_post_mock())
def test_eventbrite_webhook_without_organization(self):
"""Test /eventbrite/webhook without auth"""
# self.generate_models(authenticate=True)
url = reverse_lazy('events:eventbrite_webhook_id', kwargs={'organization_id': 1})
response = self.client.post(url, self.data('order.placed', EVENTBRITE_ORDER_URL),
headers=self.headers('order.placed'), format='json')
content = response.content
self.assertEqual(content, b'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [])
self.assertEqual(self.all_eventbrite_webhook_dict(), [{
'action': 'order.placed',
'api_url': 'https://www.eventbriteapi.com/v3/events/1/orders/1/',
'endpoint_url': 'https://something.io/eventbrite/webhook',
'id': 1,
'organization_id': '1',
'status': 'ERROR',
'status_text': 'Organization 1 doesn\'t exist',
'user_id': '123456789012',
'webhook_id': '1234567'
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(EVENTBRITE_PATH['get'], apply_eventbrite_requests_post_mock())
def test_eventbrite_webhook_without_event(self):
"""Test /eventbrite/webhook without auth"""
# self.generate_models(authenticate=True)
self.generate_models(organization=True)
url = reverse_lazy('events:eventbrite_webhook_id', kwargs={'organization_id': 1})
response = self.client.post(url, self.data('order.placed', EVENTBRITE_ORDER_URL),
headers=self.headers('order.placed'), format='json')
content = response.content
self.assertEqual(content, b'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [])
self.assertEqual(self.all_eventbrite_webhook_dict(), [{
'action': 'order.placed',
'api_url': 'https://www.eventbriteapi.com/v3/events/1/orders/1/',
'endpoint_url': 'https://something.io/eventbrite/webhook',
'id': 1,
'organization_id': '1',
'status': 'ERROR',
'status_text': 'event doesn\'t exist',
'user_id': '123456789012',
'webhook_id': '1234567'
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(EVENTBRITE_PATH['get'], apply_eventbrite_requests_post_mock())
def test_eventbrite_webhook_without_active_campaign_academy(self):
"""Test /eventbrite/webhook without auth"""
self.generate_models(organization=True, event=True, eventbrite_event_id=1, attendee=True)
url = reverse_lazy('events:eventbrite_webhook_id', kwargs={'organization_id': 1})
response = self.client.post(url, self.data('order.placed', EVENTBRITE_ORDER_URL),
headers=self.headers('order.placed'), format='json')
content = response.content
self.assertEqual(content, b'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_eventbrite_webhook_dict(), [{
'action': 'order.placed',
'api_url': 'https://www.eventbriteapi.com/v3/events/1/orders/1/',
'endpoint_url': 'https://something.io/eventbrite/webhook',
'id': 1,
'organization_id': '1',
'status': 'ERROR',
'status_text': 'ActiveCampaignAcademy doesn\'t exist',
'user_id': '123456789012',
'webhook_id': '1234567'
}])
self.assertEqual(self.all_event_checkin_dict(), [{
'attendee_id': 1,
'email': '*****@*****.**',
'event_id': 1,
'id': 1,
'status': 'PENDING'
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(EVENTBRITE_PATH['get'], apply_eventbrite_requests_post_mock())
@patch(OLD_BREATHECODE_PATH['request'], apply_old_breathecode_requests_request_mock())
def test_eventbrite_webhook_without_automation(self):
"""Test /eventbrite/webhook without auth"""
self.generate_models(organization=True, event=True, eventbrite_event_id=1, attendee=True,
active_campaign_academy=True, in_miami=True)
url = reverse_lazy('events:eventbrite_webhook_id', kwargs={'organization_id': 1})
response = self.client.post(url, self.data('order.placed', EVENTBRITE_ORDER_URL),
headers=self.headers('order.placed'), format='json')
content = response.content
self.assertEqual(content, b'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_eventbrite_webhook_dict(), [{
'action': 'order.placed',
'api_url': 'https://www.eventbriteapi.com/v3/events/1/orders/1/',
'endpoint_url': 'https://something.io/eventbrite/webhook',
'id': 1,
'organization_id': '1',
'status': 'ERROR',
'status_text': 'Automation for order_placed doesn\'t exist',
'user_id': '123456789012',
'webhook_id': '1234567'
}])
self.assertEqual(self.all_event_checkin_dict(), [{
'attendee_id': 1,
'email': '*****@*****.**',
'event_id': 1,
'id': 1,
'status': 'PENDING'
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(EVENTBRITE_PATH['get'], apply_eventbrite_requests_post_mock())
@patch(OLD_BREATHECODE_PATH['request'], apply_old_breathecode_requests_request_mock())
def test_eventbrite_webhook(self):
"""Test /eventbrite/webhook without auth"""
self.generate_models(organization=True, event=True, eventbrite_event_id=1, attendee=True,
active_campaign_academy=True, in_miami=True, automation=True, with_event_attendancy_automation=True)
url = reverse_lazy('events:eventbrite_webhook_id', kwargs={'organization_id': 1})
response = self.client.post(url, self.data('order.placed', EVENTBRITE_ORDER_URL),
headers=self.headers('order.placed'), format='json')
content = response.content
self.assertEqual(content, b'ok')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_eventbrite_webhook_dict(), [{
'action': 'order.placed',
'api_url': 'https://www.eventbriteapi.com/v3/events/1/orders/1/',
'endpoint_url': 'https://something.io/eventbrite/webhook',
'id': 1,
'organization_id': '1',
'status': 'DONE',
'status_text': None,
'user_id': '123456789012',
'webhook_id': '1234567'
}])
self.assertEqual(self.all_event_checkin_dict(), [{
'attendee_id': 1,
'email': '*****@*****.**',
'event_id': 1,
'id': 1,
'status': 'PENDING'
}])
class MediaTestSuite(MediaTestCase):
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_resolution_without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('media:info_id_resolution', kwargs={'media_id': 1})
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_resolution_wrong_academy(self):
"""Test /answer without auth"""
url = reverse_lazy('media:info_id_resolution', kwargs={'media_id': 1})
response = self.client.get(url, **{'HTTP_Academy': 1 })
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_resolution_without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('media:info_id_resolution', kwargs={'media_id': 1})
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': "You (user: 1) don't have this capability: read_media_resolution for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media_resolution', role='potato')
url = reverse_lazy('media:info_id_resolution', kwargs={'media_id': 1})
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'media-not-found',
'status_code': 404
})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_media_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_resolution_get_with_id(self):
"""Test /info/media:id/resolution"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, media_resolution=True, media=True,
capability='read_media_resolution', role='potato', profile_academy=True,
media_kwargs={'hash': 'abc'}, media_resolution_kwargs={'hash' : 'abc'})
model_dict = self.remove_dinamics_fields(model['media_resolution'].__dict__)
url = reverse_lazy('media:info_id_resolution', kwargs={'media_id': model['media'].id})
response = self.client.get(url)
json = response.json()
expected = [{
'id': model['media_resolution'].id,
'hash': model['media'].hash,
'width': model['media_resolution'].width,
'height': model['media_resolution'].height,
'hits': model['media_resolution'].hits,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_media_resolution(), 1)
self.assertEqual(self.get_media_resolution_dict(1), model_dict)
class CohortAllTestSuite(AdmissionsTestCase):
"""Test /cohort/all"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_without_auth(self):
"""Test /cohort/all without auth"""
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_without_data(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True)
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_cohort_but_without_profile_academy(self):
"""Test /cohort/all without auth"""
url = reverse_lazy('admissions:cohort_all')
self.generate_models(authenticate=True, cohort=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_bad_get_academy(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?academy=they-killed-kenny'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_academy(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?academy={self.academy.slug}'
response = self.client.get(url)
json = response.json()
expected = [{
'id': self.cohort.id,
'slug': self.cohort.slug,
'name': self.cohort.name,
'kickoff_date': re.sub(r'\+00:00$', 'Z', self.cohort.kickoff_date.isoformat()),
'ending_date': self.cohort.ending_date,
'stage': self.cohort.stage,
'language': self.cohort.language,
'certificate': {
'id': self.cohort.certificate.id,
'slug': self.cohort.certificate.slug,
'name': self.cohort.certificate.name,
'description': self.cohort.certificate.description,
'logo': self.cohort.certificate.logo,
},
'academy': {
'id': self.cohort.academy.id,
'slug': self.cohort.academy.slug,
'name': self.cohort.academy.name,
'country': {
'code': self.cohort.academy.country.code,
'name': self.cohort.academy.country.name,
},
'city': {
'name': self.cohort.academy.city.name,
},
'logo_url': self.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_bad_get_location(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?location=they-killed-kenny'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_location(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?location={self.academy.slug}'
response = self.client.get(url)
json = response.json()
expected = [{
'id': self.cohort.id,
'slug': self.cohort.slug,
'name': self.cohort.name,
'kickoff_date': re.sub(r'\+00:00$', 'Z', self.cohort.kickoff_date.isoformat()),
'ending_date': self.cohort.ending_date,
'stage': self.cohort.stage,
'language': self.cohort.language,
'certificate': {
'id': self.cohort.certificate.id,
'slug': self.cohort.certificate.slug,
'name': self.cohort.certificate.name,
'description': self.cohort.certificate.description,
'logo': self.cohort.certificate.logo,
},
'academy': {
'id': self.cohort.academy.id,
'slug': self.cohort.academy.slug,
'name': self.cohort.academy.name,
'country': {
'code': self.cohort.academy.country.code,
'name': self.cohort.academy.country.name,
},
'city': {
'name': self.cohort.academy.city.name,
},
'logo_url': self.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_location_with_comma(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?location={self.academy.slug},they-killed-kenny'
response = self.client.get(url)
json = response.json()
expected = [{
'id': self.cohort.id,
'slug': self.cohort.slug,
'name': self.cohort.name,
'kickoff_date': re.sub(r'\+00:00$', 'Z', self.cohort.kickoff_date.isoformat()),
'ending_date': self.cohort.ending_date,
'stage': self.cohort.stage,
'language': self.cohort.language,
'certificate': {
'id': self.cohort.certificate.id,
'slug': self.cohort.certificate.slug,
'name': self.cohort.certificate.name,
'description': self.cohort.certificate.description,
'logo': self.cohort.certificate.logo,
},
'academy': {
'id': self.cohort.academy.id,
'slug': self.cohort.academy.slug,
'name': self.cohort.academy.name,
'country': {
'code': self.cohort.academy.country.code,
'name': self.cohort.academy.country.name,
},
'city': {
'name': self.cohort.academy.city.name,
},
'logo_url': self.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_upcoming_false(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?upcoming=false'
response = self.client.get(url)
json = response.json()
expected = [{
'id': self.cohort.id,
'slug': self.cohort.slug,
'name': self.cohort.name,
'kickoff_date': re.sub(r'\+00:00$', 'Z', self.cohort.kickoff_date.isoformat()),
'ending_date': self.cohort.ending_date,
'stage': self.cohort.stage,
'language': self.cohort.language,
'certificate': {
'id': self.cohort.certificate.id,
'slug': self.cohort.certificate.slug,
'name': self.cohort.certificate.name,
'description': self.cohort.certificate.description,
'logo': self.cohort.certificate.logo,
},
'academy': {
'id': self.cohort.academy.id,
'slug': self.cohort.academy.slug,
'name': self.cohort.academy.name,
'country': {
'code': self.cohort.academy.country.code,
'name': self.cohort.academy.country.name,
},
'city': {
'name': self.cohort.academy.city.name,
},
'logo_url': self.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_upcoming_true_without_current_data(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?upcoming=true'
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data_with_get_upcoming_true_with_current_data(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True,
impossible_kickoff_date=True)
model_dict = self.get_cohort_dict(1)
base_url = reverse_lazy('admissions:cohort_all')
url = f'{base_url}?upcoming=true'
response = self.client.get(url)
json = response.json()
expected = [{
'id': self.cohort.id,
'slug': self.cohort.slug,
'name': self.cohort.name,
'kickoff_date': f'{self.cohort.kickoff_date.isoformat()}Z',
'ending_date': self.cohort.ending_date,
'stage': self.cohort.stage,
'language': self.cohort.language,
'certificate': {
'id': self.cohort.certificate.id,
'slug': self.cohort.certificate.slug,
'name': self.cohort.certificate.name,
'description': self.cohort.certificate.description,
'logo': self.cohort.certificate.logo,
},
'academy': {
'id': self.cohort.academy.id,
'slug': self.cohort.academy.slug,
'name': self.cohort.academy.name,
'country': {
'code': self.cohort.academy.country.code,
'name': self.cohort.academy.country.name,
},
'city': {
'name': self.cohort.academy.city.name,
},
'logo_url': self.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_all_with_data(self):
"""Test /cohort/all without auth"""
self.generate_models(authenticate=True, cohort=True, profile_academy=True)
model_dict = self.remove_dinamics_fields(self.cohort.__dict__)
url = reverse_lazy('admissions:cohort_all')
response = self.client.get(url)
json = response.json()
expected = [{
'id': self.cohort.id,
'slug': self.cohort.slug,
'name': self.cohort.name,
'kickoff_date': re.sub(r'\+00:00$', 'Z', self.cohort.kickoff_date.isoformat()),
'ending_date': self.cohort.ending_date,
'stage': self.cohort.stage,
'language': self.cohort.language,
'certificate': {
'id': self.cohort.certificate.id,
'slug': self.cohort.certificate.slug,
'name': self.cohort.certificate.name,
'description': self.cohort.certificate.description,
'logo': self.cohort.certificate.logo,
},
'academy': {
'id': self.cohort.academy.id,
'slug': self.cohort.academy.slug,
'name': self.cohort.academy.name,
'country': {
'code': self.cohort.academy.country.code,
'name': self.cohort.academy.country.name,
},
'city': {
'name': self.cohort.academy.city.name,
},
'logo_url': self.cohort.academy.logo_url,
},
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
class SendSurveyTestSuite(FeedbackTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(DJANGO_CONTRIB_PATH['messages'],
apply_django_contrib_messages_mock())
def test_send_bulk_cohort_user_survey__without_cohort(self):
"""Test /answer without auth"""
request = HttpRequest()
mock = DJANGO_CONTRIB_INSTANCES['messages']
mock.success.call_args_list = []
mock.error.call_args_list = []
self.assertEqual(
send_bulk_cohort_user_survey(None, request,
CohortUser.objects.all()), None)
self.assertEqual(
mock.success.call_args_list,
[call(request, message='Survey was '
'successfully sent')])
self.assertEqual(mock.error.call_args_list, [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
@patch(DJANGO_CONTRIB_PATH['messages'],
apply_django_contrib_messages_mock())
def test_send_bulk_cohort_user_survey_with_success_models(self):
"""Test /answer without auth"""
request = HttpRequest()
mock = DJANGO_CONTRIB_INSTANCES['messages']
mock.success.call_args_list = []
mock.error.call_args_list = []
models = [
self.generate_models(user=True, cohort_user=True, lang='en')
for _ in range(0, 3)
]
academies = [(models[key]['cohort'].academy.name, key + 1)
for key in range(0, 3)]
_cohorts = [(models[key]['cohort'].certificate.name, key + 1)
for key in range(0, 3)]
self.assertEqual(
send_bulk_cohort_user_survey(None, request,
CohortUser.objects.all()), None)
self.assertEqual(
mock.success.call_args_list,
[call(request, message='Survey was '
'successfully sent')])
self.assertEqual(mock.error.call_args_list, [])
expected = [{
'academy_id': None,
'cohort_id': key,
'comment': None,
'event_id': None,
'highest': 'very good',
'id': key,
'lang': 'en',
'lowest': 'not good',
'mentor_id': None,
'opened_at': None,
'score': None,
'status': 'SENT',
'survey_id': None,
'title': f'How has been your experience studying {c} so far?',
'token_id': key,
'user_id': key,
} for c, key in _cohorts]
dicts = [
answer for answer in self.all_answer_dict()
if isinstance(answer['created_at'], datetime)
and answer.pop('created_at')
]
self.assertEqual(dicts, expected)
class AuthenticateTestSuite(AuthTestCase):
"""Authentication test suite"""
def test_resend_invite_no_auth(self):
"""Test """
self.headers(academy=1)
url = reverse_lazy('authenticate:academy_resent_invite',
kwargs={"pa_id": 1})
response = self.client.put(url)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 401)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_resend_invite_no_capability(self):
"""Test """
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_cohort',
role='potato',
syllabus=True)
url = reverse_lazy('authenticate:academy_resent_invite',
kwargs={"pa_id": 1})
response = self.client.put(url)
json = response.json()
expected = {
'detail':
"You (user: 1) don't have this capability: crud_member for "
'academy 1',
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 403)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_resend_invite_with_capability(self):
"""Test """
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_member',
role='potato',
syllabus=True)
url = reverse_lazy('authenticate:academy_resent_invite',
kwargs={"pa_id": 1359})
response = self.client.put(url)
json = response.json()
expected = {'detail': 'Member not found', 'status_code': 400}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 400)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_resend_invite_no_invitation(self):
"""Test """
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_member',
role='potato',
syllabus=True)
url = reverse_lazy('authenticate:academy_resent_invite',
kwargs={"pa_id": 1})
response = self.client.put(url)
json = response.json()
expected = {'detail': 'Invite not found', 'status_code': 400}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 400)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_resend_invite_with_invitation(self):
"""Test """
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_member',
role='potato',
syllabus=True,
user_invite=True)
url = reverse_lazy('authenticate:academy_resent_invite',
kwargs={"pa_id": 1})
response = self.client.put(url)
json = response.json()
token = json['token']
created = json['created_at']
sent = json['sent_at']
del json['sent_at']
del json['created_at']
self.assertToken(json['token'])
del json['token']
expected = {
'status': 'PENDING',
'email': None,
'first_name': None,
'last_name': None
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
all_user_invite = [
x for x in self.all_user_invite_dict() if x.pop('sent_at')
]
self.assertEqual(all_user_invite, [{
'id': model['user_invite'].id,
'email': model['user_invite'].email,
'academy_id': model['user_invite'].academy_id,
'cohort_id': model['user_invite'].cohort_id,
'role_id': model['user_invite'].role_id,
'first_name': model['user_invite'].first_name,
'last_name': model['user_invite'].last_name,
'token': token,
'author_id': model['user_invite'].author_id,
'status': model['user_invite'].status,
'phone': model['user_invite'].phone,
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_resend_invite_recently(self):
"""Test """
self.headers(academy=1)
past_time = timezone.now() - timedelta(seconds=100)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_member',
role='potato',
syllabus=True,
user_invite=True,
token=True,
user_invite_kwargs={'sent_at': past_time})
url = reverse_lazy('authenticate:academy_resent_invite',
kwargs={"pa_id": 1})
response = self.client.put(url)
json = response.json()
expected = {
'detail': 'Imposible to resend invitation',
'status_code': 400
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 400)
self.assertEqual(
self.all_user_invite_dict(),
[{
**self.model_to_dict(model, 'user_invite'),
'sent_at': past_time,
}])
class CohortUserTestSuite(AdmissionsTestCase):
"""Test /cohort/user"""
"""
🔽🔽🔽 Auth
"""
def test_certificate_time_slot__without_auth(self):
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def test_certificate_time_slot__without_academy_header(self):
model = self.generate_models(authenticate=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail':
"Missing academy_id parameter expected for the endpoint url or 'Academy' header",
'status_code': 403,
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
def test_certificate_time_slot__without_capabilities(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail':
"You (user: 1) don't have this capability: read_certificate for academy 1",
'status_code': 403,
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
"""
🔽🔽🔽 Without data
"""
def test_certificate_time_slot__without_data(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_certificate',
role='potato')
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'time-slot-not-found',
'status_code': 404,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
"""
🔽🔽🔽 With data
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__with_data(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_certificate',
role='potato',
certificate_time_slot=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.get(url)
json = response.json()
expected = {
'id':
model.certificate_time_slot.id,
'academy':
model.certificate_time_slot.academy.id,
'certificate':
model.certificate_time_slot.certificate.id,
'starting_at':
self.datetime_to_iso(model.certificate_time_slot.starting_at),
'ending_at':
self.datetime_to_iso(model.certificate_time_slot.ending_at),
'recurrent':
model.certificate_time_slot.recurrent,
'recurrency_type':
model.certificate_time_slot.recurrency_type,
'created_at':
self.datetime_to_iso(model.certificate_time_slot.created_at),
'updated_at':
self.datetime_to_iso(model.certificate_time_slot.updated_at),
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_certificate_time_slot_dict(), [{
**self.model_to_dict(model, 'certificate_time_slot'),
}])
"""
🔽🔽🔽 Put
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__put__without_academy_certificate(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_certificate',
role='potato')
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
data = {}
response = self.client.put(url, data, format='json')
json = response.json()
expected = {
'detail': 'certificate-not-found',
'status_code': 404,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__put__without_time_slot(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_certificate',
role='potato',
academy_certificate=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
data = {}
response = self.client.put(url, data, format='json')
json = response.json()
expected = {
'detail': 'time-slot-not-found',
'status_code': 404,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__put__without_ending_at_and_starting_at(
self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_certificate',
role='potato',
certificate_time_slot=True,
academy_certificate=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
data = {}
response = self.client.put(url, data, format='json')
json = response.json()
expected = {
'ending_at': ['This field is required.'],
'starting_at': ['This field is required.'],
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.all_certificate_time_slot_dict(), [{
**self.model_to_dict(model, 'certificate_time_slot'),
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__put(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_certificate',
role='potato',
certificate_time_slot=True,
academy_certificate=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
starting_at = self.datetime_now()
ending_at = self.datetime_now()
data = {
'ending_at': self.datetime_to_iso(ending_at),
'starting_at': self.datetime_to_iso(starting_at),
}
response = self.client.put(url, data, format='json')
json = response.json()
expected = {
'academy': 1,
'certificate': 1,
'id': 1,
'recurrency_type': 'WEEKLY',
'recurrent': True,
**data,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_certificate_time_slot_dict(), [{
**self.model_to_dict(model, 'certificate_time_slot'),
'ending_at':
ending_at,
'starting_at':
starting_at,
}])
"""
🔽🔽🔽 Delete
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__delete__without_time_slot(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_certificate',
role='potato')
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.delete(url)
json = response.json()
expected = {
'detail': 'time-slot-not-found',
'status_code': 404,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_time_slot__delete(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_certificate',
role='potato',
certificate_time_slot=True)
url = reverse_lazy('admissions:academy_certificate_id_timeslot_id',
kwargs={
'certificate_id': 1,
'timeslot_id': 1
})
response = self.client.delete(url)
if response.status_code != 204:
print(response.json())
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.all_certificate_time_slot_dict(), [])
class MediaTestSuite(MediaTestCase):
"""Test /answer"""
"""
🔽🔽🔽 Auth
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__wrong_academy(self):
"""Test /answer without auth"""
url = reverse_lazy('media:root')
response = self.client.get(url, **{'HTTP_Academy': 1 })
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('media:root')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': "You (user: 1) don't have this capability: read_media for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
"""
🔽🔽🔽 Without data
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
models = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [])
"""
🔽🔽🔽 With data
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True)
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
"""
🔽🔽🔽 Academy in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_academy_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?academy=0'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_academy_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?academy=1'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_two_academy_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
del base['academy']
models = [self.generate_models(academy=True, media=True, category=True, models=base)
for _ in range(0, 2)]
url = (reverse_lazy('media:root') + '?academy=' +
str(models[0]['media'].academy.id) + ',' + str(models[1]['media'].academy.id))
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': model['category'].id,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
"""
🔽🔽🔽 Mime in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_mime_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?mime=application/hitman'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_mime_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?mime=' + model['media'].mime
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_two_mime_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
models = [self.generate_models(media=True, category=True, models=base)
for _ in range(0, 2)]
url = reverse_lazy('media:root') + '?mime=' + models[0]['media'].mime + ',' + models[1]['media'].mime
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': model['category'].id,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
"""
🔽🔽🔽 Name in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_name_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?name=hitman'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_name_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?name=' + model['media'].name
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_two_name_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
models = [self.generate_models(media=True, category=True, models=base)
for _ in range(0, 2)]
url = (reverse_lazy('media:root') + '?name=' + models[0]['media'].name +
',' + models[1]['media'].name)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': model['category'].id,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
"""
🔽🔽🔽 Slug in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_slug_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?slug=hitman'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_slug_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?slug=' + model['media'].slug
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_two_slug_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
models = [self.generate_models(media=True, category=True, models=base)
for _ in range(0, 2)]
url = (reverse_lazy('media:root') + '?slug=' + models[0]['media'].slug +
',' + models[1]['media'].slug)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': model['category'].id,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
"""
🔽🔽🔽 Id in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_id_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?id=0'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_id_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?id=' + str(model['media'].id)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_two_id_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
models = [self.generate_models(media=True, category=True, models=base)
for _ in range(0, 2)]
url = (reverse_lazy('media:root') + '?id=' + str(models[0]['media'].id) +
',' + str(models[1]['media'].id))
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': model['category'].id,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
"""
🔽🔽🔽 Categories in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_categories_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?categories=0'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_categories_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?categories=1'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_two_categories_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
base = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
models = [self.generate_models(media=True, category=True, models=base)
for _ in range(0, 2)]
url = (reverse_lazy('media:root') + '?categories=1,2')
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': model['category'].id,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
"""
🔽🔽🔽 Type in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_type_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?type=freyja'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_type_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
media_kwargs = {'mime': 'application/pdf'}
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True,
media_kwargs=media_kwargs)
url = reverse_lazy('media:root') + '?type=pdf'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
"""
🔽🔽🔽 Like in querystring
"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_bad_like_in_querystring(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:root') + '?like=freyja'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_like_in_querystring__like_match_name(self):
"""Test /answer without auth"""
self.headers(academy=1)
media_kwargs = {'name': 'Freyja'}
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True,
media_kwargs=media_kwargs)
url = reverse_lazy('media:root') + '?like=fre'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root__with_category__with_like_in_querystring__like_match_slug(self):
"""Test /answer without auth"""
self.headers(academy=1)
media_kwargs = {'slug': 'freyja'}
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True,
media_kwargs=media_kwargs)
url = reverse_lazy('media:root') + '?like=Fre'
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [{
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
}])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
"""
🔽🔽🔽 Pagination tests
"""
def test_root__pagination__with_105(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True, role=role,
capability='read_media', profile_academy=True)
models = [self.generate_models(media=True, models=base)
for _ in range(0, 105)]
url = reverse_lazy('media:root')
response = self.client.get(url)
json = response.json()
expected = [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models if model['media'].id < 101]
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
def test_root__pagination__first_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True, role=role,
capability='read_media', profile_academy=True)
models = [self.generate_models(media=True, models=base)
for _ in range(0, 10)]
url = reverse_lazy('media:root') + '?limit=5&offset=0'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': None,
'last': 'http://testserver/v1/media/?limit=5&offset=5',
'next': 'http://testserver/v1/media/?limit=5&offset=5',
'previous': None,
'results': [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models if model['media'].id < 6]
}
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
def test_root__pagination__last_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True, role=role,
capability='read_media', profile_academy=True)
models = [self.generate_models(media=True, models=base)
for _ in range(0, 10)]
url = reverse_lazy('media:root') + '?limit=5&offset=5'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/media/?limit=5',
'last': None,
'next': None,
'previous': 'http://testserver/v1/media/?limit=5',
'results': [{
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
} for model in models if model['media'].id > 5]
}
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
def test_root__pagination__after_last_five(self):
"""Test /academy/student"""
self.headers(academy=1)
role = 'student'
base = self.generate_models(authenticate=True, role=role,
capability='read_media', profile_academy=True)
models = [self.generate_models(media=True, models=base)
for _ in range(0, 10)]
url = reverse_lazy('media:root') + '?limit=5&offset=10'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/media/?limit=5',
'last': None,
'next': None,
'previous': 'http://testserver/v1/media/?limit=5&offset=5',
'results': []
}
self.assertEqual(json, expected)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
} for model in models])
class MediaTestSuite(MediaTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_without_auth(self):
"""Test /answer without auth"""
url = reverse_lazy('media:info_name', kwargs={'media_name': 'they-killed-kenny.exe'})
response = self.client.get(url)
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_wrong_academy(self):
"""Test /answer without auth"""
url = reverse_lazy('media:info_name', kwargs={'media_name': 'they-killed-kenny.exe'})
response = self.client.get(url, **{'HTTP_Academy': 1 })
json = response.json()
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('media:info_name', kwargs={'media_name': 'they-killed-kenny.exe'})
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': "You (user: 1) don't have this capability: read_media for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_without_data(self):
"""Test /answer without auth"""
self.headers(academy=1)
models = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato')
url = reverse_lazy('media:info_name', kwargs={'media_name': 'they-killed-kenny.exe'})
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'Media not found',
'status_code': 404
})
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_media_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_root(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True)
url = reverse_lazy('media:info_name', kwargs={'media_name': model['media'].name})
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'categories': [],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_info_id_with_category(self):
"""Test /answer without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_media', role='potato', media=True, category=True)
url = reverse_lazy('media:info_name', kwargs={'media_name': model['media'].name})
response = self.client.get(url)
json = response.json()
self.print_model(model, 'media')
self.print_model(model, 'category')
self.assertEqual(json, {
'categories': [{
'id': 1,
'medias': 1,
'name': model['category'].name,
'slug': model['category'].slug,
}],
'hash': model['media'].hash,
'hits': model['media'].hits,
'id': model['media'].id,
'mime': model['media'].mime,
'name': model['media'].name,
'slug': model['media'].slug,
'url': model['media'].url
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_media_dict(), [{
**self.model_to_dict(model, 'media')
}])
class CertificateTestSuite(AdmissionsTestCase):
"""Test /certificate"""
def test_certificate_slug_academy_id_syllabus_without_auth(self):
"""Test /certificate without auth"""
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': 'they-killed-kenny', 'academy_id': 1})
response = self.client.get(url)
json = response.json()
self.assertEqual(json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.all_certificate_dict(), [])
def test_certificate_slug_academy_id_syllabus_without_capability(self):
"""Test /certificate without auth"""
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': 'they-killed-kenny', 'academy_id': 1})
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
expected = {
'status_code': 403,
'detail': "You (user: 1) don't have this capability: read_syllabus for academy 1"
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_certificate_dict(), [])
def test_certificate_slug_academy_id_syllabus_without_data(self):
"""Test /certificate without auth"""
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': 'they-killed-kenny', 'academy_id': 1})
model = self.generate_models(authenticate=True, profile_academy=True,
capability='read_syllabus', role='potato')
response = self.client.get(url)
json = response.json()
expected = {
'status_code': 404,
'detail': 'Certificate slug not found'
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_certificate_dict(), [{
**self.model_to_dict(model, 'certificate'),
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_without_syllabus(self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True, certificate=True, profile_academy=True,
capability='read_syllabus', role='potato')
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': model['certificate'].slug, 'academy_id': 1})
response = self.client.get(url)
json = response.json()
self.assertEqual(json, [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_syllabus_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus(self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True, certificate=True, profile_academy=True,
capability='read_syllabus', role='potato', syllabus=True)
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': model['certificate'].slug, 'academy_id': 1})
response = self.client.get(url)
json = response.json()
expected = [{
'certificate': {
'id': model['certificate'].id,
'name': model['certificate'].name,
'slug': model['certificate'].slug,
'duration_in_days': model['cohort'].syllabus.certificate.duration_in_days,
},
'version': model['syllabus'].version,
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': model['syllabus'].json,
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_post_without_capabilities(self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True)
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': 'they-killed-kenny', 'academy_id': 1})
data = {}
response = self.client.post(url, data)
json = response.json()
expected = {
'detail': "You (user: 1) don't have this capability: crud_syllabus "
'for academy 1',
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_syllabus_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_post_with_bad_slug(self):
"""Test /certificate without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_syllabus', role='potato')
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': 'they-killed-kenny', 'academy_id': 1})
data = {}
response = self.client.post(url, data)
json = response.json()
expected = {
'detail': 'Invalid certificates slug they-killed-kenny',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_syllabus_dict(), [])
# @patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
# @patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
# @patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
# def test_certificate_slug_academy_id_syllabus__post__without_time_slot(self):
# """Test /certificate without auth"""
# self.headers(academy=1)
# model = self.generate_models(authenticate=True, profile_academy=True,
# capability='crud_syllabus', role='potato', certificate=True)
# url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
# 'certificate_slug': model['certificate'].slug, 'academy_id': 1})
# data = {}
# response = self.client.post(url, data)
# json = response.json()
# expected = {
# 'detail': 'certificate-not-have-time-slots',
# 'status_code': 400,
# }
# self.assertEqual(json, expected)
# self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
# self.assertEqual(self.all_syllabus_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_post_without_required_fields(self):
"""Test /certificate without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_syllabus', role='potato', certificate=True,
certificate_time_slot=True)
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': model['certificate'].slug, 'academy_id': 1})
data = {}
response = self.client.post(url, data)
json = response.json()
expected = {
'json': ['This field is required.']
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.all_syllabus_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_post(self):
"""Test /certificate without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_syllabus', role='potato', certificate=True,
certificate_time_slot=True)
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': model['certificate'].slug, 'academy_id': 1})
data = {
'certificate': model['certificate'].id,
'json': {'slug': 'they-killed-kenny'}
}
response = self.client.post(url, data, format='json')
json = response.json()
self.assertDatetime(json['created_at'])
self.assertDatetime(json['updated_at'])
del json['created_at']
del json['updated_at']
expected = {
'academy_owner': 1,
'certificate': 1,
'github_url': None,
'id': 1,
'json': data['json'],
'private': False,
'version': 1,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(self.all_syllabus_dict(), [{
'academy_owner_id': 1,
'certificate_id': 1,
'github_url': None,
'id': 1,
'json': {'slug': 'they-killed-kenny'},
'private': False,
'version': 1,
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus__post__with_cohort_and_syllabus(self):
"""Test /certificate without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True, profile_academy=True,
capability='crud_syllabus', role='potato', certificate=True,
certificate_time_slot=True, cohort=True, syllabus=True)
url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus', kwargs={
'certificate_slug': model['certificate'].slug, 'academy_id': 1})
data = {
'certificate': model['certificate'].id,
'json': {'slug': 'they-killed-kenny'}
}
response = self.client.post(url, data, format='json')
json = response.json()
self.assertDatetime(json['created_at'])
self.assertDatetime(json['updated_at'])
del json['created_at']
del json['updated_at']
expected = {
'academy_owner': 1,
'certificate': 1,
'github_url': None,
'id': 2,
'json': data['json'],
'private': False,
'version': model.syllabus.version + 1,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(self.all_syllabus_dict(), [{
**self.model_to_dict(model, 'syllabus')
} , {
'academy_owner_id': 1,
'certificate_id': 1,
'github_url': None,
'id': 2,
'json': {'slug': 'they-killed-kenny'},
'private': False,
'version': model.syllabus.version + 1,
}])
class AnswerIdTestSuite(FeedbackTestCase):
"""Test /answer/:id"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_without_auth(self):
"""Test /answer/:id without auth"""
url = reverse_lazy('feedback:answer_id', kwargs={'answer_id': 9999})
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.count_answer(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_without_data(self):
"""Test /answer/:id without auth"""
self.generate_models(authenticate=True)
url = reverse_lazy('feedback:answer_id', kwargs={'answer_id': 9999})
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'This survey does not exist for this user',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.count_answer(), 0)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_with_data_without_user(self):
"""Test /answer/:id without auth"""
model = self.generate_models(authenticate=True, answer=True)
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
response = self.client.get(url)
json = response.json()
expected = {
'detail': 'This survey does not exist for this user',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_with_data(self):
"""Test /answer/:id without auth"""
model = self.generate_models(authenticate=True,
answer=True,
user=True,
answer_status='SENT')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'id': model['answer'].id,
'title': model['answer'].title,
'lowest': model['answer'].lowest,
'highest': model['answer'].highest,
'lang': model['answer'].lang,
'score': model['answer'].score,
'comment': model['answer'].comment,
'status': model['answer'].status,
'opened_at': model['answer'].opened_at,
'created_at': datetime_to_iso_format(
model['answer'].created_at),
'updated_at': datetime_to_iso_format(
model['answer'].updated_at),
'cohort': model['answer'].cohort,
'survey': None,
'academy': model['answer'].academy,
'mentor': model['answer'].mentor,
'event': model['answer'].event,
'user': model['answer'].user.id,
})
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_put_with_bad_id(self):
"""Test /answer/:id without auth"""
self.generate_models(authenticate=True)
url = reverse_lazy('feedback:answer_id', kwargs={'answer_id': 9999})
response = self.client.put(url, {})
json = response.json()
expected = {
'detail': 'This survey does not exist for this user',
'status_code': 404,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_put_without_score(self):
"""Test /answer/:id without auth"""
model = self.generate_models(authenticate=True,
answer=True,
user=True,
answer_status='SENT')
db = self.model_to_dict(model, 'answer')
data = {
'comment': 'They killed kenny',
}
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
response = self.client.put(url, data)
json = response.json()
self.assertEqual(
json, {'non_field_errors': ['Score must be between 1 and 10']})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_put_with_score_less_of_1(self):
"""Test /answer/:id without auth"""
model = self.generate_models(authenticate=True,
answer=True,
user=True,
answer_status='SENT')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
data = {
'comment': 'They killed kenny',
'score': 0,
}
response = self.client.put(url, data)
json = response.json()
self.assertEqual(
json, {'non_field_errors': ['Score must be between 1 and 10']})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_put_with_score_more_of_10(self):
"""Test /answer/:id without auth"""
model = self.generate_models(authenticate=True,
answer=True,
user=True,
answer_status='SENT')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
data = {
'comment': 'They killed kenny',
'score': 11,
}
response = self.client.put(url, data)
json = response.json()
self.assertEqual(
json, {'non_field_errors': ['Score must be between 1 and 10']})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.all_answer_dict(), [db])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_put_with_all_valid_scores(self):
"""Test /answer/:id without auth"""
for number in range(1, 10):
self.remove_all_answer()
model = self.generate_models(authenticate=True,
answer=True,
user=True,
answer_status='SENT')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
score = str(number)
data = {
'comment': 'They killed kenny',
'score': score,
}
response = self.client.put(url, data)
json = response.json()
expected = {
'id': model['answer'].id,
'title': model['answer'].title,
'lowest': model['answer'].lowest,
'highest': model['answer'].highest,
'lang': model['answer'].lang,
'score': score,
'comment': data['comment'],
'status': 'ANSWERED',
'opened_at': model['answer'].opened_at,
'created_at':
datetime_to_iso_format(model['answer'].created_at),
'cohort': model['answer'].cohort,
'academy': model['answer'].academy,
'survey': None,
'mentor': model['answer'].mentor,
'event': model['answer'].event,
'user': model['answer'].user.id,
}
del json['updated_at']
self.assertEqual(json, expected)
dicts = [
answer for answer in self.all_answer_dict()
if not 'updated_at' in answer
or isinstance(answer['updated_at'], datetime)
and answer.pop('updated_at')
]
self.assertEqual(response.status_code, status.HTTP_200_OK)
db['score'] = score
db['status'] = 'ANSWERED'
db['comment'] = data['comment']
self.assertEqual(dicts, [db])
# TODO: this test should return 400 but its returning 200, why? If needs to return 400 because you cannot change your score in the answer once you already answered
# @patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
# @patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
# @patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
# def test_answer_id_put_twice_different_score(self):
# """Test /answer/:id without auth"""
# model = self.generate_models(manual_authenticate=True, answer=True, user=True,answer_score=7,
# answer_status='SENT')
# db = self.model_to_dict(model, 'answer')
# url = reverse_lazy('feedback:answer_id', kwargs={'answer_id': model['answer'].id})
# data = {
# 'comment': 'They killed kenny',
# 'score': 1,
# }
# self.client.put(url, data)
# self.auth_with_token(model['user'])
# response = self.client.put(url, data)
# json = response.json()
# # assert False
# self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_answer_id_put_twice_same_score(self):
"""Test /answer/:id without auth"""
model = self.generate_models(manual_authenticate=True,
answer=True,
user=True,
answer_score=3,
answer_status='SENT')
db = self.model_to_dict(model, 'answer')
url = reverse_lazy('feedback:answer_id',
kwargs={'answer_id': model['answer'].id})
data = {
'comment': 'They killed kenny',
'score': '3',
}
self.client.put(url, data)
self.auth_with_token(model['user'])
response = self.client.put(url, data)
json = response.json()
# assert False
self.assertEqual(response.status_code, status.HTTP_200_OK)
db['score'] = data['score']
db['status'] = 'ANSWERED'
db['comment'] = data['comment']
self.assertEqual(self.all_answer_dict(), [db])
class CertificateTestSuite(AdmissionsTestCase):
"""Test /certificate"""
def test_certificate_slug_academy_id_syllabus_version_without_auth(self):
"""Test /certificate without auth"""
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': '1'
})
response = self.client.get(url)
json = response.json()
self.assertEqual(
json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.all_certificate_dict(), [])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
def test_certificate_slug_academy_id_syllabus_version_without_capability(
self):
"""Test /certificate without auth"""
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': '1'
})
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
expected = {
'status_code':
403,
'detail':
'You (user: 1) don\'t have this capability: read_syllabus '
'for academy 1'
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_certificate_dict(), [])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
def test_certificate_slug_academy_id_syllabus_version_without_data(self):
"""Test /certificate without auth"""
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': '1'
})
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_syllabus',
role='potato')
response = self.client.get(url)
json = response.json()
expected = {'status_code': 404, 'detail': 'Certificate slug not found'}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_certificate_dict(), [{
**self.model_to_dict(model, 'certificate'),
}])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_without_syllabus(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
certificate=True,
profile_academy=True,
capability='read_syllabus',
role='potato')
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': model['certificate'].slug,
'academy_id': 1,
'version': '1'
})
response = self.client.get(url)
json = response.json()
expected = {'detail': 'Syllabus not found', 'status_code': 404}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_syllabus_dict(), [])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_with_bad_version(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
certificate=True,
profile_academy=True,
capability='read_syllabus',
role='potato',
syllabus=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': model['certificate'].slug,
'academy_id': 1,
'version': '1'
})
response = self.client.get(url)
json = response.json()
expected = {'detail': 'Syllabus not found', 'status_code': 404}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(
self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': model['syllabus'].json,
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version(self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
certificate=True,
profile_academy=True,
capability='read_syllabus',
role='potato',
syllabus=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': model['certificate'].slug,
'academy_id': 1,
'version': model['syllabus'].version
})
response = self.client.get(url)
json = response.json()
expected = {
'certificate': model['certificate'].slug,
'json': model['syllabus'].json,
'updated_at': datetime_to_iso_format(model['syllabus'].updated_at),
'version': model['syllabus'].version,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': model['syllabus'].json,
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put_without_auth(
self):
"""Test /certificate without auth"""
model = self.generate_models()
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': 1
})
data = {}
response = self.client.put(url, data)
json = response.json()
expected = {
'detail': 'Authentication credentials were not provided.',
'status_code': 401
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
self.assertEqual(self.all_syllabus_dict(), [])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put_without_capability(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': 1
})
data = {}
response = self.client.put(url, data)
json = response.json()
expected = {
'detail':
"You (user: 1) don't have this capability: crud_syllabus "
"for academy 1",
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.all_syllabus_dict(), [])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put_without_syllabus(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_syllabus',
role='potato')
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': 1
})
data = {}
response = self.client.put(url, data)
json = response.json()
expected = {
'detail': 'Syllabus version not found for this academy',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(self.all_syllabus_dict(), [])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put_without_bad_version(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_syllabus',
role='potato',
syllabus=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': 1
})
data = {}
response = self.client.put(url, data)
json = response.json()
expected = {
'detail': 'Syllabus version not found for this academy',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(
self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': model['syllabus'].json,
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put_without_bad_slug(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_syllabus',
role='potato',
syllabus=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': 'they-killed-kenny',
'academy_id': 1,
'version': model['syllabus'].version
})
data = {}
response = self.client.put(url, data)
json = response.json()
expected = {
'detail': 'Syllabus version not found for this academy',
'status_code': 404
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(
self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': model['syllabus'].json,
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
self.assertEqual(self.all_cohort_time_slot_dict(), [])
# @patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
# @patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
# @patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
# def test_certificate_slug_academy_id_syllabus_version__put__without_time_slot(self):
# """Test /certificate without auth"""
# model = self.generate_models(authenticate=True, profile_academy=True,
# capability='crud_syllabus', role='potato', syllabus=True,
# certificate=True)
# url = reverse_lazy('admissions:certificate_slug_academy_id_syllabus_version',
# kwargs={'certificate_slug': model['certificate'].slug, 'academy_id': 1,
# 'version': model['syllabus'].version})
# data = {}
# response = self.client.put(url, data)
# json = response.json()
# expected = {
# 'detail': 'certificate-not-have-time-slots',
# 'status_code': 400,
# }
# self.assertEqual(json, expected)
# self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
# self.assertEqual(self.all_syllabus_dict(), [{
# 'academy_owner_id': model['syllabus'].academy_owner_id,
# 'certificate_id': model['syllabus'].certificate_id,
# 'github_url': model['syllabus'].github_url,
# 'id': model['syllabus'].id,
# 'json': model['syllabus'].json,
# 'private': model['syllabus'].private,
# 'version': model['syllabus'].version
# }])
# self.assertEqual(self.all_cohort_time_slot_dict(), [])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put_without_json_field(
self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_syllabus',
role='potato',
syllabus=True,
certificate=True,
certificate_time_slot=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': model['certificate'].slug,
'academy_id': 1,
'version': model['syllabus'].version
})
data = {}
response = self.client.put(url, data)
json = response.json()
expected = {'json': ['This field is required.']}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': model['syllabus'].json,
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_certificate_slug_academy_id_syllabus_version_put(self):
"""Test /certificate without auth"""
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_syllabus',
role='potato',
syllabus=True,
certificate=True,
certificate_time_slot=True)
url = reverse_lazy(
'admissions:certificate_slug_academy_id_syllabus_version',
kwargs={
'certificate_slug': model['certificate'].slug,
'academy_id': 1,
'version': model['syllabus'].version
})
data = {'json': {'ova': 'thus spoke kishibe rohan'}}
response = self.client.put(url, data, format='json')
json = response.json()
self.assertDatetime(json['created_at'])
self.assertDatetime(json['updated_at'])
del json['updated_at']
expected = {
'academy_owner': model['syllabus'].academy_owner_id,
'certificate': model['syllabus'].certificate_id,
'created_at': self.datetime_to_iso(model['syllabus'].created_at),
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': data['json'],
'private': model['syllabus'].private,
'version': model['syllabus'].version
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
self.all_syllabus_dict(), [{
'academy_owner_id': model['syllabus'].academy_owner_id,
'certificate_id': model['syllabus'].certificate_id,
'github_url': model['syllabus'].github_url,
'id': model['syllabus'].id,
'json': data['json'],
'private': model['syllabus'].private,
'version': model['syllabus'].version
}])
class SendSurveyTestSuite(FeedbackTestCase):
"""Test /answer"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_cohort_bulk_survey_without_cohort(self):
"""Test /answer without auth"""
request = HttpRequest()
self.assertEqual(send_cohort_bulk_survey(None, request, Cohort.objects.all()), None)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_cohort_bulk_survey_with_educational_status_active(self):
"""Test /answer without auth"""
request = HttpRequest()
models = [self.generate_models(user=True, cohort_user=True, profile_academy=True,
cohort_user_role='STUDENT', educational_status='ACTIVE', lang='en') for _ in range(0, 3)]
academies = [(models[key]['cohort'].academy.name, key + 1) for key in range(0, 3)]
_cohorts = [(models[key]['cohort'].certificate.name, key + 1) for key in range(0, 3)]
self.assertEqual(send_cohort_bulk_survey(None, request, Cohort.objects.all()), None)
expected = [{
'academy_id': None,
'cohort_id': key,
'comment': None,
'event_id': None,
'highest': 'very good',
'id': key,
'lang': 'en',
'lowest': 'not good',
'mentor_id': None,
'opened_at': None,
'score': None,
'status': 'SENT',
'survey_id': None,
'title': f'How has been your experience studying {c} so far?',
'token_id': key,
'user_id': key,
} for c, key in _cohorts]
dicts = [answer for answer in self.all_answer_dict() if isinstance(answer['created_at'],
datetime) and answer.pop('created_at')]
self.assertEqual(dicts, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_cohort_bulk_survey_with_educational_status_graduated(self):
"""Test /answer without auth"""
request = HttpRequest()
models = [self.generate_models(user=True, cohort_user=True, profile_academy=True,
cohort_user_role='STUDENT', educational_status='GRADUATED', lang='en') for _ in range(0, 3)]
academies = [(models[key]['cohort'].academy.name, key + 1) for key in range(0, 3)]
cohorts = Cohort.objects.all()
self.assertEqual(send_cohort_bulk_survey(None, request, cohorts), None)
_cohorts = [(models[key]['cohort'].certificate.name, key + 1) for key in range(0, 3)]
expected = [{
'academy_id': None,
'cohort_id': key,
'comment': None,
'event_id': None,
'highest': 'very good',
'id': key,
'lang': 'en',
'lowest': 'not good',
'mentor_id': None,
'opened_at': None,
'score': None,
'survey_id': None,
'status': 'SENT',
'title': f'How has been your experience studying {cohort} so far?',
'token_id': key,
'user_id': key,
} for cohort, key in _cohorts]
dicts = [answer for answer in self.all_answer_dict() if isinstance(answer['created_at'],
datetime) and answer.pop('created_at')]
self.assertEqual(dicts, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_cohort_bulk_survey_with_educational_status_postponed(self):
"""Test /answer without auth"""
request = HttpRequest()
models = [self.generate_models(user=True, cohort_user=True, profile_academy=True,
cohort_user_role='STUDENT', educational_status='POSTPONED', lang='en') for _ in range(0, 3)]
academies = [(models[key]['cohort'].academy.name, key + 1) for key in range(0, 3)]
self.assertEqual(send_cohort_bulk_survey(None, request, Cohort.objects.all()), None)
expected = []
dicts = [answer for answer in self.all_answer_dict() if isinstance(answer['created_at'],
datetime) and answer.pop('created_at')]
self.assertEqual(dicts, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_cohort_bulk_survey_with_educational_status_suspended(self):
"""Test /answer without auth"""
request = HttpRequest()
models = [self.generate_models(user=True, cohort_user=True, profile_academy=True,
cohort_user_role='STUDENT', educational_status='SUSPENDED', lang='en') for _ in range(0, 3)]
academies = [(models[key]['cohort'].academy.name, key + 1) for key in range(0, 3)]
self.assertEqual(send_cohort_bulk_survey(None, request, Cohort.objects.all()), None)
expected = []
dicts = [answer for answer in self.all_answer_dict() if isinstance(answer['created_at'],
datetime) and answer.pop('created_at')]
self.assertEqual(dicts, expected)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_send_cohort_bulk_survey_with_educational_status_dropped(self):
"""Test /answer without auth"""
request = HttpRequest()
models = [self.generate_models(user=True, cohort_user=True, profile_academy=True,
cohort_user_role='STUDENT', educational_status='DROPPED', lang='en') for _ in range(0, 3)]
academies = [(models[key]['cohort'].academy.name, key + 1) for key in range(0, 3)]
self.assertEqual(send_cohort_bulk_survey(None, request, Cohort.objects.all()), None)
expected = []
dicts = [answer for answer in self.all_answer_dict() if isinstance(answer['created_at'],
datetime) and answer.pop('created_at')]
self.assertEqual(dicts, expected)
class AcademyCohortTestSuite(AdmissionsTestCase):
"""Test /cohort"""
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_without_auth(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': 1})
response = self.client.put(url, {})
json = response.json()
self.assertEqual(
json, {
'detail': 'Authentication credentials were not provided.',
'status_code': status.HTTP_401_UNAUTHORIZED
})
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_put_without_capability(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': 1})
self.generate_models(authenticate=True)
data = {}
response = self.client.put(url, data)
json = response.json()
self.assertEqual(
json, {
'detail':
"You (user: 1) don't have this capability: crud_cohort for academy 1",
'status_code': 403
})
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_put_with_id_without_certificate(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
capability='crud_cohort',
role='potato')
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': model['cohort'].id})
data = {}
response = self.client.put(url, data)
json = response.json()
self.assertEqual(json, {'certificate': ['This field is required.']})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_put_without_cohort(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': 99999})
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_cohort',
role='potato',
certificate=True)
data = {'certificate': model['certificate'].id}
response = self.client.put(url, data)
json = response.json()
self.assertEqual(json, {
'status_code': 400,
'detail': 'Specified cohort not be found'
})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1),
self.remove_dinamics_fields(model['cohort'].__dict__))
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_put(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': 1})
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_cohort',
role='potato',
certificate=True)
data = {'certificate': model['certificate'].id}
response = self.client.put(url, data)
json = response.json()
expected = {
'id':
model['cohort'].id,
'slug':
model['cohort'].slug,
'name':
model['cohort'].name,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model['cohort'].kickoff_date.isoformat()),
'ending_date':
model['cohort'].ending_date,
'current_day':
model['cohort'].current_day,
'stage':
model['cohort'].stage,
'language':
model['cohort'].language,
'certificate':
model['cohort'].certificate.id,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1),
self.remove_dinamics_fields(model['cohort'].__dict__))
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_put_with_id_with_data_in_body(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
capability='crud_cohort',
role='potato',
certificate=True)
model_dict = self.get_cohort_dict(1)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': model['cohort'].id})
data = {
'certificate': model['certificate'].id,
'slug': 'they-killed-kenny',
'name': 'They killed kenny',
'current_day': model['cohort'].current_day + 1,
'language': 'es',
}
model_dict.update(data)
model_dict['certificate_id'] = model_dict['certificate']
del model_dict['certificate']
response = self.client.put(url, data)
json = response.json()
expected = {
'id':
model['cohort'].id,
'slug':
data['slug'],
'name':
data['name'],
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model['cohort'].kickoff_date.isoformat()),
'ending_date':
model['cohort'].ending_date,
'current_day':
data['current_day'],
'stage':
model['cohort'].stage,
'language':
data['language'],
'certificate':
model['cohort'].certificate.id,
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_get_with_id(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
capability='read_cohort',
role='potato',
certificate=True)
model_dict = self.remove_dinamics_fields(model['cohort'].__dict__)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': model['cohort'].id})
response = self.client.get(url)
json = response.json()
expected = {
'id':
model['cohort'].id,
'slug':
model['cohort'].slug,
'name':
model['cohort'].name,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model['cohort'].kickoff_date.isoformat()),
'ending_date':
model['cohort'].ending_date,
'stage':
model['cohort'].stage,
'language':
model['cohort'].language,
'certificate': {
'id': model['cohort'].certificate.id,
'slug': model['cohort'].certificate.slug,
'name': model['cohort'].certificate.name,
'description': model['cohort'].certificate.description,
'logo': model['cohort'].certificate.logo,
},
'academy': {
'id': model['cohort'].academy.id,
'slug': model['cohort'].academy.slug,
'name': model['cohort'].academy.name,
'country': {
'code': model['cohort'].academy.country.code,
'name': model['cohort'].academy.country.name,
},
'city': {
'name': model['cohort'].academy.city.name,
},
'logo_url': model['cohort'].academy.logo_url,
},
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_get_with_bad_slug(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
capability='read_cohort',
role='potato',
certificate=True)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': 'they-killed-kenny'})
response = self.client.get(url)
self.assertEqual(response.data, None)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_get_with_slug(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
profile_academy=True,
capability='read_cohort',
role='potato',
certificate=True)
model_dict = self.remove_dinamics_fields(model['cohort'].__dict__)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': model['cohort'].slug})
response = self.client.get(url)
json = response.json()
expected = {
'id':
model['cohort'].id,
'slug':
model['cohort'].slug,
'name':
model['cohort'].name,
'kickoff_date':
re.sub(r'\+00:00$', 'Z', model['cohort'].kickoff_date.isoformat()),
'ending_date':
model['cohort'].ending_date,
'language':
model['cohort'].language,
'stage':
model['cohort'].stage,
'certificate': {
'id': model['cohort'].certificate.id,
'slug': model['cohort'].certificate.slug,
'name': model['cohort'].certificate.name,
'description': model['cohort'].certificate.description,
'logo': model['cohort'].certificate.logo,
},
'academy': {
'id': model['cohort'].academy.id,
'slug': model['cohort'].academy.slug,
'name': model['cohort'].academy.name,
'country': model['cohort'].academy.country,
'city': model['cohort'].academy.city,
'logo_url': model['cohort'].academy.logo_url,
'country': {
'code': model['cohort'].academy.country.code,
'name': model['cohort'].academy.country.name,
},
'city': {
'name': model['cohort'].academy.city.name,
},
},
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.count_cohort(), 1)
self.assertEqual(self.get_cohort_dict(1), model_dict)
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_delete_with_bad_id(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
user=True,
profile_academy=True,
capability='read_cohort',
role='potato',
certificate=True,
cohort_user=True)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': 0})
self.assertEqual(self.count_cohort_user(), 1)
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(self.count_cohort_user(), 1)
self.assertEqual(self.count_cohort_stage(model['cohort'].id),
'INACTIVE')
@patch(GOOGLE_CLOUD_PATH['client'], apply_google_cloud_client_mock())
@patch(GOOGLE_CLOUD_PATH['bucket'], apply_google_cloud_bucket_mock())
@patch(GOOGLE_CLOUD_PATH['blob'], apply_google_cloud_blob_mock())
def test_cohort_id_delete_with_id(self):
"""Test /cohort/:id without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
cohort=True,
user=True,
profile_academy=True,
capability='crud_cohort',
role='potato',
certificate=True,
cohort_user=True)
url = reverse_lazy('admissions:academy_cohort_id',
kwargs={'cohort_id': model['cohort'].id})
self.assertEqual(self.count_cohort_user(), 1)
self.assertEqual(self.count_cohort_stage(model['cohort'].id),
'INACTIVE')
response = self.client.delete(url)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.count_cohort_user(), 0)
self.assertEqual(self.count_cohort_stage(model['cohort'].id),
'DELETED')
