def test_create_no_price(self):
"""
Ensure we can create a timeslot without providing a price.
"""
self.client.force_authenticate(user=self.admin)
data = {
'period': reverse('period-detail', args=[self.period.id]),
# 'price': '10.00', # Will use Period's price if not provided
'start_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 12)),
'end_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 16)),
}
response = self.client.post(
reverse('timeslot-list'),
data,
format='json',
)
response_data = remove_translation_fields(json.loads(response.content))
response_data['workplace'] = remove_translation_fields(
response_data['workplace']
)
content = {
'id': 3,
'end_time': data['end_time'].isoformat(),
'price': '3.00',
'places_remaining': 40,
'reservations': [],
'reservations_canceled': [],
'start_time': data['start_time'].isoformat(),
'url': 'http://testserver/time_slots/3',
'period': 'http://testserver/periods/1',
'users': [],
'workplace': {
'address_line1': '123 random street',
'address_line2': None,
'city': '',
'country': 'Random country',
'details': 'short_description',
'id': 1,
'latitude': None,
'longitude': None,
'name': 'Blitz',
'pictures': [],
'postal_code': '123 456',
'seats': 40,
'state_province': 'Random state',
'timezone': None,
'url': 'http://testserver/workplaces/1',
}
}
self.assertEqual(response_data, content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_list_as_admin(self):
"""
Ensure we can list all packages as an admin.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('package-list'),
format='json',
)
data = remove_translation_fields(json.loads(response.content))
data['results'] = [
remove_translation_fields(m) for m in data['results']
]
content = {
'count':
2,
'next':
None,
'previous':
None,
'results': [{
'available': True,
'details': '100 reservations package',
'exclusive_memberships': [],
'id': self.package.id,
'name': 'extreme_package',
'price': '400.00',
'reservations': 100,
'url': f'http://testserver/packages/{self.package.id}',
'available_on_product_types': [],
'available_on_products': [],
'options': [],
}, {
'available': False,
'details': 'todo',
'exclusive_memberships': [],
'id': self.package_unavailable.id,
'name': 'pending_package',
'price': '400.00',
'reservations': 100,
'url': f'http://testserver/packages/'
f'{self.package_unavailable.id}',
'available_on_product_types': [],
'available_on_products': [],
'options': [],
}]
}
self.assertEqual(data, content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_list_as_admin(self):
"""
Ensure we can list all memberships as an admin.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('membership-list'),
format='json',
)
data = remove_translation_fields(json.loads(response.content))
data['results'] = [
remove_translation_fields(m) for m in data['results']
]
content = {
'count': 2,
'next': None,
'previous': None,
'results': [{
'available': True,
'id': self.membership.id,
'details': '1-Year student membership',
'duration': '365 00:00:00',
'name': 'basic_membership',
'price': '50.00',
'url': 'http://testserver/memberships/' +
str(self.membership.id),
'academic_levels': ['http://testserver/academic_levels/' +
str(self.academic_level.id)],
'available_on_product_types': [],
'available_on_products': [],
'options': [],
}, {
'available': False,
'id': self.membership_unavailable.id,
'details': 'todo',
'duration': '365 00:00:00',
'name': 'pending_membership',
'price': '50.00',
'url': 'http://testserver/memberships/' +
str(self.membership_unavailable.id),
'academic_levels': ['http://testserver/academic_levels/' +
str(self.academic_level.id)],
'available_on_product_types': [],
'available_on_products': [],
'options': [],
}]
}
self.assertEqual(data, content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_read_admin(self):
"""
Ensure we can read a package's order lines as an admin.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('package-detail', args=[self.package.id]), )
content = {
'available': True,
'details': '100 reservations package',
'exclusive_memberships': [],
'id': self.package.id,
'name': 'extreme_package',
'order_lines':
[f'http://testserver/order_lines/{self.order_line.id}'],
'price': '400.00',
'reservations': 100,
'url': f'http://testserver/packages/{self.package.id}'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)), content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_create(self):
"""
Ensure we can create a picture if user has permission.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "random_picture",
'retreat': reverse('retreat:retreat-detail',
args=[self.retreat.id]),
'picture': self.picture_file,
}
response = self.client.post(
reverse('retreat:picture-list'),
data,
)
fname = self.picture_file.name.replace('\\', '/').split("/")[-1]
content = {
'name': 'random_picture',
'picture': 'http://testserver/media/retreats/' + fname,
'retreat':
'http://testserver/retreat/retreats/' + str(self.retreat.id)
}
response_data = remove_translation_fields(json.loads(response.content))
del response_data['url']
del response_data['id']
self.assertEqual(response_data, content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create(self):
"""
Ensure we can create a picture if user has permission.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "random_picture",
'workplace': reverse('workplace-detail', args=[self.workplace.id]),
'picture': self.picture_file,
}
response = self.client.post(
reverse('picture-list'),
data,
)
fname = self.picture_file.name.replace('\\', '/').split("/")[-1]
content = {
'id': 2,
'name': 'random_picture',
'picture': 'http://testserver/media/workplaces/' + fname,
'url': 'http://testserver/pictures/2',
'workplace': 'http://testserver/workplaces/1'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)), content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def to_representation(self, instance):
user = self.context['request'].user
data = super(BaseProductSerializer, self).to_representation(instance)
if not user.is_staff:
data.pop("order_lines")
data = remove_translation_fields(data)
return data
def test_list(self):
"""
Ensure we can list active periods as an unauthenticated user if is
active.
"""
response = self.client.get(
reverse('period-list'),
format='json',
)
data = json.loads(response.content)
data['results'] = [
remove_translation_fields(m) for m in data['results']
]
content = {
'count': 1,
'next': None,
'previous': None,
'results': [{
'id': 2,
'end_date': data['results'][0]['end_date'],
'is_active': True,
'name': 'random_period_active',
'price': '3.00',
'total_reservations': 1,
'start_date': data['results'][0]['start_date'],
'url': 'http://testserver/periods/2',
'workplace': 'http://testserver/workplaces/1'
}]
}
self.assertEqual(data, content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_read_as_admin(self):
"""
Ensure we can read a membership as an unauthenticated user.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse(
'membership-detail',
kwargs={'pk': 1},
),
)
content = {
'available': True,
'id': 1,
'details': '1-Year student membership',
'duration': '365 00:00:00',
'name': 'basic_membership',
'order_lines': [],
'price': '50.00',
'url': 'http://testserver/memberships/1',
'academic_levels': ['http://testserver/academic_levels/1']
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_read_inactive(self):
"""
Ensure we can read a period as admin if it is inactive.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse(
'period-detail',
args=[self.period.id]
),
)
data = json.loads(response.content)
content = {
'id': self.period.id,
'end_date': data['end_date'],
'is_active': False,
'name': 'random_period',
'price': '3.00',
'total_reservations': 0,
'start_date': data['start_date'],
'url': f'http://testserver/periods/{self.period.id}',
'workplace': f'http://testserver/workplaces/{self.workplace.id}'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_partial(self):
"""
Ensure we can partially update a package.
"""
self.client.force_authenticate(user=self.admin)
data = {
'details': "New very cool details",
'price': 99,
}
response = self.client.patch(
reverse('package-detail', args=[self.package.id]),
data,
format='json',
)
content = {
'available': True,
'details': 'New very cool details',
'exclusive_memberships': [],
'id': self.package.id,
'name': 'extreme_package',
'order_lines':
[f'http://testserver/order_lines/{self.order_line.id}'],
'price': '99.00',
'reservations': 100,
'url': f'http://testserver/packages/{self.package.id}'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)), content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update(self):
"""
Ensure we can fully update a timeslot without users.
"""
self.client.force_authenticate(user=self.admin)
data = {
'period': reverse('period-detail', args=[self.period.id]),
'price': '10.00', # Will use Period's price if not provided
'start_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 12)),
'end_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 16)),
}
response = self.client.put(
reverse(
'timeslot-detail',
kwargs={'pk': 2},
),
data,
format='json',
)
response_data = json.loads(response.content)
response_data['workplace'] = remove_translation_fields(
response_data['workplace']
)
content = {
'id': 2,
'end_time': data['end_time'].isoformat(),
'price': '10.00',
'places_remaining': 40,
'reservations': [],
'reservations_canceled': [],
'start_time': data['start_time'].isoformat(),
'url': 'http://testserver/time_slots/2',
'period': 'http://testserver/periods/1',
'users': [],
"workplace": {
"address_line1": "123 random street",
"address_line2": None,
"city": "",
"country": "Random country",
"details": "short_description",
"id": 1,
"latitude": None,
"longitude": None,
"name": "Blitz",
"pictures": [],
"postal_code": "123 456",
"seats": 40,
"state_province": "Random state",
"timezone": None,
"url": "http://testserver/workplaces/1"
}
}
self.assertEqual(response_data, content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def to_representation(self, instance):
user = self.context['request'].user
self.fields['options'] = BaseProductManagerSerializer(many=True)
data = super(BaseProductSerializer, self).to_representation(instance)
if not user.is_staff:
data = remove_translation_fields(data)
return data
def to_representation(self, instance):
is_staff = self.context['request'].user.is_staff
if self.context['view'].action == 'retrieve' and is_staff:
self.fields['users'] = UserSerializer(many=True)
data = super(RetirementSerializer, self).to_representation(instance)
if is_staff:
return data
return remove_translation_fields(data)
def test_create(self):
"""
Ensure we can create a workplace if user has permission.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "random_workplace",
'seats': 40,
'details': "short_description",
'address_line1': 'random_address_1',
'city': 'random_city',
'country': 'Random_Country',
'postal_code': 'RAN_DOM',
'state_province': 'Random_State',
'timezone': "America/Montreal",
'volunteers': [f"http://testserver/users/{self.user.id}"],
}
response = self.client.post(
reverse('workplace-list'),
data,
format='json',
)
response_content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED,
response.content)
content = {
'details': 'short_description',
'address_line1': 'random_address_1',
'address_line2': None,
'city': 'random_city',
'country': 'Random_Country',
'postal_code': 'RAN_DOM',
'state_province': 'Random_State',
'latitude': None,
'longitude': None,
'name': 'random_workplace',
'pictures': [],
'seats': 40,
'timezone': "America/Montreal",
'place_name': '',
'volunteers': [
f'http://testserver/users/{self.user.id}'
],
}
del response_content['id']
del response_content['url']
self.assertEqual(
remove_translation_fields(response_content),
content
)
def test_update(self):
"""
Ensure we can update a membership.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "basic_membership_updated",
'details': "1-Year student membership",
'price': 10,
'duration': timedelta(days=365),
'available': True,
# ManytoMany relationship not required for some reasons.
# Needs investigtion.
# 'academic_levels': [reverse(
# 'academiclevel-detail', args=[self.academic_level.id]
# )],
}
response = self.client.put(
reverse(
'membership-detail',
kwargs={'pk': self.membership.id},
),
data,
format='json',
)
content = {
'available':
True,
'details':
'1-Year student membership',
'duration':
'365 00:00:00',
'name':
'basic_membership_updated',
'order_lines': [],
'price':
'10.00',
'url':
'http://testserver/memberships/' + str(self.membership.id),
'id':
self.membership.id,
'academic_levels': [
'http://testserver/academic_levels/' +
str(self.academic_level.id)
]
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)), content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_create(self):
"""
Ensure we can create a package if user has permission.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name':
"basic_package",
'details':
"10 reservations package",
'available':
True,
'price':
50,
'reservations':
10,
'exclusive_memberships': [
reverse('membership-detail', args=[self.membership.id]),
],
}
response = self.client.post(
reverse('package-list'),
data,
format='json',
)
content = {
'details':
'10 reservations package',
'exclusive_memberships':
[f'http://testserver/memberships/{self.membership.id}'],
'available':
True,
'name':
'basic_package',
'price':
'50.00',
'reservations':
10,
'available_on_product_types': [],
'available_on_products': [],
'options': [],
}
response_content = json.loads(response.content)
del response_content['id']
del response_content['url']
self.assertEqual(remove_translation_fields(response_content), content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_list(self):
"""
Ensure we can list active timeslots as an unauthenticated user.
"""
response = self.client.get(
reverse('timeslot-list'),
format='json',
)
data = json.loads(response.content)
for idx, obj in enumerate(data['results']):
data['results'][idx]['workplace'] = remove_translation_fields(
obj['workplace']
)
content = {
'count': 1,
'next': None,
'previous': None,
'results': [{
'id': 2,
'end_time': data['results'][0]['end_time'],
'price': '3.00',
'places_remaining': 40,
'reservations': [],
'reservations_canceled': [],
'start_time': data['results'][0]['start_time'],
'url': 'http://testserver/time_slots/2',
'period': 'http://testserver/periods/2',
'users': [],
"workplace": {
"address_line1": "123 random street",
"address_line2": None,
"city": "",
"country": "Random country",
"details": "short_description",
"id": 2,
"latitude": None,
"longitude": None,
"name": "Blitz2",
"pictures": [],
"postal_code": "123 456",
"seats": 40,
"state_province": "Random state",
"timezone": None,
"url": "http://testserver/workplaces/2"
}
}]
}
self.assertEqual(data, content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update(self):
"""
Ensure we can update a workplace.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "new_workplace",
'seats': 200,
'details': "new_short_description",
'address_line1': 'new_address',
'city': 'new_city',
'country': 'Random_Country',
'postal_code': 'NEW_CIT',
'state_province': 'Random_State',
'timezone': "America/Montreal",
}
response = self.client.put(
reverse(
'workplace-detail',
kwargs={'pk': 1},
),
data,
format='json',
)
content = {
'details': 'new_short_description',
'id': 1,
'longitude': None,
'latitude': None,
'address_line1': 'new_address',
'address_line2': None,
'city': 'new_city',
'country': 'Random_Country',
'postal_code': 'NEW_CIT',
'state_province': 'Random_State',
'name': 'new_workplace',
'pictures': [],
'seats': 200,
'timezone': 'America/Montreal',
'place_name': '',
'volunteers': [],
'url': 'http://testserver/workplaces/1'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_create(self):
"""
Ensure we can create a membership if user has permission.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name':
"advanced_membership",
'details':
"3-Year student membership",
'available':
True,
'price':
125,
'duration':
timedelta(days=365 * 3),
'academic_levels':
[reverse('academiclevel-detail', args=[self.academic_level.id])],
}
response = self.client.post(
reverse('membership-list'),
data,
format='json',
)
response_data = remove_translation_fields(json.loads(response.content))
del response_data['url']
del response_data['id']
content = {
'available':
True,
'details':
'3-Year student membership',
'duration':
'1095 00:00:00',
'name':
'advanced_membership',
'order_lines': [],
'price':
'125.00',
'academic_levels': [
'http://testserver/academic_levels/' +
str(self.academic_level.id)
]
}
self.assertEqual(response_data, content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_list_inactive(self):
"""
Ensure we can list all periods as an admin user.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('period-list'),
format='json',
)
data = json.loads(response.content)
data['results'] = [
remove_translation_fields(m) for m in data['results']
]
content = {
'count': 2,
'next': None,
'previous': None,
'results': [{
'id': self.period.id,
'end_date': data['results'][0]['end_date'],
'is_active': False,
'name': 'random_period',
'price': '3.00',
'total_reservations': 0,
'start_date': data['results'][0]['start_date'],
'url': f'http://testserver/periods/{self.period.id}',
'workplace':
f'http://testserver/workplaces/{self.workplace.id}'
}, {
'id': self.period_active.id,
'end_date': data['results'][1]['end_date'],
'is_active': True,
'name': 'random_period_active',
'price': '3.00',
'total_reservations': 1,
'start_date': data['results'][1]['start_date'],
'url': f'http://testserver/periods/{self.period_active.id}',
'workplace':
f'http://testserver/workplaces/{self.workplace.id}'
}]
}
self.assertEqual(data, content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def to_representation(self, instance):
is_staff = self.context['request'].user.is_staff
if self.context['view'].action == 'retrieve' and is_staff:
from blitz_api.serializers import UserSerializer
self.fields['users'] = UserSerializer(many=True)
data = super(RetreatSerializer, self).to_representation(instance)
# We don't need orderlines for retreat in this serializer
if data.get("order_lines") is not None:
data.pop("order_lines")
# TODO put back available after migration from is_active
data.pop("available")
if is_staff:
return data
return remove_translation_fields(data)
def test_create(self):
"""
Ensure we can create a period if user has permission.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "random_period",
'workplace': reverse('workplace-detail', args=[self.workplace.id]),
'start_date': LOCAL_TIMEZONE.localize(
datetime.now() +
timedelta(weeks=5)),
'end_date': LOCAL_TIMEZONE.localize(
datetime.now() + timedelta(weeks=10)),
'price': '3.00',
'is_active': True,
}
response = self.client.post(
reverse('period-list'),
data,
format='json',
)
content = {
'end_date': data['end_date'].isoformat(),
'is_active': True,
'name': 'random_period',
'price': '3.00',
'total_reservations': 0,
'start_date': data['start_date'].isoformat(),
'workplace': f'http://testserver/workplaces/{self.workplace.id}'
}
response_content = json.loads(response.content)
del response_content['id']
del response_content['url']
self.assertEqual(
remove_translation_fields(response_content),
content
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_update(self):
"""
Ensure we can update a period without reservations.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "new_period",
'workplace': reverse('workplace-detail', args=[self.workplace.id]),
'start_date': LOCAL_TIMEZONE.localize(
datetime.now() + timedelta(weeks=5)),
'end_date': LOCAL_TIMEZONE.localize(
datetime.now() + timedelta(weeks=10)),
'price': '3.00',
'is_active': True,
}
response = self.client.put(
reverse(
'period-detail',
args=[self.period.id]
),
data,
format='json',
)
content = {
'id': self.period.id,
'end_date': data['end_date'].isoformat(),
'is_active': True,
'name': 'new_period',
'price': '3.00',
'total_reservations': 0,
'start_date': data['start_date'].isoformat(),
'url': f'http://testserver/periods/{self.period.id}',
'workplace': f'http://testserver/workplaces/{self.workplace.id}'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_create(self):
"""
Ensure we can create a timeslot if user has permission.
If the period is not assigned to a workplace, places_remaining should
be 0.
"""
self.client.force_authenticate(user=self.admin)
data = {
'period': reverse(
'period-detail', args=[self.period_no_workplace.id]
),
'price': '10.00', # Will use Period's price if not provided
'start_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 12)),
'end_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 16)),
}
response = self.client.post(
reverse('timeslot-list'),
data,
format='json',
)
content = {
'id': 3,
'end_time': data['end_time'].isoformat(),
'price': '10.00',
'places_remaining': 0,
'reservations': [],
'reservations_canceled': [],
'start_time': data['start_time'].isoformat(),
'url': 'http://testserver/time_slots/3',
'period': 'http://testserver/periods/3',
'users': [],
'workplace': None
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_update_partial(self):
"""
Ensure we can partially update a period.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "updated_period",
'start_date': timezone.now() + timedelta(weeks=1),
'price': '2000.00',
}
response = self.client.patch(
reverse(
'period-detail',
kwargs={'pk': 1},
),
data,
format='json',
)
response_data = json.loads(response.content)
content = {
'id': 1,
'is_active': False,
'name': 'updated_period',
'price': '2000.00',
'total_reservations': 0,
'end_date': response_data['end_date'],
'start_date': data['start_date'].astimezone().isoformat(),
'url': 'http://testserver/periods/1',
'workplace': 'http://testserver/workplaces/1'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update(self):
"""
Ensure we can update a package.
"""
self.client.force_authenticate(user=self.admin)
data = {
'name': "extreme_package_updated",
'details': "999 reservations package",
'price': 1,
'reservations': 999,
'available': True,
}
response = self.client.put(
reverse(
'package-detail',
kwargs={'pk': 1},
),
data,
format='json',
)
content = {
'available': True,
'details': '999 reservations package',
'exclusive_memberships': [],
'id': 1,
'name': 'extreme_package_updated',
'order_lines': ['http://testserver/order_lines/1'],
'price': '1.00',
'reservations': 999,
'url': 'http://testserver/packages/1'
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)),
content
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def to_representation(self, instance):
data = super(PictureSerializer, self).to_representation(instance)
if self.context['request'].user.is_staff:
return data
return remove_translation_fields(data)
def test_create_duplicate(self):
"""
Ensure we can create the same reservation multiple times. This does
not duplicate the entry and instead returns the existing one.
"""
self.client.force_authenticate(user=self.admin)
data = {
'timeslot': reverse('timeslot-detail',
args=[self.time_slot_active.id]),
'user': reverse('user-detail', args=[self.user.id]),
'is_active': True,
}
response = self.client.post(
reverse('reservation-list'),
data,
format='json',
)
response_data = json.loads(response.content)
response_data['timeslot_details'] = remove_translation_fields(
response_data['timeslot_details'])
response_data['timeslot_details'][
'workplace'] = remove_translation_fields(
response_data['timeslot_details']['workplace'])
response_data['user_details'] = remove_translation_fields(
response_data['user_details'])
del response_data['user_details']["first_name"]
del response_data['user_details']["last_name"]
del response_data['user_details']["email"]
del response_data['user_details']['date_joined']
content = {
'id': 3,
'is_active': True,
'is_present': False,
'timeslot': 'http://testserver/time_slots/2',
'url': 'http://testserver/reservations/3',
'user': '******',
'cancelation_date': None,
'cancelation_reason': None,
'timeslot_details': {
'end_time':
'2130-01-15T22:00:00-05:00',
'id':
2,
'period':
'http://testserver/periods/2',
'places_remaining':
-2,
'reservations': [
'http://testserver/reservations/1',
'http://testserver/reservations/2',
'http://testserver/reservations/3'
],
'reservations_canceled': [],
'price':
'3.00',
'start_time':
'2130-01-15T18:00:00-05:00',
'url':
'http://testserver/time_slots/2',
'users': [
'http://testserver/users/1', 'http://testserver/users/2',
'http://testserver/users/1'
],
'workplace': {
'address_line1': '123 random street',
'address_line2': None,
'city': '',
'country': 'Random country',
'details': 'short_description',
'id': 2,
'latitude': None,
'longitude': None,
'name': 'Blitz2',
'pictures': [],
'postal_code': '123 456',
'seats': 1,
'state_province': 'Random state',
'timezone': None,
'url': 'http://testserver/workplaces/2'
}
},
'user_details': {
'academic_field': None,
'academic_level': None,
'birthdate': None,
'gender': None,
'groups': [],
'id': 1,
'is_active': True,
'is_staff': False,
'is_superuser': False,
'last_login': None,
'membership': None,
'membership_end': None,
'other_phone': None,
'phone': None,
'tickets': 1,
'university': None,
'url': 'http://testserver/users/1',
'user_permissions': []
}
}
self.assertEqual(response_data, content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create(self):
"""
Ensure we can create a retirement if user has permission.
"""
self.client.force_authenticate(user=self.admin)
responses.add(responses.POST,
"http://example.com/authentication",
json={"token": "1234567890"},
status=200)
responses.add(responses.POST, "http://example.com/tasks", status=200)
data = {
'name': "random_retirement",
'seats': 40,
'details': "short_description",
'address_line1': 'random_address_1',
'city': 'random_city',
'country': 'Random_Country',
'postal_code': 'RAN_DOM',
'state_province': 'Random_State',
'timezone': "America/Montreal",
'price': '100.00',
'start_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 15, 12)),
'end_time': LOCAL_TIMEZONE.localize(datetime(2130, 1, 17, 16)),
'min_day_refund': 7,
'min_day_exchange': 7,
'refund_rate': 50,
'is_active': True,
'accessibility': True,
'form_url': "example.com",
'carpool_url': 'example2.com',
'review_url': 'example3.com',
}
response = self.client.post(
reverse('retirement:retirement-list'),
data,
format='json',
)
self.assertEqual(
response.status_code,
status.HTTP_201_CREATED,
response.content,
)
content = {
'details': 'short_description',
'email_content': None,
'id': 3,
'address_line1': 'random_address_1',
'address_line2': None,
'city': 'random_city',
'country': 'Random_Country',
'postal_code': 'RAN_DOM',
'state_province': 'Random_State',
'latitude': None,
'longitude': None,
'name': 'random_retirement',
'next_user_notified': 0,
'notification_interval': '1 00:00:00',
'pictures': [],
'start_time': '2130-01-15T12:00:00-05:00',
'end_time': '2130-01-17T16:00:00-05:00',
'seats': 40,
'reserved_seats': 0,
'activity_language': None,
'price': '100.00',
'exclusive_memberships': [],
'timezone': "America/Montreal",
'is_active': True,
'places_remaining': 40,
'min_day_exchange': 7,
'min_day_refund': 7,
'refund_rate': 50,
'reservations': [],
'reservations_canceled': [],
'total_reservations': 0,
'users': [],
'url': 'http://testserver/retirement/retirements/3',
'accessibility': True,
'form_url': "example.com",
'carpool_url': 'example2.com',
'review_url': 'example3.com',
'place_name': '',
}
self.assertEqual(
remove_translation_fields(json.loads(response.content)), content)
