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 AcademyEventView(APIView, HeaderLimitOffsetPagination):
"""
List all snippets, or create a new snippet.
"""
cache = EventCache()
@capable_of('read_event')
def get(self, request, format=None, academy_id=None, event_id=None):
city = self.request.GET.get('city')
country = self.request.GET.get('country')
zip_code = self.request.GET.get('zip_code')
upcoming = self.request.GET.get('upcoming')
past = self.request.GET.get('past')
cache_kwargs = {
'academy_id': academy_id,
'event_id': event_id,
'city': city,
'country': country,
'zip_code': zip_code,
'upcoming': upcoming,
'past': past,
**self.pagination_params(request),
}
cache = self.cache.get(**cache_kwargs)
if cache:
return Response(cache, status=status.HTTP_200_OK)
if event_id is not None:
single_event = Event.objects.filter(
id=event_id, academy__id=academy_id).first()
if single_event is None:
raise ValidationException("Event not found", 404)
serializer = EventSmallSerializer(single_event, many=False)
self.cache.set(serializer.data, **cache_kwargs)
return Response(serializer.data)
items = Event.objects.filter(academy__id=academy_id)
lookup = {}
if city:
lookup['venue__city__iexact'] = city
if country:
lookup['venue__country__iexact'] = country
if zip_code:
lookup['venue__zip_code'] = zip_code
if upcoming:
lookup['starting_at__gte'] = timezone.now()
elif past:
if 'starting_at__gte' in lookup:
lookup.pop("starting_at__gte")
if past == "true":
lookup['starting_at__lte'] = timezone.now()
items = items.filter(**lookup).order_by('-starting_at')
page = self.paginate_queryset(items, request)
serializer = EventSmallSerializerNoAcademy(page, many=True)
if self.is_paginate(request):
return self.get_paginated_response(serializer.data,
cache=self.cache,
cache_kwargs=cache_kwargs)
else:
self.cache.set(serializer.data, **cache_kwargs)
return Response(serializer.data, status=200)
@capable_of('crud_event')
def post(self, request, format=None, academy_id=None):
academy = Academy.objects.filter(id=academy_id).first()
if academy is None:
raise ValidationException(f"Academy {academy_id} not found")
data = {}
for key in request.data.keys():
data[key] = request.data.get(key)
serializer = EventSerializer(data={**data, "academy": academy.id})
if serializer.is_valid():
self.cache.clear()
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@capable_of('crud_event')
def put(self, request, academy_id=None, event_id=None):
already = Event.objects.filter(id=event_id,
academy__id=academy_id).first()
if already is None:
raise ValidationException(
f"Event not found for this academy {academy_id}")
serializer = EventSerializer(already, data=request.data)
if serializer.is_valid():
self.cache.clear()
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class AcademyEventTestSuite(EventTestCase):
cache = EventCache()
def test_academy_checkin_no_auth(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_checkin')
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_academy_checkin_without_capability(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_checkin')
self.generate_models(authenticate=True)
response = self.client.get(url)
json = response.json()
expected = {
'detail':
"You (user: 1) don't have this capability: read_eventcheckin for academy 1",
'status_code': 403
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 403)
def test_academy_checkin_without_data(self):
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
url = reverse_lazy('events:academy_checkin')
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
def test_academy_checkin_with_bad_academy(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
model = self.generate_models(event_checkin=True,
event_kwargs=event_kwargs,
models=base)
url = reverse_lazy('events:academy_checkin')
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin__(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base,
event_checkin_kwargs=event_checkin_kwargs)
url = reverse_lazy('events:academy_checkin')
response = self.client.get(url)
json = response.json()
expected = [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_bad_status(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base)
url = reverse_lazy('events:academy_checkin') + '?status=DONE'
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_status(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base,
event_checkin_kwargs=event_checkin_kwargs)
url = reverse_lazy('events:academy_checkin') + '?status=PENDING'
response = self.client.get(url)
json = response.json()
expected = [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_bad_event(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base)
url = reverse_lazy('events:academy_checkin') + '?event=2'
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_event(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base,
event_checkin_kwargs=event_checkin_kwargs)
url = reverse_lazy('events:academy_checkin') + '?event=1'
response = self.client.get(url)
json = response.json()
expected = [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_bad_start(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base)
url = reverse_lazy('events:academy_checkin') + '?start=3000-01-01'
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_start(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base,
event_checkin_kwargs=event_checkin_kwargs)
date = model['event_checkin'].created_at
url = (reverse_lazy('events:academy_checkin') +
f'?start={date.year}-{date.month}-{date.day}')
response = self.client.get(url)
json = response.json()
expected = [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_bad_end(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base)
url = reverse_lazy('events:academy_checkin') + '?end=1000-01-01'
response = self.client.get(url)
json = response.json()
expected = []
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_with_end(self):
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
model = self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base,
event_checkin_kwargs=event_checkin_kwargs)
date = model['event_checkin'].updated_at
url = (reverse_lazy('events:academy_checkin') +
f'?end={date.year + 1}-{date.month}-{date.day}')
response = self.client.get(url)
json = response.json()
expected = [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
}]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 200)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
}])
def test_academy_checkin_pagination_with_105(self):
"""Test /academy/member"""
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
models = [
self.generate_models(event=True,
event_checkin=True,
event_checkin_kwargs=event_checkin_kwargs,
event_kwargs=event_kwargs,
models=base) for _ in range(0, 105)
]
ordened_models = sorted(models,
key=lambda x: x['event_checkin'].created_at,
reverse=True)
url = reverse_lazy('events:academy_checkin')
response = self.client.get(url)
json = response.json()
expected = [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
} for model in ordened_models][:100]
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
} for model in models])
def test_academy_checkin_pagination_first_five(self):
"""Test /academy/member"""
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
models = [
self.generate_models(event=True,
event_checkin=True,
event_checkin_kwargs=event_checkin_kwargs,
event_kwargs=event_kwargs,
models=base) for _ in range(0, 10)
]
ordened_models = sorted(models,
key=lambda x: x['event_checkin'].created_at,
reverse=True)
url = reverse_lazy('events:academy_checkin') + '?limit=5&offset=0'
response = self.client.get(url)
json = response.json()
expected = {
'count':
10,
'first':
None,
'last':
'http://testserver/v1/events/academy/checkin?limit=5&offset=5',
'next':
'http://testserver/v1/events/academy/checkin?limit=5&offset=5',
'previous':
None,
'results': [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(
model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(
model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
} for model in ordened_models][:5]
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
} for model in models])
def test_academy_checkin_pagination_last_five(self):
"""Test /academy/member"""
self.headers(academy=1)
role = 'hitman'
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
event_checkin_kwargs = {'attended_at': self.datetime_now()}
models = [
self.generate_models(event=True,
event_checkin=True,
event_checkin_kwargs=event_checkin_kwargs,
event_kwargs=event_kwargs,
models=base) for _ in range(0, 10)
]
ordened_models = sorted(models,
key=lambda x: x['event_checkin'].created_at,
reverse=True)
url = reverse_lazy('events:academy_checkin') + '?limit=5&offset=5'
response = self.client.get(url)
json = response.json()
expected = {
'count':
10,
'first':
'http://testserver/v1/events/academy/checkin?limit=5',
'last':
None,
'next':
None,
'previous':
'http://testserver/v1/events/academy/checkin?limit=5',
'results': [{
'attendee': {
'first_name': model['event_checkin'].attendee.first_name,
'id': model['event_checkin'].attendee.id,
'last_name': model['event_checkin'].attendee.last_name
},
'email':
model['event_checkin'].email,
'event': {
'ending_at':
self.datetime_to_iso(
model['event_checkin'].event.ending_at),
'event_type':
model['event_checkin'].event.event_type,
'id':
model['event_checkin'].event.id,
'starting_at':
self.datetime_to_iso(
model['event_checkin'].event.starting_at),
'title':
model['event_checkin'].event.title
},
'id':
model['event_checkin'].id,
'status':
model['event_checkin'].status,
'created_at':
self.datetime_to_iso(model['event_checkin'].created_at),
'attended_at':
self.datetime_to_iso(model['event_checkin'].attended_at)
} for model in ordened_models][5:]
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
} for model in models])
def test_academy_checkin_pagination_after_last_five(self):
"""Test /academy/member"""
self.headers(academy=1)
base = self.generate_models(authenticate=True,
profile_academy=True,
capability='read_eventcheckin',
role='potato')
event_kwargs = {'academy': base['academy']}
models = [
self.generate_models(event=True,
event_checkin=True,
event_kwargs=event_kwargs,
models=base) for _ in range(0, 10)
]
url = reverse_lazy('events:academy_checkin') + '?limit=5&offset=10'
response = self.client.get(url)
json = response.json()
expected = {
'count': 10,
'first': 'http://testserver/v1/events/academy/checkin?limit=5',
'last': None,
'next': None,
'previous':
'http://testserver/v1/events/academy/checkin?limit=5&offset=5',
'results': []
}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.all_event_checkin_dict(), [{
**self.model_to_dict(model, 'event_checkin')
} for model in models])
class AcademyEventsTestSuite(EventTestCase):
cache = EventCache()
def test_academy_single_event_no_auth(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_single_event',
kwargs={"event_id": 1})
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_single_event',
kwargs={"event_id": 1})
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)
@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_single_event_invalid_id(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_single_event',
kwargs={"event_id": 1})
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 = {'detail': 'Event not found', 'status_code': 404}
self.assertEqual(json, expected)
self.assertEqual(response.status_code, 404)
@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_single_event_valid_id(self):
self.headers(academy=1)
url = reverse_lazy('events:academy_single_event',
kwargs={"event_id": 1})
model = 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,
'capacity': model['event'].capacity,
'description': model['event'].description,
'excerpt': model['event'].excerpt,
'title': model['event'].title,
'lang': model['event'].lang,
'url': model['event'].url,
'banner': model['event'].banner,
'starting_at': datetime_to_iso_format(model['event'].starting_at),
'ending_at': datetime_to_iso_format(model['event'].ending_at),
'status': model['event'].status,
'event_type': model['event'].event_type,
'online_event': model['event'].online_event,
'venue': model['event'].venue,
'academy': {
'id': 1,
'slug': model['academy'].slug,
'name': model['academy'].name,
'city': {
'name': model['event'].academy.city.name
}
}
}
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_id_put_without_required_fields(self):
"""Test /cohort without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_event',
role='potato2',
event=True)
url = reverse_lazy('events:academy_single_event',
kwargs={'event_id': 1})
current_date = self.datetime_now()
data = {
'id': 1,
}
response = self.client.put(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(response.status_code, 400)
self.assertEqual(self.all_event_dict(), [{
**self.model_to_dict(model, 'event'),
}])
@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_id_put(self):
"""Test /cohort without auth"""
self.headers(academy=1)
model = self.generate_models(authenticate=True,
profile_academy=True,
capability='crud_event',
role='potato2',
event=True)
url = reverse_lazy('events:academy_single_event',
kwargs={'event_id': 1})
current_date = self.datetime_now()
data = {
'id': 1,
'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.put(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': 1,
'description': None,
'event_type': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host': 1,
'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(model, 'event'),
**data,
'starting_at': current_date,
'ending_at': current_date,
}])
@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_put(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 = AcademyEventTestSuite.test_all_academy_events(self)
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_single_event',
kwargs={'event_id': 1})
current_date = self.datetime_now()
data = {
'id': 1,
'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.put(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': 1,
'description': None,
'event_type': None,
'eventbrite_id': None,
'eventbrite_organizer_id': None,
'eventbrite_status': None,
'eventbrite_url': None,
'excerpt': None,
'host': 1,
'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(model, 'event'),
**data,
'starting_at': current_date,
'ending_at': current_date,
}])
self.assertEqual(self.cache.keys(), [])
event = old_model[0]['event']
for x in data:
setattr(event, x, data[x])
event.starting_at = current_date
event.ending_at = current_date
old_model[0]['event'] = event
base = [
self.generate_models(authenticate=True, models=old_model[0]),
]
AcademyEventTestSuite.test_all_academy_events(self, base)
self.assertEqual(self.cache.keys(), cache_keys)