def test_cancel_outage(self):
# create outage
start = datetime.now()
end = start + timedelta(hours=1)
data = self.get_outage_data(title="Outage", start=start, end=end, tool_name=tool.name)
login_as_staff(self.client)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 200)
outage = ScheduledOutage.objects.get(title="Outage")
self.assertTrue(outage.id)
# regular user should not be able to delete outage
login_as_user(self.client)
response = self.client.get(reverse('cancel_outage', kwargs={'outage_id': 999}), {}, follow=True)
test_response_is_landing_page(self, response)
self.assertTrue(ScheduledOutage.objects.get(pk=outage.id).id, outage.id)
login_as_staff(self.client)
# get should fail
response = self.client.get(reverse('cancel_outage', kwargs={'outage_id': 999}), {}, follow=True)
self.assertEquals(response.status_code, 405)
# test wrong id
response = self.client.post(reverse('cancel_outage', kwargs={'outage_id':999}), {}, follow=True)
self.assertEquals(response.status_code, 404)
response = self.client.post(reverse('cancel_outage', kwargs={'outage_id': outage.id}), {}, follow=True)
self.assertEquals(response.status_code, 200)
self.assertEquals(ScheduledOutage.objects.all().count(), 0)
def test_farewell_screen_fails(self):
response = self.client.post(reverse('farewell_screen',
kwargs={'door_id': door.id}),
follow=True)
test_response_is_failed_login(self, response)
login_as_user(self.client)
response = self.client.post(reverse('farewell_screen',
kwargs={'door_id': door.id}),
follow=True)
test_response_is_landing_page(
self,
response) # landing since we don't have the right credentials
login_as_user_with_permissions(self.client,
['change_areaaccessrecord'])
response = self.client.post(reverse('farewell_screen',
kwargs={'door_id': door.id}),
follow=True)
self.assertEqual(response.status_code,
405) # POST isn't accepted, only GET
response = self.client.get(reverse('farewell_screen',
kwargs={'door_id': 999}),
follow=True)
self.assertEqual(response.status_code, 404) # wrong door id
response = self.client.get(reverse('farewell_screen',
kwargs={'door_id': door.id}),
follow=True)
self.assertEqual(response.status_code, 200) # All good now
self.assertTrue("farewell_screen" in response.request['PATH_INFO'])
def test_reservation_details(self):
# create reservation
start = datetime.now() + timedelta(hours=1)
end = start + timedelta(hours=1)
data = self.get_reservation_data(start, end, area)
login_as(self.client, consumer)
response = self.client.post(reverse('create_reservation'),
data,
follow=True)
self.assertEquals(response.status_code, 200)
reservation = Reservation.objects.get(area=area)
self.assertTrue(reservation.id)
# anybody that is logged in can see reservation details
login_as_user(self.client)
# post should fail
response = self.client.post(reverse('reservation_details',
kwargs={'reservation_id': 999}),
{},
follow=True)
self.assertEquals(response.status_code, 405)
# test wrong id
response = self.client.get(reverse('reservation_details',
kwargs={'reservation_id': 999}), {},
follow=True)
self.assertEquals(response.status_code, 404)
response = self.client.get(
reverse('reservation_details',
kwargs={'reservation_id': reservation.id}), {},
follow=True)
self.assertEquals(response.status_code, 200)
def test_calendar_urls(self):
# if not logged in, it should send an error message
response = self.client.get(reverse('calendar'), follow=True)
test_response_is_failed_login(self, response)
login_as_user(self.client)
response = self.client.get(reverse('calendar'), follow=True)
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse('calendar', kwargs={'tool_id': tool.id}), follow=True)
self.assertEqual(response.status_code, 200)
def test_resize_outage(self):
# create outage
start = datetime.now()
end = start + timedelta(hours=1)
data = self.get_outage_data(title="Outage", start=start, end=end, tool_name=tool.name)
login_as_staff(self.client)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 200)
outage = ScheduledOutage.objects.get(title="Outage")
self.assertTrue(outage.id)
# regular user should not be able to resize outage
login_as_user(self.client)
response = self.client.get(reverse('resize_outage'), {}, follow=True)
test_response_is_landing_page(self, response)
self.assertTrue(ScheduledOutage.objects.get(pk=outage.id).id, outage.id)
# back to staff mode
login_as_staff(self.client)
# test wrong delta
response = self.client.post(reverse('resize_outage'), {'delta':'asd', 'id': outage.id}, follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.content.decode(), "Invalid delta")
# test no outage id
response = self.client.post(reverse('resize_outage'), {'delta': 10}, follow=True)
self.assertEquals(response.status_code, 404)
self.assertEquals(response.content.decode(), "The outage that you wish to modify doesn't exist!")
# test resize to less than original time
response = self.client.post(reverse('resize_outage'), {'delta': -60, 'id': outage.id}, follow=True)
self.assertEquals(response.status_code, 400)
self.assertTrue('Outage start time' in response.content.decode())
self.assertTrue('must be before the end time' in response.content.decode())
# create a reservation and try to resize outage to overlap reservation
start_reservation = end + timedelta(hours=1)
end_reservation = start_reservation + timedelta(hours=1)
Reservation.objects.create(user=owner, creator=owner, tool=tool, start=start_reservation, end=end_reservation, short_notice=False)
response = self.client.post(reverse('resize_outage'), {'delta': 61, 'id': outage.id}, follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.content.decode(), "Your scheduled outage coincides with a reservation that already exists. Please choose a different time.")
# test reduce outage time by 10 min
response = self.client.post(reverse('resize_outage'), {'delta': -10, 'id':outage.id}, follow=True)
self.assertEquals(response.status_code, 200)
self.assertEquals(ScheduledOutage.objects.get(pk=outage.id).end, outage.end - timedelta(minutes=10))
# test increase outage time by 10 min
outage = ScheduledOutage.objects.get(pk=outage.id)
response = self.client.post(reverse('resize_outage'), {'delta': 10, 'id': outage.id}, follow=True)
self.assertEquals(response.status_code, 200)
self.assertEquals(ScheduledOutage.objects.get(pk=outage.id).end, outage.end + timedelta(minutes=10))
def test_calendar_urls(self):
# if not logged in, it should redirect to login
response = self.client.get(reverse('calendar'), follow=True)
test_response_is_login_page(self, response)
login_as_user(self.client)
response = self.client.get(reverse('calendar'), follow=True)
self.assertEquals(response.status_code, 200)
response = self.client.get(reverse('calendar',
kwargs={'tool_id': tool.id}),
follow=True)
self.assertEquals(response.status_code, 200)
def test_tool_in_use(self):
user = login_as_user(self.client)
# make the tool operational
tool.operational = True
tool.save()
project = Project.objects.create(name="test project", application_identifier="sadasd", account=Account.objects.create(name="test account"))
user.projects.add(project)
# user needs to be qualified to use the tool
user.qualifications.add(tool)
user.physical_access_levels.add(PhysicalAccessLevel.objects.get(name="cleanroom access"))
user.badge_number = 11
user.training_required = False
user.save()
# log into the area
login_as_access_user(self.client)
response = self.client.post(reverse('login_to_area', kwargs={'door_id': area_door.id}), {'badge_number':user.badge_number}, follow=True)
self.assertEquals(response.status_code, 200, response.content.decode())
login_as(self.client, user)
# start using tool
response = self.client.post(reverse('enable_tool', kwargs={'tool_id':tool.id, 'user_id':user.id, 'project_id':project.id, 'staff_charge':'false'}), follow=True)
self.assertEquals(response.status_code, 200, response.content.decode())
# make sure both tool and child tool are "in use"
self.assertTrue(tool.in_use())
self.assertTrue(alternate_tool.in_use())
# make sure both return the same usage event
self.assertEquals(tool.get_current_usage_event(), alternate_tool.get_current_usage_event())
def test_outage_policy_problems(self):
start = datetime.now()
end = start - timedelta(hours=1)
data = self.get_outage_data(start=start, end=end, tool_name=tool.name)
# regular user should not be able to create outage
login_as_user(self.client)
response = self.client.get(reverse('create_outage'), {}, follow=True)
test_response_is_landing_page(self, response)
# back to staff mode
login_as_staff(self.client)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.content.decode(), "The request parameters have an end time that precedes the start time.")
# fix time
end = (start + timedelta(hours=1))
# Create a reservation and try to schedule an outage at the same time
Reservation.objects.create(user=owner, creator=owner, tool=tool, start=start, end=end, short_notice=False)
data = self.get_outage_data(start=start, end=end, tool_name=tool.name)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.content.decode(), "Your scheduled outage coincides with a reservation that already exists. Please choose a different time.")
# try to schedule an outage that starts before but ends slightly after the reservation starts
data = self.get_outage_data(start=start-timedelta(hours=1), end=end-timedelta(minutes=59), tool_name=tool.name)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.content.decode(), "Your scheduled outage coincides with a reservation that already exists. Please choose a different time.")
# try to schedule an outage that starts slightly before the reservation ends
data = self.get_outage_data(start=start + timedelta(minutes=59), end=end + timedelta(hours=1), tool_name=tool.name)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.content.decode(), "Your scheduled outage coincides with a reservation that already exists. Please choose a different time.")
# no title
start = start + timedelta(hours=2)
end = end + timedelta(hours=2)
data = self.get_outage_data(start=start, end=end, tool_name=tool.name)
response = self.client.post(reverse('create_outage'), data, follow=True)
self.assertEquals(response.status_code, 200) # response code valid but form is sent back. let's make sure the outage was indeed NOT created
self.assertEquals(ScheduledOutage.objects.all().count(), 0)
def outage_details(self, item_id: int, item_type: ReservationItemType):
# create outage
start = datetime.now()
end = start + timedelta(hours=1)
data = self.get_outage_data(title="Outage",
start=start,
end=end,
item_id=item_id,
item_type=item_type)
login_as_staff(self.client)
response = self.client.post(reverse('create_outage'),
data,
follow=True)
self.assertEqual(response.status_code, 200)
outage = ScheduledOutage.objects.get(title="Outage")
self.assertTrue(outage.id)
# anybody that is logged in can see outage details
login_as_user(self.client)
# post should fail
response = self.client.post(reverse('outage_details',
kwargs={'outage_id': 999}), {},
follow=True)
self.assertEqual(response.status_code, 405)
# test wrong id
response = self.client.get(reverse('outage_details',
kwargs={'outage_id': 999}), {},
follow=True)
self.assertEqual(response.status_code, 404)
response = self.client.get(reverse('outage_details',
kwargs={'outage_id': outage.id}),
{},
follow=True)
self.assertEqual(response.status_code, 200)
outage.delete()
def test_new_area_record_get(self):
user = login_as_user(self.client)
response = self.client.get(reverse('new_area_access_record'),
data={'customer': user.id},
follow=True)
test_response_is_landing_page(self, response)
staff = login_as_staff(self.client)
user.is_active = False
user.save()
response = self.client.get(reverse('new_area_access_record'),
data={'customer': user.id},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue("Oops! Something went wrong" in str(response.content))
self.assertTrue("is inactive"
in str(response.content)) # user is inactive
user.is_active = True
user.save()
response = self.client.get(reverse('new_area_access_record'),
data={'customer': user.id},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue("Oops! Something went wrong" in str(response.content))
self.assertTrue(
"does not have any active projects to bill area access"
in str(response.content)) # user does not have active projects
user.projects.add(
Project.objects.create(
name="Project1",
account=Account.objects.create(name="Account1")))
user.save()
response = self.client.get(reverse('new_area_access_record'),
data={'customer': user.id},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue("Oops! Something went wrong" in str(response.content))
self.assertTrue("does not have access to any billable NanoFab areas"
in str(response.content)) # user does not have access
user.physical_access_levels.add(
PhysicalAccessLevel.objects.create(
name="cleanroom access",
area=area,
schedule=PhysicalAccessLevel.Schedule.ALWAYS))
user.save()
response = self.client.get(reverse('new_area_access_record'),
data={'customer': user.id},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertFalse("Oops! Something went wrong" in str(response.content))
def test_login_to_area(self):
self.client.post(reverse('self_log_in'),
data={'area': area.id},
follow=True)
self.assertFalse(
AreaAccessRecord.objects.filter(area=area,
end__isnull=True).exists())
user = login_as_user(self.client)
self.client.post(reverse('self_log_in'),
data={'area': area.id},
follow=True)
self.assertFalse(
AreaAccessRecord.objects.filter(area=area,
end__isnull=True).exists())
Customization.objects.update_or_create(name='self_log_in',
defaults={'value': 'enabled'})
self.assertFalse(
AreaAccessRecord.objects.filter(area=area,
end__isnull=True).exists())
project = Project.objects.create(
name="Project1", account=Account.objects.create(name="Account1"))
user.projects.add(project)
user.save()
self.client.post(reverse('self_log_in'),
data={
'area': area.id,
'project': project.id
},
follow=True)
self.assertFalse(
AreaAccessRecord.objects.filter(
area=area,
end__isnull=True).exists()) # user doesn't have access
user.physical_access_levels.add(
PhysicalAccessLevel.objects.create(
name="cleanroom access",
area=area,
schedule=PhysicalAccessLevel.Schedule.ALWAYS))
user.save()
self.client.post(reverse('self_log_in'),
data={
'area': area.id,
'project': project.id
},
follow=True)
self.assertTrue(
AreaAccessRecord.objects.filter(area=area,
customer=user,
end__isnull=True).exists())
def move_outage(self, item_id: int, item_type: ReservationItemType):
# create outage
start = datetime.now()
end = start + timedelta(hours=1)
data = self.get_outage_data(title="Outage",
start=start,
end=end,
item_id=item_id,
item_type=item_type)
login_as_staff(self.client)
response = self.client.post(reverse('create_outage'),
data,
follow=True)
self.assertEqual(response.status_code, 200)
outage = ScheduledOutage.objects.get(title="Outage")
self.assertTrue(outage.id)
# regular user should not be able to move outage
login_as_user(self.client)
response = self.client.get(reverse('move_outage'), {}, follow=True)
test_response_is_landing_page(self, response)
self.assertTrue(
ScheduledOutage.objects.get(pk=outage.id).id, outage.id)
# back to staff mode
login_as_staff(self.client)
# test wrong delta
response = self.client.post(reverse('move_outage'), {
'delta': 'asd',
'id': outage.id
},
follow=True)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.content.decode(), "Invalid delta")
# test no outage id
response = self.client.post(reverse('move_outage'), {'delta': 10},
follow=True)
self.assertEqual(response.status_code, 404)
self.assertEqual(response.content.decode(),
"The outage that you wish to modify doesn't exist!")
# create a reservation and try to move outage to overlap reservation
start_reservation = end + timedelta(hours=1)
end_reservation = start_reservation + timedelta(hours=1)
if item_type == ReservationItemType.TOOL:
Reservation.objects.create(user=owner,
creator=owner,
tool=tool,
start=start_reservation,
end=end_reservation,
short_notice=False)
elif item_type == ReservationItemType.AREA:
Reservation.objects.create(user=owner,
creator=owner,
area=area,
start=start_reservation,
end=end_reservation,
short_notice=False)
response = self.client.post(reverse('move_outage'), {
'delta': 61,
'id': outage.id
},
follow=True)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.content.decode(),
"Your scheduled outage coincides with a reservation that already exists. Please choose a different time."
)
# test move outage 10 min earlier
response = self.client.post(reverse('move_outage'), {
'delta': -10,
'id': outage.id
},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(
ScheduledOutage.objects.get(pk=outage.id).end,
outage.end - timedelta(minutes=10))
self.assertEqual(
ScheduledOutage.objects.get(pk=outage.id).start,
outage.start - timedelta(minutes=10))
# test move outage 10 min later
outage = ScheduledOutage.objects.get(pk=outage.id)
response = self.client.post(reverse('move_outage'), {
'delta': 10,
'id': outage.id
},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(
ScheduledOutage.objects.get(pk=outage.id).end,
outage.end + timedelta(minutes=10))
self.assertEqual(
ScheduledOutage.objects.get(pk=outage.id).start,
outage.start + timedelta(minutes=10))
outage.delete()
def test_cancel_reservation(self):
# create reservation
start = datetime.now() + timedelta(hours=1)
end = start + timedelta(hours=1)
data = self.get_reservation_data(start, end, area)
login_as(self.client, consumer)
response = self.client.post(reverse('create_reservation'),
data,
follow=True)
self.assertEquals(response.status_code, 200)
reservation = Reservation.objects.get(area=area)
self.assertTrue(reservation.id)
# get should fail
response = self.client.get(reverse('cancel_reservation',
kwargs={'reservation_id': 999}), {},
follow=True)
self.assertEquals(response.status_code, 405)
# test wrong id
response = self.client.post(reverse('cancel_reservation',
kwargs={'reservation_id': 999}),
{},
follow=True)
self.assertEquals(response.status_code, 404)
# test non staff user trying to cancel reservation
login_as_user(self.client)
response = self.client.post(
reverse('cancel_reservation',
kwargs={'reservation_id': reservation.id}), {},
follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(
"You must provide a reason when cancelling someone else's reservation.",
response.content.decode())
response = self.client.post(reverse(
'cancel_reservation', kwargs={'reservation_id': reservation.id}),
{'reason': 'reason'},
follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(
"You may not cancel reservations that you do not own.",
response.content.decode())
login_as(self.client, consumer)
# test cancel missed reservation
missed_resa = Reservation.objects.create(area=area,
start=start +
timedelta(days=1),
end=end + timedelta(days=1),
user=consumer,
creator=consumer,
missed=True,
short_notice=False)
response = self.client.post(
reverse('cancel_reservation',
kwargs={'reservation_id': missed_resa.id}), {},
follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(
response.content.decode(),
"This reservation was missed and cannot be modified.")
# test cancel already ended reservation
already_ended_resa = Reservation.objects.create(
area=area,
start=start - timedelta(days=1),
end=end - timedelta(days=1),
user=consumer,
creator=consumer,
missed=False,
short_notice=False)
response = self.client.post(reverse(
'cancel_reservation',
kwargs={'reservation_id': already_ended_resa.id}), {},
follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(
response.content.decode(),
"You may not cancel reservations that have already ended.")
# test cancel reservation while logged in area
older_resa_still_ongoing = Reservation.objects.create(
area=area,
start=datetime.now() - timedelta(hours=1),
end=datetime.now() + timedelta(hours=1),
user=consumer,
creator=consumer,
missed=False,
short_notice=False)
AreaAccessRecord.objects.create(area=area,
customer=consumer,
start=datetime.now(),
project=project)
response = self.client.post(reverse(
'cancel_reservation',
kwargs={'reservation_id': older_resa_still_ongoing.id}), {},
follow=True)
self.assertEquals(response.status_code, 400)
self.assertEquals(
response.content.decode(),
"You may not cancel an area reservation while logged in that area."
)
# cancel reservation
response = self.client.post(
reverse('cancel_reservation',
kwargs={'reservation_id': reservation.id}), {},
follow=True)
self.assertEquals(response.status_code, 200)
self.assertTrue(Reservation.objects.get(pk=reservation.id).cancelled)
self.assertEquals(
Reservation.objects.get(pk=reservation.id).cancelled_by, consumer)
# test cancel already cancelled reservation
response = self.client.post(
reverse('cancel_reservation',
kwargs={'reservation_id': reservation.id}), {},
follow=True)
self.assertContains(response,
"This reservation has already been cancelled by ",
status_code=400)
# test staff cancelling somebody else's reservation
other_resa = Reservation.objects.create(area=area,
start=start -
timedelta(days=1),
end=end - timedelta(days=1),
user=consumer,
creator=consumer,
short_notice=False)
login_as(self.client, staff)
response = self.client.post(
reverse('cancel_reservation',
kwargs={'reservation_id': other_resa.id}), {},
follow=True)
self.assertContains(
response,
"You must provide a reason when cancelling someone else's reservation.",
status_code=400)
response = self.client.post(reverse(
'cancel_reservation', kwargs={'reservation_id': other_resa.id}),
{'reason': 'reason'},
follow=True)
self.assertEquals(response.status_code, 200)
self.assertTrue(Reservation.objects.get(pk=other_resa.id).cancelled)
self.assertEquals(
Reservation.objects.get(pk=other_resa.id).cancelled_by, staff)
def test_area_access_page_by_user(self):
login_as_user(self.client)
response = self.client.get(reverse('area_access'), {}, follow=True)
test_response_is_landing_page(
self,
response) # since user is not staff, it should redirect to landing
def test_login_to_area(self):
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
follow=True)
test_response_is_failed_login(self, response)
login_as_user(self.client)
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
follow=True)
test_response_is_landing_page(
self,
response) # landing since we don't have the right credentials
user = login_as_user_with_permissions(self.client,
['add_areaaccessrecord'])
response = self.client.get(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertEqual(response.status_code,
405) # GET isn't accepted, only POST
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': 999}),
follow=True)
self.assertEqual(response.status_code, 404) # wrong door id
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
follow=True)
self.assertContains(response, "Your badge wasn't recognized")
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': 999},
follow=True)
self.assertContains(response, "Your badge wasn't recognized")
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertContains(
response=response,
text="You are not a member of any active projects",
status_code=200) # user does not have active projects
user.projects.add(
Project.objects.create(
name="Project1",
account=Account.objects.create(name="Account1")))
user.save()
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertContains(response=response,
text="Physical access denied",
status_code=200) # user does not have access
user.physical_access_levels.add(
PhysicalAccessLevel.objects.create(
name="cleanroom access",
area=door.area,
schedule=PhysicalAccessLevel.Schedule.ALWAYS))
user.save()
door.area.maximum_capacity = 1
door.area.save()
# add a logged in person so capacity is reached
AreaAccessRecord.objects.create(
area=door.area,
customer=User.objects.create(username='******',
first_name='Test',
last_name='Staff',
is_staff=True,
badge_number=2222),
project=Project.objects.get(name="Project1"),
start=datetime.now())
staff = User.objects.create(username='******',
first_name='Test',
last_name='Staff',
is_staff=True,
badge_number=11111)
staff.projects.add(Project.objects.get(name="Project1"))
staff.physical_access_levels.add(
PhysicalAccessLevel.objects.get(name="cleanroom access"))
staff.save()
self.client.force_login(user=user)
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertContains(response,
"This area has reached its maximum capacity.")
# staff can still login
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': staff.badge_number},
follow=True)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertContains(response=response,
text="You're logged in to the ",
status_code=200)
self.assertTrue(
AreaAccessRecord.objects.filter(
area=door.area,
customer=User.objects.get(
badge_number=staff.badge_number)).exists())
# try again user, should fail
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertContains(response,
"This area has reached its maximum capacity.")
# increase capacity so user can login
door.area.maximum_capacity = 5
door.area.save()
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertContains(response=response,
text="You're logged in to the ",
status_code=200)
self.assertTrue(
AreaAccessRecord.objects.filter(
area=door.area,
customer=User.objects.get(
badge_number=user.badge_number)).exists())
def test_login_to_area(self):
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
follow=True)
test_response_is_login_page(self, response)
login_as_user(self.client)
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
follow=True)
test_response_is_landing_page(
self,
response) # landing since we don't have the right credentials
user = login_as_user_with_permissions(self.client,
['add_areaaccessrecord'])
response = self.client.get(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertEqual(response.status_code,
405) # GET isn't accepted, only POST
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': 999}),
follow=True)
self.assertEqual(response.status_code, 404) # wrong door id
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
follow=True)
self.assertTrue(
"Your badge wasn\\'t recognized" in str(response.content))
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': 999},
follow=True)
self.assertTrue(
"Your badge wasn\\'t recognized" in str(response.content))
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertTrue("You are not a member of any active projects" in str(
response.content)) # user does not have active projects
user.projects.add(
Project.objects.create(
name="Project1",
account=Account.objects.create(name="Account1")))
user.save()
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertTrue("Physical access denied"
in str(response.content)) # user does not have access
user.physical_access_levels.add(
PhysicalAccessLevel.objects.create(
name="cleanroom access",
area=door.area,
schedule=PhysicalAccessLevel.Schedule.ALWAYS))
user.save()
response = self.client.post(reverse('login_to_area',
kwargs={'door_id': door.id}),
data={'badge_number': user.badge_number},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(
f"login_to_area/{door.id}" in response.request['PATH_INFO'])
self.assertTrue("You're logged in to the " in str(response.content))
self.assertTrue(
AreaAccessRecord.objects.filter(
area=door.area,
customer=User.objects.get(
badge_number=user.badge_number)).exists())
