class CellTests(APITransactionTestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
def test_create_cell(self):
"""
Ensure we can create a new cell with just required arguments
"""
cell = Cell.objects.create(
name='my cell',
address=self.address,
)
self.assertEqual(cell.name, 'my cell')
self.assertEqual(cell.address, self.address)
def test_create_cell_missing_attribute(self):
"""
Ensure we can't create a new cell without required arguments
"""
self.assertRaises(IntegrityError, Cell.objects.create)
self.assertRaises(IntegrityError, Cell.objects.create, name="my cell")
self.assertRaises(IntegrityError,
Cell.objects.create,
address=self.address)
class TaskTypesTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.tasktype = TaskType.objects.create(name='TaskType 1', )
def test_create_new_tasktype_with_permission(self):
"""
Ensure we can create a new tasktype if we have the permission.
"""
data = {
'name': 'TaskType 3',
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:tasktypes'),
data,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create_new_tasktype_without_permission(self):
"""
Ensure we can't create a new tasktype if we don't have the permission.
"""
data = {
'name': 'TaskType 3',
}
self.client.force_authenticate(user=self.user)
response = self.client.post(
reverse('volunteer:tasktypes'),
data,
format='json',
)
content = {
"detail": "You are not authorized to create a new tasktype."
}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_list_tasktype(self):
"""
Ensure we can list all tasktypes.
"""
data = [{
"id": self.tasktype.id,
"name": self.tasktype.name,
}]
self.client.force_authenticate(user=self.user)
response = self.client.get(reverse('volunteer:tasktypes'))
self.assertEqual(json.loads(response.content)['results'], data)
self.assertEqual(json.loads(response.content)['count'], 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class ParticipationsIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.user2 = UserFactory()
self.user2.set_password('Test123!')
self.user2.save()
self.user_cell_manager = UserFactory()
self.user_cell_manager.set_password('Test123!')
self.user_cell_manager_no_perms = UserFactory()
self.user_cell_manager_no_perms.set_password('Test123!')
self.user_cell_manager_no_perms.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.cell_with_manager = Cell.objects.create(
name="my cell with manager",
address=self.address,
)
self.cell_with_manager.managers = [
self.user_cell_manager,
]
self.cell_with_manager.save()
self.cycle = Cycle.objects.create(name="my cycle", )
self.task_type = TaskType.objects.create(name="my tasktype", )
start_date = timezone.now() + timezone.timedelta(minutes=100, )
end_date = start_date + timezone.timedelta(minutes=100, )
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event2 = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event_with_manager = Event.objects.create(
cell=self.cell_with_manager,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
subscription_date = timezone.now()
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
self.participation = Participation.objects.create(
standby=True,
subscription_date=subscription_date,
user=self.user,
event=self.event2,
)
self.participation2 = Participation.objects.create(
standby=True,
subscription_date=subscription_date,
user=self.user2,
event=self.event2,
)
self.participation_cell_manager = Participation.objects.create(
standby=True,
subscription_date=subscription_date,
user=self.user2,
event=self.event_with_manager,
)
def test_retrieve_participation_id_not_exist(self):
"""
Ensure we can't retrieve a participation that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:participations_id',
kwargs={'pk': 999},
),
format='json',
)
content = {"detail": "Not found."}
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(json.loads(response.content), content)
def test_retrieve_participation_as_owner(self):
"""
Ensure we can retrieve a participation as the owner.
"""
subscription_date_str = self.participation.subscription_date.\
strftime("%Y-%m-%dT%H:%M:%S.%fZ")
duration_minutes = self.participation.presence_duration_minutes
data = dict(
id=self.participation.id,
standby=self.participation.standby,
subscription_date=subscription_date_str,
event=self.participation.event.id,
presence_duration_minutes=duration_minutes,
presence_status=self.participation.presence_status,
)
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation.id},
))
content = json.loads(response.content)
del content['user']
self.assertEqual(content, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_retrieve_participation_basic_serializer(self):
"""
Ensure we can retrieve a participation.
Using the BasicSerializer
"""
subscription_date_str = self.participation2.subscription_date.\
strftime("%Y-%m-%dT%H:%M:%S.%fZ")
duration_minutes = self.participation2.presence_duration_minutes
data = dict(
id=self.participation2.id,
standby=self.participation2.standby,
subscription_date=subscription_date_str,
event=self.participation2.event.id,
presence_duration_minutes=duration_minutes,
presence_status=self.participation2.presence_status,
)
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation2.id},
))
content = json.loads(response.content)
del content['user']
self.assertEqual(content, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_participation_with_permission(self):
"""
Ensure we can update a specific participation if the caller owns it.
"""
subscription_date = timezone.now()
subscription_date_str = subscription_date.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ")
duration_minutes = self.participation.presence_duration_minutes
data = dict(
id=self.participation.id,
standby=False,
subscription_date=subscription_date_str,
event=self.participation.event.id,
presence_duration_minutes=duration_minutes,
presence_status=self.participation.presence_status,
)
data_post = {
"standby": False,
}
self.client.force_authenticate(user=self.user)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.patch(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation.id},
),
data_post,
format='json',
)
content = json.loads(response.content)
del content['user']
self.assertEqual(content, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_participation_with_superuser(self):
"""
Ensure we can update a specific participation if we are superuser.
"""
subscription_date = timezone.now()
subscription_date_str = subscription_date.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ", )
data = dict(
id=self.participation.id,
standby=self.participation.standby,
subscription_date=subscription_date_str,
event=self.participation.event.id,
presence_duration_minutes=14,
presence_status='P',
)
data_post = {
"presence_status": 'P',
"presence_duration_minutes": 14,
}
self.client.force_authenticate(user=self.admin)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.patch(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation.id},
),
data_post,
format='json',
)
content = json.loads(response.content)
del content['user']
self.assertEqual(content, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_participation_status(self):
"""
Ensure we can update our own participation status if we're user.
"""
subscription_date = timezone.now()
subscription_date_str = subscription_date.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ", )
data = dict(
id=self.participation.id,
standby=self.participation.standby,
subscription_date=subscription_date_str,
event=self.participation.event.id,
presence_duration_minutes=14,
presence_status='P',
)
data_post = {
"presence_status": 'P',
"presence_duration_minutes": 14,
}
self.client.force_authenticate(user=self.user)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.patch(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation.id},
),
data_post,
format='json',
)
content = json.loads(response.content)
del content['user']
self.assertEqual(content, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_participation_without_permission(self):
"""
Ensure we can't update a specific participation of another user.
"""
data_post = {
"standby": False,
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation2.id},
),
data_post,
format='json',
)
content = {
'detail': "You do not have permission to perform this action.",
}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_participation_that_doesnt_exist(self):
"""
Ensure we can't update a specific participation if it doesn't exist.
"""
data_post = {
"standby": True,
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:participations_id',
kwargs={'pk': 9999},
),
data_post,
format='json',
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_update_participation_cell_manager(self):
"""
Ensure we have the right to modify a Participation
if the user is a Cell manager
"""
self.client.force_authenticate(user=self.user_cell_manager)
data_patch = {'presence_status': 'P'}
subscription_date = timezone.now()
subscription_date_str = subscription_date.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ", )
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.patch(
reverse('volunteer:participations_id',
kwargs={'pk': self.participation_cell_manager.id}),
data_patch,
format='json',
)
content = {
"id": self.participation_cell_manager.id,
"event": self.participation_cell_manager.event.pk,
"user": {
"id": self.user2.id,
"username": self.user2.username,
"email": self.user2.email,
"first_name": self.user2.first_name,
"last_name": self.user2.last_name,
"is_active": self.user2.is_active,
"is_superuser": self.user2.is_superuser,
"phone": None,
"mobile": None,
"managed_cell": []
},
"standby": True,
"subscription_date": subscription_date_str,
"presence_duration_minutes": None,
"presence_status": "P"
}
self.assertEqual(json.loads(response.content), content)
def test_update_participation_cell_manager_no_perms(self):
"""
Ensure we don't have the right to modify a Participation
if the user is not a Cell manager
"""
self.client.force_authenticate(user=self.user_cell_manager_no_perms)
data_patch = {'presence_status': 'P'}
subscription_date = timezone.now()
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.patch(
reverse('volunteer:participations_id',
kwargs={'pk': self.participation_cell_manager.id}),
data_patch,
format='json',
)
content = {
'detail': "You do not have permission to perform this action.",
}
self.assertEqual(json.loads(response.content), content)
def test_delete_participation_with_permission(self):
"""
Ensure we can delete a specific participation if the caller owns it.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation.id},
), )
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_participation_but_event_already_started(self):
"""
Ensure we can't delete a specific participation if
the event is already started.
"""
self.client.force_authenticate(user=self.user)
start_date = timezone.now()
end_date = start_date + timezone.timedelta(minutes=100, )
event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
participation = Participation.objects.create(
standby=True,
user=self.user,
event=event,
)
response = self.client.delete(
reverse(
'volunteer:participations_id',
kwargs={'pk': participation.id},
), )
content = {
'non_field_errors':
"You can't delete a participation if the "
"associated event is already started",
}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_participation_without_permission(self):
"""
Ensure we can't delete a specific participation without owning it.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:participations_id',
kwargs={'pk': self.participation2.id},
), )
content = {
'detail': "You do not have permission to perform this action.",
}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_participation_that_doesnt_exist(self):
"""
Ensure we can't delete a specific participation if it doesn't exist
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:participations_id',
kwargs={'pk': 9999},
), )
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class TaskTypesIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.tasktype = TaskType.objects.create(
name='TaskType 1',
)
def test_retrieve_tasktype_id_not_exist(self):
"""
Ensure we can't retrieve a TaskType that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': 999},
)
)
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_retrieve_tasktype(self):
"""
Ensure we can retrieve a TaskType.
"""
data = {
"id": self.tasktype.id,
"name": self.tasktype.name,
}
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': self.tasktype.id},
)
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_tasktype_with_permission(self):
"""
Ensure we can update a specific TaskType.
"""
data = {
"id": self.tasktype.id,
"name": "my new_name",
}
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': self.tasktype.id},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_tasktype_id_not_exist_with_permission(self):
"""
Ensure we can update a specific TaskType.
"""
self.client.force_authenticate(user=self.admin)
data_post = {
"name": "my new_name",
}
response = self.client.patch(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': 999},
),
data_post,
format='json',
)
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_update_tasktype_without_permission(self):
"""
Ensure we can't update a specific tasktype without permission.
"""
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': self.tasktype.id},
),
data_post,
format='json',
)
content = {'detail': "You are not authorized to update a tasktype."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_tasktype_with_permission(self):
"""
Ensure we can delete a specific TaskType.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': self.tasktype.id},
),
)
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_tasktype_id_not_exist_with_permission(self):
"""
Ensure we can delete a specific TaskType.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': 999},
),
)
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_tasktype_without_permission(self):
"""
Ensure we can't delete a specific TaskType without permission.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:tasktypes_id',
kwargs={'pk': self.tasktype.id},
),
)
content = {'detail': "You are not authorized to delete a tasktype."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
class CellsIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.other_user = UserFactory()
self.other_user.set_password('Test123!')
self.other_user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="Random Country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="Random State",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name='my cell',
address=self.address,
)
def test_retrieve_cell_id_not_exist(self):
"""
Ensure we can't retrieve a cell that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:cells_id',
kwargs={'pk': 999},
))
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_retrieve_cell(self):
"""
Ensure we can retrieve a cell.
"""
data = {
"id":
self.cell.id,
"name":
self.cell.name,
"address":
dict(
id=self.address.id,
address_line1=self.address.address_line1,
postal_code=self.address.postal_code,
city=self.address.city,
state_province=dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code,
),
country=dict(
name=self.random_country.name,
iso_code=self.random_country.iso_code,
),
),
"managers": [],
}
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
))
data['address']['address_line2'] = ''
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_cell_with_permission(self):
"""
Ensure we can update a specific cell.
"""
data = {
"id":
self.cell.id,
"name":
"my new_name",
"address":
dict(
id=self.address.id,
address_line1=self.address.address_line1,
address_line2=self.address.address_line2,
postal_code=self.address.postal_code,
city=self.address.city,
state_province=dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code,
),
country=dict(
name=self.random_country.name,
iso_code=self.random_country.iso_code,
),
),
"managers": [],
}
data_post = {
"name":
"my new_name",
"address":
dict(
address_line1=self.address.address_line1,
postal_code=self.address.postal_code,
city=self.address.city,
state_province=dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code,
),
country=dict(
name=self.random_country.name,
iso_code=self.random_country.iso_code,
),
),
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_cell_country(self):
"""
Ensure we can't update only the country of a cell.
"""
data_post = {
"name":
self.cell.name,
"address":
dict(
address_line1=self.address.address_line1,
postal_code=self.address.postal_code,
city=self.address.city,
state_province=dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code,
),
country=dict(
name='New Country',
iso_code='NC',
),
),
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
# This happens because we are trying to recreate an already existing
# StateProvince to assign it to a new Country. This causes a iso_code
# duplication.
err = {'message': 'A StateProvince with that iso_code already exists'}
self.assertEqual(json.loads(response.content), err)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_update_cell_managers(self):
"""
Ensure we can update managers of a cells.
"""
self.assertEqual(self.cell.managers.count(), 0)
data_post = {"managers": [self.user.id]}
data = {
"id":
self.cell.id,
"name":
self.cell.name,
"address": {
"id": self.cell.address.id,
"address_line1": self.cell.address.address_line1,
"address_line2": '',
"postal_code": self.cell.address.postal_code,
"city": self.cell.address.city,
"state_province": {
"name": self.cell.address.state_province.name,
"iso_code": self.cell.address.state_province.iso_code,
},
"country": {
"name": self.cell.address.country.name,
"iso_code": self.cell.address.country.iso_code,
},
},
"managers": [
{
"id": self.user.id,
"username": self.user.username,
"first_name": self.user.first_name,
"last_name": self.user.last_name,
"email": self.user.email,
},
],
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.cell.managers.count(), 1)
self.assertEquals(self.user.has_perm('volunteer.add_participation'),
True)
self.assertEquals(self.user.has_perm('volunteer.change_participation'),
True)
self.assertEquals(self.user.has_perm('volunteer.delete_participation'),
True)
self.assertEquals(self.user.has_perm('volunteer.add_event'), True)
self.assertEquals(self.user.has_perm('volunteer.change_event'), True)
self.assertEquals(self.user.has_perm('volunteer.delete_event'), True)
# Now let's remove the manager
data_post = {"managers": []}
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
data['managers'] = []
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(len(self.user.user_permissions.all()), 0)
# Testing the signals
self.cell.managers.add(self.user, self.other_user)
self.cell.managers.remove(self.user)
def test_update_multiple_cell_managers(self):
"""
Ensure we can update multiple managers of a cells.
"""
self.assertEqual(self.cell.managers.count(), 0)
data_post = {
"managers": [
self.user.id,
self.admin.id,
]
}
data = {
"id":
self.cell.id,
"name":
self.cell.name,
"address": {
"id": self.cell.address.id,
"address_line1": self.cell.address.address_line1,
"address_line2": '',
"postal_code": self.cell.address.postal_code,
"city": self.cell.address.city,
"state_province": {
"name": self.cell.address.state_province.name,
"iso_code": self.cell.address.state_province.iso_code,
},
"country": {
"name": self.cell.address.country.name,
"iso_code": self.cell.address.country.iso_code,
},
},
"managers": [
{
"id": self.user.id,
"username": self.user.username,
"first_name": self.user.first_name,
"last_name": self.user.last_name,
"email": self.user.email,
},
{
"id": self.admin.id,
"username": self.admin.username,
"first_name": self.admin.first_name,
"last_name": self.admin.last_name,
"email": self.admin.email,
},
],
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(self.cell.managers.count(), 2)
def test_update_cell_with_empty_address(self):
"""
Ensure we can't update a cells with an empty address.
"""
data_post = {
"address": dict(),
"managers": [
self.user.id,
self.admin.id,
]
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = {'message': "Please specify a complete valid address."}
self.assertEqual(json.loads(response.content), content)
def test_update_cell_without_permission(self):
"""
Ensure we can't update a specific cell without permission.
"""
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
content = {'detail': "You are not authorized to update a cell."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_cell_that_doesnt_exist(self):
"""
Ensure we can't update a specific cell if it doesn't exist.
"""
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': 9999},
),
data_post,
format='json',
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_cell_with_permission(self):
"""
Ensure we can delete a specific cell.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
), )
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_cell_without_permission(self):
"""
Ensure we can't delete a specific cell without permission.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
), )
content = {'detail': "You are not authorized to delete a cell."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_cell_that_doesnt_exist(self):
"""
Ensure we can't delete a specific cell if it doesn't exist
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:cells_id',
kwargs={'pk': 9999},
), )
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_update_cell_with_bad_manager(self):
"""
Ensure we can't update a cell with a bad manager id.
"""
self.assertEqual(self.cell.managers.count(), 0)
data_post = {"managers": [7812]}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cells_id',
kwargs={'pk': self.cell.id},
),
data_post,
format='json',
)
content = json.loads(response.content)
error = {'message': 'Unknown user with this ID'}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(content, error)
class CellExportationTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.user2 = UserFactory()
self.user2.set_password('Test123!')
self.user2.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.cycle = Cycle.objects.create(
name="my cycle",
)
self.task_type = TaskType.objects.create(
name="my tasktype",
)
start_date = timezone.now() - timezone.timedelta(
minutes=100,
)
end_date = start_date + timezone.timedelta(
minutes=50,
)
self.cycle_inactive = Cycle.objects.create(
name="my cycle",
start_date=start_date,
end_date=end_date,
)
# Some date INSIDE the cycle range
start_date = start_date + timezone.timedelta(
minutes=1,
)
end_date = end_date - timezone.timedelta(
minutes=1,
)
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event2 = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
subscription_date = timezone.now()
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
self.participation = Participation.objects.create(
standby=True,
user=self.user,
event=self.event2,
)
self.participation2 = Participation.objects.create(
standby=True,
user=self.user2,
event=self.event2,
)
self.participation3 = Participation.objects.create(
standby=True,
user=self.user2,
event=self.event,
)
"Create temp directory and update MEDIA_ROOT and default storage."
settings._original_media_root = settings.MEDIA_ROOT
settings._original_file_storage = settings.DEFAULT_FILE_STORAGE
self._temp_media = tempfile.mkdtemp()
settings.MEDIA_ROOT = self._temp_media
settings.DEFAULT_FILE_STORAGE = \
'django.core.files.storage.FileSystemStorage'
def tearDown(self):
"Delete temp storage."
shutil.rmtree(self._temp_media, ignore_errors=True)
settings.MEDIA_ROOT = settings._original_media_root
del settings._original_media_root
settings.DEFAULT_FILE_STORAGE = settings._original_file_storage
del settings._original_file_storage
@override_settings(DEBUG=True)
def test_cell_exportation(self):
"""
Ensure we can export Participation from a Cell.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
'/volunteer/cells/%s/export' % self.cell.pk,
format='json',
)
content = json.loads(response.content)
# get today date without time
now = timezone.now()
now = now.replace(hour=0, minute=0, second=0, microsecond=0)
actual_file_path = \
'/%scell_export/%s_%s.csv' % \
(settings.MEDIA_URL, self.cell.pk, now.strftime('%Y%m%d'))
data_compare = {
'export_link': actual_file_path
}
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content, data_compare)
data = [
'standby,first_name,last_name,email,phone,mobile,'
'event__start_date,event__end_date,task_type,'
'cell,presence_status,presence_duration_minutes\n',
'1,%s,%s,%s,,,%s,%s,%s,%s,%s,\n' % (
self.participation2.user.first_name,
self.participation2.user.last_name,
self.participation2.user.email,
self.participation2.event.start_date
.strftime("%Y-%m-%d %H:%M:%S"),
self.participation2.event.end_date
.strftime("%Y-%m-%d %H:%M:%S"),
self.participation2.event.task_type.name,
self.participation2.cell,
self.participation2.presence_status,
),
'1,%s,%s,%s,,,%s,%s,%s,%s,%s,\n' % (
self.participation.user.first_name,
self.participation.user.last_name,
self.participation.user.email,
self.participation.event.start_date
.strftime("%Y-%m-%d %H:%M:%S"),
self.participation.event.end_date
.strftime("%Y-%m-%d %H:%M:%S"),
self.participation.event.task_type.name,
self.participation.cell,
self.participation.presence_status,
),
'1,%s,%s,%s,,,%s,%s,%s,%s,%s,\n' % (
self.participation3.user.first_name,
self.participation3.user.last_name,
self.participation3.user.email,
self.participation3.event.start_date
.strftime("%Y-%m-%d %H:%M:%S"),
self.participation3.event.end_date
.strftime("%Y-%m-%d %H:%M:%S"),
self.participation3.event.task_type.name,
self.participation3.cell,
self.participation3.presence_status,
)]
actual_file_path = \
'%s/cell_export/%s_%s.csv' % \
(self._temp_media, self.cell.pk, now.strftime('%Y%m%d'))
with open(actual_file_path) as fp:
line = fp.readline()
cnt = 0
while line:
self.assertEqual(line, data[cnt])
line = fp.readline()
cnt += 1
class ParticipationsTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.user2 = UserFactory()
self.user2.set_password('Test123!')
self.user2.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.cycle = Cycle.objects.create(name="my cycle", )
self.task_type = TaskType.objects.create(name="my tasktype", )
start_date = timezone.now() - timezone.timedelta(minutes=100, )
end_date = start_date + timezone.timedelta(minutes=50, )
self.cycle_inactive = Cycle.objects.create(
name="my cycle",
start_date=start_date,
end_date=end_date,
)
# Some date INSIDE the cycle range
start_date = start_date + timezone.timedelta(minutes=1, )
end_date = end_date - timezone.timedelta(minutes=1, )
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event2 = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
subscription_date = timezone.now()
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
self.participation = Participation.objects.create(
standby=True,
user=self.user,
event=self.event2,
)
self.participation2 = Participation.objects.create(
standby=True,
user=self.user2,
event=self.event2,
)
self.participation3 = Participation.objects.create(
standby=True,
user=self.user2,
event=self.event,
)
def test_create_new_participation(self):
"""
Ensure we can create a new participation.
"""
subscription_date = timezone.now()
subscription_date_str = subscription_date.strftime(
"%Y-%m-%dT%H:%M:%S.%fZ", )
data = {
'event': self.event.id,
'user': self.user.id,
'standby': False,
'subscription_date': subscription_date,
}
self.client.force_authenticate(user=self.user)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.post(
reverse('volunteer:participations'),
data,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content['subscription_date'], subscription_date_str)
self.assertEqual(content['user']['id'], self.user.id)
self.assertEqual(content['event'], self.event.id)
self.assertEqual(content['standby'], False)
# Check the system doesn't return attributes not expected
attributes = [
'id',
'subscription_date',
'user',
'event',
'standby',
'presence_duration_minutes',
'presence_status',
]
for key in content.keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
def test_create_duplicate_participation(self):
"""
Ensure we can't create a duplicated participation.
"""
subscription_date = timezone.now()
data = {
'event': self.event2.id,
'standby': False,
}
self.client.force_authenticate(user=self.user)
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
response = self.client.post(
reverse('volunteer:participations'),
data,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
content = {
'non_field_errors': [
'The fields event, user must make a unique set.',
],
}
self.assertEqual(json.loads(response.content), content)
def test_list_participations(self):
"""
Ensure we can list all participations.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('volunteer:participations'),
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 3)
# Check the system doesn't return attributes not expected
attributes = [
'id',
'user',
'event',
'subscription_date',
'standby',
'presence_duration_minutes',
'presence_status',
]
for key in content['results'][0].keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
def test_list_participations_filtered_by_username(self):
"""
Ensure we can filter permissions by username.
"""
self.client.force_authenticate(user=self.user)
url = "{0}?username={1}".format(
reverse('volunteer:participations'),
self.user.username,
)
response = self.client.get(
url,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 1)
self.assertEqual(content['results'][0]['id'], self.participation.id)
# Check the system doesn't return attributes not expected
attributes = [
'id',
'user',
'event',
'subscription_date',
'standby',
'presence_duration_minutes',
'presence_status',
]
for key in content['results'][0].keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
def test_list_participations_filter_by_event(self):
"""
Ensure we can list participations filtered by event.
"""
self.client.force_authenticate(user=self.admin)
url = "{0}?event={1}".format(
reverse('volunteer:participations'),
self.event.id,
)
response = self.client.get(
url,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 1)
class CountriesTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="Random Country 1",
iso_code="RC",
)
def test_create_new_country_with_permission(self):
"""
Ensure we can create a new country if we have the permission.
"""
data = dict(
iso_code='R2',
name='Random Country 2',
)
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('location:countries'),
data,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(json.loads(response.content), data)
def test_create_existing_country_with_permission(self):
"""
Ensure we cannot recreate a country.
"""
data = dict(
iso_code='RC',
name='Random Country 1',
)
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('location:countries'),
data,
format='json',
)
err = {
'iso_code': ['country with this iso code already exists.']
}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(json.loads(response.content), err)
def test_create_new_country_without_permission(self):
"""
Ensure we can't create a new country if we don't have the permission.
"""
data = dict(
iso_code='RC',
name='Random Country 2',
)
self.client.force_authenticate(user=self.user)
response = self.client.post(
reverse('location:countries'),
data,
format='json',
)
content = {"detail": "You are not authorized to create a new country."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_list_country(self):
"""
Ensure we can list all countries.
"""
data = [
dict(
iso_code='RC',
name='Random Country 1',
),
]
self.client.force_authenticate(user=self.user)
response = self.client.get(reverse('location:countries'))
self.assertEqual(json.loads(response.content)['results'], data)
self.assertEqual(json.loads(response.content)['count'], 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class CountriesIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="Random Country",
iso_code="RC",
)
def test_retrieve_country_id_not_exist(self):
"""
Ensure we can't retrieve an country that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'location:countries_id',
kwargs={'pk': "XX"},
))
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_retrieve_country(self):
"""
Ensure we can retrieve an country.
"""
data = {
'name': self.random_country.name,
'iso_code': self.random_country.iso_code,
}
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'location:countries_id',
kwargs={'pk': self.random_country.iso_code},
))
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_country_with_permission(self):
"""
Ensure we can update a specific country.
"""
data = {
'iso_code': self.random_country.iso_code,
'name': "new country",
}
data_post = {
'iso_code': self.random_country.iso_code,
'name': "new country",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'location:countries_id',
kwargs={'pk': self.random_country.iso_code},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_country_without_permission(self):
"""
Ensure we can't update a specific country without permission.
"""
data_post = {
"name": "my country",
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'location:countries_id',
kwargs={'pk': self.random_country.iso_code},
),
data_post,
format='json',
)
content = {'detail': "You are not authorized to update a country."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_country_that_doesnt_exist(self):
"""
Ensure we can't update a specific country if it doesn't exist.
"""
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'location:countries_id',
kwargs={'pk': "XX"},
),
data_post,
format='json',
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_country_with_permission(self):
"""
Ensure we can delete a specific country.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'location:countries_id',
kwargs={'pk': self.random_country.iso_code},
), )
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_country_without_permission(self):
"""
Ensure we can't delete a specific country without permission.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'location:countries_id',
kwargs={'pk': self.random_country.iso_code},
), )
content = {'detail': "You are not authorized to delete a country."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_country_that_doesnt_exist(self):
"""
Ensure we can't delete a specific country if it doesn't exist
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'location:countries_id',
kwargs={'pk': "XX"},
), )
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class AddressesIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="Random Country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="Random State",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
def test_retrieve_address_id_not_exist(self):
"""
Ensure we can't retrieve an address that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'location:addresses_id',
kwargs={'pk': 999},
))
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_retrieve_address(self):
"""
Ensure we can retrieve an address.
"""
data = {
'id':
self.address.id,
'address_line1':
self.address.address_line1,
'postal_code':
self.address.postal_code,
'city':
self.address.city,
'state_province':
dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code,
),
'country':
dict(
name=self.random_country.name,
iso_code=self.random_country.iso_code,
),
}
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'location:addresses_id',
kwargs={'pk': self.address.id},
))
data['address_line2'] = ''
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_address_with_permission(self):
"""
Ensure we can update a specific address.
"""
data = {
'id':
self.address.id,
'address_line1':
self.address.address_line1,
'address_line2':
"Add second line",
'postal_code':
self.address.postal_code,
'city':
self.address.city,
'state_province':
dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code,
),
'country':
dict(
name=self.random_country.name,
iso_code=self.random_country.iso_code,
),
}
data_post = {
'id': self.address.id,
'address_line1': self.address.address_line1,
'address_line2': "Add second line",
'postal_code': self.address.postal_code,
'city': self.address.city,
'state_province': self.random_state_province.iso_code,
'country': self.random_country.iso_code,
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'location:addresses_id',
kwargs={'pk': self.address.id},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_address_country(self):
"""
Ensure we can't update only the country of an address.
"""
Country.objects.create(name="New Country", iso_code="NC")
data_post = dict(
address_line1=self.address.address_line1,
postal_code=self.address.postal_code,
city=self.address.city,
state_province=self.random_state_province.iso_code,
country='NC',
)
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'location:addresses_id',
kwargs={'pk': self.address.id},
),
data_post,
format='json',
)
err = {'detail': 'The StateProvince should be linked to the Country'}
self.assertEqual(json.loads(response.content), err)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_update_address_without_permission(self):
"""
Ensure we can't update a specific address without permission.
"""
data_post = {
"address_line1": "my address",
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'location:addresses_id',
kwargs={'pk': self.address.id},
),
data_post,
format='json',
)
content = {'detail': "You are not authorized to update an address."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_address_that_doesnt_exist(self):
"""
Ensure we can't update a specific address if it doesn't exist.
"""
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'location:addresses_id',
kwargs={'pk': 9999},
),
data_post,
format='json',
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_address_with_permission(self):
"""
Ensure we can delete a specific address.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'location:addresses_id',
kwargs={'pk': self.address.id},
), )
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_address_without_permission(self):
"""
Ensure we can't delete a specific address without permission.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'location:addresses_id',
kwargs={'pk': self.address.id},
), )
content = {'detail': "You are not authorized to delete an address."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_address_that_doesnt_exist(self):
"""
Ensure we can't delete a specific address if it doesn't exist
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'location:addresses_id',
kwargs={'pk': 9999},
), )
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class CycleTests(APITestCase):
def setUp(self):
pass
def test_create_cycle(self):
"""
Ensure we can create a new cycle with just required arguments
"""
cycle = Cycle.objects.create(
name='my cycle'
)
self.assertEquals(cycle.name, 'my cycle')
def test_is_active_property_true(self):
"""
Ensure we have True if the cycle is active
"""
start_date = timezone.now()
end_date = start_date + timezone.timedelta(
minutes=100,
)
cycle = Cycle.objects.create(
name='my cycle',
start_date=start_date,
end_date=end_date,
)
start_date += timezone.timedelta(days=1)
end_date += timezone.timedelta(days=1)
cycle_2 = Cycle.objects.create(
name='my cycle',
start_date=start_date,
end_date=end_date,
)
# Event in progress
self.assertEqual(cycle.is_active, True)
# Event to come
self.assertEqual(cycle_2.is_active, True)
def test_is_active_property_false(self):
"""
Ensure we have False if the cycle is not active
"""
start_date = timezone.now()
end_date = start_date
cycle = Cycle.objects.create(
name='my cycle',
start_date=start_date,
end_date=end_date,
)
# Event has ended
self.assertEqual(cycle.is_active, False)
def test_str_method(self):
"""
Validate the string representation of cycles
"""
start_date = timezone.now()
end_date = start_date
cycle = Cycle.objects.create(
name='my cycle',
start_date=start_date,
end_date=end_date,
)
self.assertEqual(str(cycle), cycle.name)
def test_cycle_generate_report_data_error(self):
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.cycle = Cycle.objects.create(
name="my cycle",
)
self.task_type = TaskType.objects.create(
name="my tasktype",
)
event_start_date = timezone.now()
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=event_start_date,
end_date=event_start_date + timezone.timedelta(minutes=100),
)
self.participation = Participation.objects.create(
standby=True,
user=self.admin,
event=self.event,
)
self.event_2 = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=event_start_date,
end_date=event_start_date + timezone.timedelta(minutes=100),
)
self.participation_presence = Participation.objects.create(
standby=True,
user=self.admin,
event=self.event_2,
presence_status='P',
presence_duration_minutes=300,
)
# Test error case
test_data_error = {
'error':
'All of the Participations presence '
'status must be initialised.',
}
data = self.cycle.generate_participation_report_data()
self.assertEqual(data, test_data_error)
# Test normal case
self.participation.presence_status = 'A'
self.participation.save()
data = self.cycle.generate_participation_report_data()
test_data = {
self.admin.pk: {
'first_name': self.admin.first_name,
'last_name': self.admin.last_name,
'email': self.admin.email,
'total_time': 300,
}
}
self.assertEqual(data, test_data)
class CyclesIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.cycle = Cycle.objects.create(
name='Cycle 1',
start_date=timezone.now(),
end_date=timezone.now() + timezone.timedelta(minutes=100, ),
)
def test_retrieve_cycle_id_not_exist(self):
"""
Ensure we can't retrieve a cycle that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:cycles_id',
kwargs={'pk': 999},
))
content = {"detail": "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_retrieve_cycle(self):
"""
Ensure we can retrieve a cycle.
"""
start_date = self.cycle.start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.cycle.end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = {
"id": self.cycle.id,
"name": self.cycle.name,
"start_date": start_date,
"end_date": end_date,
}
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:cycles_id',
kwargs={'pk': self.cycle.id},
))
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_cycle_with_permission(self):
"""
Ensure we can update a specific cycle.
"""
start_date = self.cycle.start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.cycle.end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = {
"id": self.cycle.id,
"name": "my new_name",
"start_date": start_date,
"end_date": end_date,
}
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cycles_id',
kwargs={'pk': self.cycle.id},
),
data_post,
format='json',
)
self.assertEqual(json.loads(response.content), data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_cycle_without_permission(self):
"""
Ensure we can't update a specific cycle without permission.
"""
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'volunteer:cycles_id',
kwargs={'pk': self.cycle.id},
),
data_post,
format='json',
)
content = {'detail': "You are not authorized to update a cycle."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_cycle_that_doesnt_exist(self):
"""
Ensure we can't update a specific cycle if it doesn't exist.
"""
start_date = self.cycle.start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.cycle.end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data_post = {
"name": "my new_name",
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:cycles_id',
kwargs={'pk': 9999},
),
data_post,
format='json',
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_cycle_with_permission(self):
"""
Ensure we can delete a specific cycle.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:cycles_id',
kwargs={'pk': self.cycle.id},
), )
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_cycle_without_permission(self):
"""
Ensure we can't delete a specific cycle without permission.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:cycles_id',
kwargs={'pk': self.cycle.id},
), )
content = {'detail': "You are not authorized to delete a cycle."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_cycle_that_doesnt_exist(self):
"""
Ensure we can't delete a specific cycle if it doesn't exist
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:cycles_id',
kwargs={'pk': 9999},
), )
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class ParticipationTests(APITransactionTestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.cycle = Cycle.objects.create(name="my cycle", )
self.task_type = TaskType.objects.create(name="my tasktype", )
event_start_date = timezone.now()
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=event_start_date,
end_date=event_start_date + timezone.timedelta(minutes=100),
)
self.participation = Participation.objects.create(
standby=True,
user=self.admin,
event=self.event,
)
self.event_2 = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=event_start_date,
end_date=event_start_date + timezone.timedelta(minutes=100),
)
self.participation_presence = Participation.objects.create(
standby=True,
user=self.admin,
event=self.event_2,
presence_status='P',
presence_duration_minutes=300,
)
def test_create_participation(self):
"""
Ensure we can create a new participation with just required arguments
"""
subscription_date = timezone.now()
with mock.patch('django.utils.timezone.now') as mock_now:
mock_now.return_value = subscription_date
participation = Participation.objects.create(
standby=True,
user=self.user,
event=self.event,
)
self.assertEqual(participation.standby, True)
self.assertEqual(participation.subscription_date, subscription_date)
self.assertEqual(participation.user.id, self.user.id)
self.assertEqual(participation.event.id, self.event.id)
def test_create_participation_missing_event(self):
"""
Ensure we can't create a new participation without required event
"""
subscription_date = timezone.now()
self.assertRaises(
IntegrityError,
Participation.objects.create,
standby=True,
subscription_date=subscription_date,
user=self.user,
)
def test_create_participation_missing_user(self):
"""
Ensure we can't create a new participation without required user
"""
subscription_date = timezone.now()
self.assertRaises(
IntegrityError,
Participation.objects.create,
standby=True,
subscription_date=subscription_date,
event=self.event,
)
def test_create_participation_missing_standby(self):
"""
Ensure we can't create a new participation without required standby
"""
subscription_date = timezone.now()
self.assertRaises(
IntegrityError,
Participation.objects.create,
subscription_date=subscription_date,
user=self.user,
event=self.event,
)
def test_start_date_property(self):
"""
Check start_date property
"""
self.assertEqual(self.participation.start_date,
self.participation.event.start_date)
def test_end_date_property(self):
"""
Check end_date property
"""
self.assertEqual(self.participation.end_date,
self.participation.event.end_date)
def test_cell_property(self):
"""
Check cell property
"""
self.assertEqual(self.participation.cell,
self.participation.event.cell.name)
def test_duration_from_model(self):
"""
Check duration
"""
self.assertEqual(self.participation_presence.duration,
timedelta(minutes=300))
def test_duration_from_event_property(self):
"""
Check duration
"""
self.assertEqual(self.participation.duration, timedelta(0, 6000))
def test_name(self):
self.assertIsNot(self.participation.__str__, None)
class AddressesTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.random_country2 = Country.objects.create(
name="random country",
iso_code="R2",
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
def test_create_new_address_with_permission(self):
"""
Ensure we can create a new address if we have the permission.
"""
data = dict(
address_line1='random address 2',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province.iso_code,
country=self.random_country.iso_code,
)
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('location:addresses'),
data,
format='json',
)
data['address_line2'] = ''
data['state_province'] = dict(
name=self.random_state_province.name,
iso_code=self.random_state_province.iso_code
)
data['country'] = dict(
name=self.random_country.name,
iso_code=self.random_country.iso_code
)
res = json.loads(response.content)
del res['id']
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(res, data)
def test_create_new_address_incorrect_state_province(self):
"""
Ensure we can't create a new address if the StateProvince is not
in the Country.
"""
data = dict(
address_line1='random address 2',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province.iso_code,
country=self.random_country2.iso_code,
)
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('location:addresses'),
data,
format='json',
)
res = json.loads(response.content)
err = {
'detail': 'The StateProvince should be linked to the Country'
}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(res, err)
def test_create_new_address_without_permission(self):
"""
Ensure we can't create a new address if we don't have the permission.
"""
data = dict(
address_line1='random address 1',
postal_code='random postal',
city='random city',
state_province=self.random_state_province.name,
country=self.random_country.name,
)
self.client.force_authenticate(user=self.user)
response = self.client.post(
reverse('location:addresses'),
data,
format='json',
)
content = {"detail": "You are not authorized to create a new address."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_list_address(self):
"""
Ensure we can list all addresses.
"""
data = [
dict(
id=self.address.id,
address_line1='random address 1',
address_line2='',
postal_code='RAN DOM',
city='random city',
state_province=dict(
iso_code=self.random_state_province.iso_code,
name=self.random_state_province.name,
),
country=dict(
iso_code=self.random_country.iso_code,
name=self.random_country.name,
),
),
]
self.client.force_authenticate(user=self.user)
response = self.client.get(reverse('location:addresses'))
self.assertEqual(json.loads(response.content)['results'], data)
self.assertEqual(json.loads(response.content)['count'], 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class EventsTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.user_cell_manager = UserFactory()
self.user_cell_manager.set_password('Test123!')
self.user_cell_manager.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.second_cell = Cell.objects.create(
name="my second cell",
address=self.address,
)
self.cell_with_manager = Cell.objects.create(
name="my cell with manager",
address=self.address,
)
self.cell_with_manager.save()
self.cell_with_manager.managers = [self.user_cell_manager, ]
self.cell_with_manager.save()
self.cycle = Cycle.objects.create(
name="my cycle",
)
self.task_type = TaskType.objects.create(
name="my tasktype",
)
start_date = timezone.now() - timezone.timedelta(
minutes=100,
)
end_date = start_date + timezone.timedelta(
minutes=50,
)
self.cycle_inactive = Cycle.objects.create(
name="my cycle",
start_date=start_date,
end_date=end_date
)
# Some date INSIDE the cycle range
start_date = start_date + timezone.timedelta(
minutes=2,
)
end_date = end_date - timezone.timedelta(
minutes=1,
)
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event_second_cell = Event.objects.create(
cell=self.second_cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event_inactive = Event.objects.create(
cell=self.cell,
cycle=self.cycle_inactive,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event_inactive_second_cel = Event.objects.create(
cell=self.second_cell,
cycle=self.cycle_inactive,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event_with_manager = Event.objects.create(
cell=self.cell_with_manager,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
# Decrement start_date for event_2
start_date = start_date - timezone.timedelta(
minutes=1,
)
self.event_2 = Event.objects.create(
cell=self.cell,
cycle=self.cycle_inactive,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
self.event_2 = Event.objects.create(
cell=self.second_cell,
cycle=self.cycle_inactive,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
def test_create_new_event_with_permission(self):
"""
Ensure we can create a new event if we have the permission.
"""
start_date = timezone.now()
end_date = start_date + timezone.timedelta(
minutes=100,
)
start_date_str = start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date_str = end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = {
'cell_id': self.cell.id,
'cycle_id': self.cycle.id,
'task_type_id': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content['start_date'], start_date_str)
self.assertEqual(content['end_date'], end_date_str)
self.assertEqual(content['cycle']['id'], self.cycle.id)
self.assertEqual(content['cell']['id'], self.cell.id)
self.assertEqual(content['task_type']['id'], self.task_type.id)
self.assertEqual(content['nb_volunteers_needed'], 0)
self.assertEqual(content['nb_volunteers_standby_needed'], 0)
self.assertEqual(content['nb_volunteers'], 0)
self.assertEqual(content['nb_volunteers_standby'], 0)
# Check the system doesn't return attributes not expected
attributes = ['id', 'start_date', 'end_date', 'nb_volunteers_needed',
'nb_volunteers_standby_needed', 'volunteers', 'cell',
'cycle', 'task_type', 'nb_volunteers_standby',
'nb_volunteers']
for key in content.keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
def test_create_new_event_with_cell_manager_permission(self):
"""
Ensure we can create a new event if we have the permission.
"""
start_date = timezone.now()
end_date = start_date + timezone.timedelta(
minutes=100,
)
start_date_str = start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date_str = end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = {
'cell_id': self.cell_with_manager.id,
'cycle_id': self.cycle.id,
'task_type_id': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.user_cell_manager)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content['start_date'], start_date_str)
self.assertEqual(content['end_date'], end_date_str)
self.assertEqual(content['cycle']['id'], self.cycle.id)
self.assertEqual(content['cell']['id'], self.cell_with_manager.id)
self.assertEqual(content['task_type']['id'], self.task_type.id)
self.assertEqual(content['nb_volunteers_needed'], 0)
self.assertEqual(content['nb_volunteers_standby_needed'], 0)
self.assertEqual(content['nb_volunteers'], 0)
self.assertEqual(content['nb_volunteers_standby'], 0)
# Check the system doesn't return attributes not expected
attributes = ['id', 'start_date', 'end_date', 'nb_volunteers_needed',
'nb_volunteers_standby_needed', 'volunteers', 'cell',
'cycle', 'task_type', 'nb_volunteers_standby',
'nb_volunteers']
for key in content.keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
def test_create_new_event_with_start_date_outside_cycle(self):
"""
Ensure we can't create a new event if start_date is outside
the cycle specified.
"""
start_date = self.cycle_inactive.start_date - timezone.timedelta(
minutes=100,
)
end_date = self.cycle_inactive.end_date - timezone.timedelta(
minutes=1,
)
data = {
'cell_id': self.cell.id,
'cycle_id': self.cycle_inactive.id,
'task_type_id': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
content = {
'non_field_errors': [
'Start date need to be after start date of the cycle.'
]
}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(json.loads(response.content), content)
def test_create_new_event_with_end_date_outside_cycle(self):
"""
Ensure we can't create a new event if end_date is outside
the cycle specified.
"""
start_date = self.cycle_inactive.start_date + timezone.timedelta(
minutes=1,
)
end_date = self.cycle_inactive.end_date + timezone.timedelta(
minutes=100,
)
data = {
'cell_id': self.cell.id,
'cycle_id': self.cycle_inactive.id,
'task_type_id': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
content = {
'non_field_errors': [
'End date need to be before the end date of the cycle.'
]
}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(json.loads(response.content), content)
def test_create_new_event_with_both_date_outside_cycle(self):
"""
Ensure we can't create a new event if both dates are outside
the cycle specified.
"""
start_date = self.cycle_inactive.start_date - timezone.timedelta(
minutes=100,
)
end_date = self.cycle_inactive.end_date + timezone.timedelta(
minutes=100,
)
data = {
'cell_id': self.cell.id,
'cycle_id': self.cycle_inactive.id,
'task_type_id': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
content = {
'non_field_errors': [
'Start date need to be after start date of the cycle.'
]
}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(json.loads(response.content), content)
def test_create_new_event_with_start_date_after_end_date(self):
"""
Ensure we can't create a new event if a start_date after end_date.
"""
end_date = self.cycle_inactive.start_date + timezone.timedelta(
minutes=1,
)
start_date = self.cycle_inactive.end_date - timezone.timedelta(
minutes=1,
)
data = {
'cell_id': self.cell.id,
'cycle_id': self.cycle_inactive.id,
'task_type_id': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
content = {
'non_field_errors': [
'Start date need to be before the end date.'
]
}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(json.loads(response.content), content)
def test_create_new_event_without_permission(self):
"""
Ensure we can't create a new event if we don't have the permission.
"""
start_date = timezone.now()
end_date = start_date + timezone.timedelta(
minutes=100,
)
data = {
'cell': self.cell.id,
'cycle': self.cycle.id,
'task_type': self.task_type.id,
'start_date': start_date,
'end_date': end_date,
}
self.client.force_authenticate(user=self.user)
response = self.client.post(
reverse('volunteer:events'),
data,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
content = {"detail": "You are not authorized to create a new event."}
self.assertEqual(json.loads(response.content), content)
def test_list_events_with_permissions(self):
"""
Ensure we can list all events. (ordered by start_date by default)
"""
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('volunteer:events'),
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 7)
# Check the system doesn't return attributes not expected
attributes = ['id', 'start_date', 'end_date', 'nb_volunteers_needed',
'nb_volunteers_standby_needed', 'volunteers', 'cell',
'cycle', 'task_type', 'nb_volunteers_standby',
'nb_volunteers']
for key in content['results'][0].keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
# Make sure the events are ordered in ascending start_date
self.assertTrue(
content['results'][0]['start_date'] <=
content['results'][1]['start_date']
)
self.assertTrue(
content['results'][0]['start_date'] <=
content['results'][2]['start_date']
)
self.assertTrue(
content['results'][1]['start_date'] <=
content['results'][2]['start_date']
)
def test_list_events_filter_by_cycle(self):
"""
Ensure we can list event filtered by cycle.
"""
self.client.force_authenticate(user=self.admin)
url = "{0}?cycle={1}".format(
reverse('volunteer:events'),
self.cycle_inactive.id,
)
response = self.client.get(
url,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 4)
# Check the system doesn't return attributes not expected
attributes = ['id', 'start_date', 'end_date', 'nb_volunteers_needed',
'nb_volunteers_standby_needed', 'volunteers', 'cell',
'cycle', 'task_type', 'nb_volunteers_standby',
'nb_volunteers']
for key in content['results'][0].keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
def test_list_events_filter_by_cell(self):
"""
Ensure we can list event filtered by cycle.
"""
self.client.force_authenticate(user=self.admin)
url = "{0}?cell={1}".format(
reverse('volunteer:events'),
self.cell.id,
)
response = self.client.get(
url,
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 3)
def test_list_events_without_permissions(self):
"""
Ensure we can list only active event (is_active property)
if we don't have some permissions.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse('volunteer:events'),
format='json',
)
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(content['count'], 3)
# Check the system doesn't return attributes not expected
attributes = ['id', 'start_date', 'end_date', 'nb_volunteers_needed',
'nb_volunteers_standby_needed', 'volunteers', 'cell',
'cycle', 'task_type', 'nb_volunteers_standby',
'nb_volunteers']
for key in content['results'][0].keys():
self.assertTrue(
key in attributes,
'Attribute "{0}" is not expected but is '
'returned by the system.'.format(key),
)
attributes.remove(key)
# Ensure the system returns all expected attributes
self.assertTrue(
len(attributes) == 0,
'The system failed to return some '
'attributes : {0}'.format(attributes),
)
class EventsIdTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="random country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="random state",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name="my cell",
address=self.address,
)
self.second_cell = Cell.objects.create(
name="my second cell",
address=self.address,
)
self.cycle = Cycle.objects.create(
name="my cycle",
)
self.second_cycle = Cycle.objects.create(
name="my second cycle",
)
self.task_type = TaskType.objects.create(
name="my tasktype",
)
self.second_task_type = TaskType.objects.create(
name="my second tasktype",
)
start_date = timezone.now()
end_date = start_date + timezone.timedelta(
minutes=100,
)
self.event = Event.objects.create(
cell=self.cell,
cycle=self.cycle,
task_type=self.task_type,
start_date=start_date,
end_date=end_date,
)
def test_retrieve_event_id_not_exist(self):
"""
Ensure we can't retrieve an event that doesn't exist.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:events_id',
kwargs={'pk': 999},
),
format='json',
)
content = {"detail": "Not found."}
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(json.loads(response.content), content)
def test_retrieve_event(self):
"""
Ensure we can retrieve an event.
"""
self.client.force_authenticate(user=self.user)
response = self.client.get(
reverse(
'volunteer:events_id',
kwargs={'pk': self.event.id},
)
)
result = json.loads(response.content)
self.assertEqual(result['id'], self.event.id)
self.assertEqual(result['cell']['id'], self.event.cell.id)
self.assertEqual(result['cycle']['id'], self.event.cycle.id)
self.assertEqual(result['task_type']['id'], self.event.task_type.id)
self.assertEqual(
result['nb_volunteers_needed'],
self.event.nb_volunteers_needed
)
self.assertEqual(
result['nb_volunteers_standby_needed'],
self.event.nb_volunteers_standby_needed
)
self.assertEqual(
result['nb_volunteers'],
self.event.nb_volunteers
)
self.assertEqual(
result['nb_volunteers_standby'],
self.event.nb_volunteers_standby
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_event_with_permission(self):
"""
Ensure we can update a specific event.
"""
data_post = {
"nb_volunteers_needed": 10,
"cell_id": self.second_cell.id,
"cycle_id": self.second_cycle.id,
"task_type_id": self.second_task_type.id,
}
self.admin.is_superuser = True
self.admin.save()
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:events_id',
kwargs={'pk': self.event.id},
),
data_post,
format='json',
)
result = json.loads(response.content)
self.assertEqual(result['id'], self.event.id)
self.assertEqual(
result['cell']['id'],
self.second_cell.id,
)
self.assertEqual(
result['cycle']['id'],
self.second_cycle.id,
)
self.assertEqual(
result['task_type']['id'],
self.second_task_type.id,
)
self.assertEqual(result['nb_volunteers_needed'], 10)
self.assertEqual(
result['nb_volunteers_standby_needed'],
self.event.nb_volunteers_standby_needed,
)
self.assertEqual(
result['nb_volunteers'],
self.event.nb_volunteers
)
self.assertEqual(
result['nb_volunteers_standby'],
self.event.nb_volunteers_standby
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_event_without_permission(self):
"""
Ensure we can't update a specific event without permission.
"""
data_post = {
"nb_volunteers_needed": 10,
}
self.client.force_authenticate(user=self.user)
response = self.client.patch(
reverse(
'volunteer:events_id',
kwargs={'pk': self.event.id},
),
data_post,
format='json',
)
content = {
'detail': 'You do not have permission to perform this action.'
}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_update_event_that_doesnt_exist(self):
"""
Ensure we can't update a specific event if it doesn't exist.
"""
data_post = {
"nb_volunteers_needed": 10,
}
self.client.force_authenticate(user=self.admin)
response = self.client.patch(
reverse(
'volunteer:events_id',
kwargs={'pk': 9999},
),
data_post,
format='json',
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_delete_event_with_permission(self):
"""
Ensure we can delete a specific event.
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:events_id',
kwargs={'pk': self.event.id},
),
)
self.assertEqual(response.content, b'')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_delete_event_without_permission(self):
"""
Ensure we can't delete a specific event without permission.
"""
self.client.force_authenticate(user=self.user)
response = self.client.delete(
reverse(
'volunteer:events_id',
kwargs={'pk': self.event.id},
),
)
content = {
'detail': 'You do not have permission to perform this action.'
}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_delete_event_that_doesnt_exist(self):
"""
Ensure we can't delete a specific event if it doesn't exist
"""
self.client.force_authenticate(user=self.admin)
response = self.client.delete(
reverse(
'volunteer:events_id',
kwargs={'pk': 9999},
),
)
content = {'detail': "Not found."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
class CyclesTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.cycle = Cycle.objects.create(
name='Cycle 1',
start_date=timezone.now(),
end_date=timezone.now() + timezone.timedelta(minutes=100, ),
)
self.past_cycle = Cycle.objects.create(
name='Cycle 2',
start_date=timezone.now() - timezone.timedelta(days=10, ),
end_date=timezone.now(),
)
def test_create_new_cycle_with_permission(self):
"""
Ensure we can create a new cycle if we have the permission.
"""
data = {
'name': 'Cycle 3',
'start_date': timezone.now(),
'end_date': timezone.now() + timezone.timedelta(minutes=100, ),
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cycles'),
data,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_create_new_cycle_without_permission(self):
"""
Ensure we can't create a new cycle if we don't have the permission.
"""
data = {
'name': 'Cycle 3',
'start_date': timezone.now(),
'end_date': timezone.now() + timezone.timedelta(minutes=100),
}
self.client.force_authenticate(user=self.user)
response = self.client.post(
reverse('volunteer:cycles'),
data,
format='json',
)
content = {"detail": "You are not authorized to create a new cycle."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_list_cycle(self):
"""
Ensure we can list all cycles.
"""
start_date = self.cycle.start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.cycle.end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = {
"id": self.cycle.id,
"name": self.cycle.name,
"start_date": start_date,
"end_date": end_date,
}
self.client.force_authenticate(user=self.user)
response = self.client.get(reverse('volunteer:cycles'))
self.assertEqual(json.loads(response.content)['results'][0], data)
self.assertEqual(json.loads(response.content)['count'], 2)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_list_cycle_when_is_active_true(self):
start_date = self.cycle.start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.cycle.end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = [{
"id": self.cycle.id,
"name": self.cycle.name,
"start_date": start_date,
"end_date": end_date,
}]
self.client.force_authenticate(user=self.user)
url = "{0}?is_active=True".format(reverse('volunteer:cycles'))
response = self.client.get(url)
self.assertEqual(json.loads(response.content)['results'], data)
self.assertEqual(json.loads(response.content)['count'], 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_list_cycle_when_is_active_false(self):
start_date = self.past_cycle.start_date\
.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.past_cycle.end_date\
.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = [{
"id": self.past_cycle.id,
"name": self.past_cycle.name,
"start_date": start_date,
"end_date": end_date,
}]
self.client.force_authenticate(user=self.user)
url = "{0}?is_active=False".format(reverse('volunteer:cycles'))
response = self.client.get(url)
self.assertEqual(json.loads(response.content)['count'], 1)
self.assertEqual(json.loads(response.content)['results'], data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_list_cycle_when_is_active_bad_input(self):
start_date = self.cycle.start_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
end_date = self.cycle.end_date.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
data = {
"id": self.cycle.id,
"name": self.cycle.name,
"start_date": start_date,
"end_date": end_date,
}
self.client.force_authenticate(user=self.user)
# 'bad' is not a good input
url = "{0}?is_active=bad".format(reverse('volunteer:cycles'))
response = self.client.get(url)
self.assertEqual(json.loads(response.content)['results'][0], data)
self.assertEqual(json.loads(response.content)['count'], 2)
self.assertEqual(response.status_code, status.HTTP_200_OK)
class CellsTests(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = UserFactory()
self.user.set_password('Test123!')
self.user.save()
self.admin = AdminFactory()
self.admin.set_password('Test123!')
self.admin.save()
self.random_country = Country.objects.create(
name="Random Country",
iso_code="RC",
)
self.random_state_province = StateProvince.objects.create(
name="Random State",
iso_code="RS",
country=self.random_country,
)
self.address = Address.objects.create(
address_line1='random address 1',
postal_code='RAN DOM',
city='random city',
state_province=self.random_state_province,
country=self.random_country,
)
self.cell = Cell.objects.create(
name='my cell',
address=self.address,
)
def test_create_new_cell_with_permission(self):
"""
Ensure we can create a new cell if we have the permission.
The Address, Country and StateProvince do not exist in the DB.
"""
data_post = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'NS',
'name': 'New State',
},
'country': {
'iso_code': 'NC',
'name': 'New Country',
},
},
'managers': [
self.user.id,
],
}
data = {
'name':
'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'NS',
'name': 'New State',
},
'country': {
'iso_code': 'NC',
'name': 'New Country',
},
},
'managers': [
{
'id': self.user.id,
'username': self.user.username,
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'email': self.user.email,
},
],
}
self.assertRaises(
Address.DoesNotExist, Address.objects.get, **{
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city'
})
self.assertRaises(Country.DoesNotExist, Country.objects.get,
**data_post['address']['country'])
self.assertRaises(StateProvince.DoesNotExist,
StateProvince.objects.get,
**data_post['address']['state_province'])
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data_post,
format='json',
)
content = json.loads(response.content)
del content['id']
del content['address']['id']
data['address']['address_line2'] = ''
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content, data)
def test_create_new_cell_existing_address_different_country(self):
"""
Ensure we can create a new cell if we have the permission.
The Address already exists but the Country and StateProvince are
different.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "random address 1",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'NS',
'name': 'New State',
},
'country': {
'iso_code': 'NC',
'name': 'New Country',
},
},
'managers': [],
}
self.assertRaises(Country.DoesNotExist, Country.objects.get,
**data['address']['country'])
self.assertRaises(StateProvince.DoesNotExist,
StateProvince.objects.get,
**data['address']['state_province'])
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = json.loads(response.content)
del content['id']
del content['address']['id']
data['address']['address_line2'] = ''
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content, data)
def test_create_new_cell_existing_country(self):
"""
Ensure we can create a new cell if we have the permission.
The Country already exist in the DB.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'NS',
'name': 'New State',
},
'country': {
'iso_code': 'RC',
'name': 'Random Country',
},
},
'managers': [],
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = json.loads(response.content)
del content['id']
del content['address']['id']
data['address']['address_line2'] = ''
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content, data)
def test_create_new_cell_existing_state_province(self):
"""
Ensure we can create a new cell if we have the permission.
The Country and StateProvince already exist in the DB.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'RS',
'name': 'Random State',
},
'country': {
'iso_code': 'RC',
'name': 'Random Country',
},
},
'managers': [],
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = json.loads(response.content)
del content['id']
del content['address']['id']
data['address']['address_line2'] = ''
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content, data)
def test_create_new_cell_existing_address(self):
"""
Ensure we can create a new cell if we have the permission.
The Address, Country and StateProvince already exist in the DB.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "random address 1",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'RS',
'name': 'Random State',
},
'country': {
'iso_code': 'RC',
'name': 'Random Country',
},
},
'managers': [],
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = json.loads(response.content)
del content['id']
del content['address']['id']
data['address']['address_line2'] = ''
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(content, data)
def test_create_new_cell_with_inexistent_country(self):
"""
Ensure we can't create a new cell if the state_province already exist
and is not in the country.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': { # Already associated with a country
'iso_code': 'RS',
'name': 'Random State',
},
'country': { # New country NOT containing the state_province
'iso_code': 'NC',
'name': 'not created',
},
},
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
err = {'message': 'A StateProvince with that iso_code already exists'}
content = json.loads(response.content)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(content, err)
def test_create_new_cell_with_duplicate_state_province(self):
"""
Ensure we can't create a new cell if the state_province iso_code
is already associated to another state_province.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'RS',
'name': 'Random State 2',
},
'country': {
'iso_code': 'NC',
'name': 'not created',
},
},
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = json.loads(response.content)
err = {'message': 'A StateProvince with that iso_code already exists'}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(content, err)
def test_create_new_cell_with_duplicate_country(self):
"""
Ensure we can't create a new cell if the country iso_code
is already associated to another country.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'RA',
'name': 'Random State 2',
},
'country': {
'iso_code': 'RC',
'name': 'Random Country Dup',
},
},
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = json.loads(response.content)
err = {'message': 'A Country with that iso_code already exists'}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(content, err)
def test_create_new_cell_without_permission(self):
"""
Ensure we can't create a new cell if we don't have the permission.
"""
data = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': 'RS',
'country': 'RC',
},
}
self.client.force_authenticate(user=self.user)
response = self.client.post(
reverse('volunteer:cells'),
data,
format='json',
)
content = {"detail": "You are not authorized to create a new cell."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_list_cell(self):
"""
Ensure we can list all cells.
"""
data = [{
'id': self.cell.id,
'name': self.cell.name,
'address': {
'id': self.address.id,
'address_line1': self.address.address_line1,
'address_line2': self.address.address_line2,
'postal_code': self.address.postal_code,
'city': self.address.city,
'state_province': {
'iso_code': self.random_state_province.iso_code,
'name': self.random_state_province.name,
},
'country': {
'iso_code': self.random_country.iso_code,
'name': self.random_country.name,
},
},
"managers": [],
}]
self.client.force_authenticate(user=self.user)
response = self.client.get(reverse('volunteer:cells'))
response_parsed = json.loads(response.content)
self.assertEqual(response_parsed['results'], data)
self.assertEqual(response_parsed['count'], 1)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_create_new_cell_with_bad_manager(self):
"""
Ensure we can't create a new cell with a bad idea of manager
"""
data_post = {
'name': 'Cell 3',
'address': {
'address_line1': "my address",
'postal_code': "RAN DOM",
'city': 'random city',
'state_province': {
'iso_code': 'NS',
'name': 'New State',
},
'country': {
'iso_code': 'NC',
'name': 'New Country',
},
},
'managers': [
7812,
],
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
reverse('volunteer:cells'),
data_post,
format='json',
)
content = json.loads(response.content)
error = {'message': 'Unknown user with this ID'}
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(content, error)
def test_cell_list_ordering(self):
self.cell_2 = Cell.objects.create(
name='AAA Cell',
address=self.address,
)
self.client.force_authenticate(user=self.admin)
response = self.client.get(
reverse('volunteer:cells'),
format='json',
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['results'][0]['name'], 'my cell')
self.assertEqual(response.data['results'][1]['name'], 'AAA Cell')
url_ordered = '%s?ordering=name' % reverse('volunteer:cells')
response = self.client.get(
url_ordered,
format='json',
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['results'][0]['name'], 'AAA Cell')
self.assertEqual(response.data['results'][1]['name'], 'my cell')