def test_fail_reserve_busy_resource(self):
c = Client()
other_user = self.test_data['users'][5]
c.login(username=other_user.username, password='******')
resource1 = self.test_data['resources'][2]
response = c.post('/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
colliding_reservations = [
(later(0.5), later(1.1)),
(later(1), later(2)),
(later(1.1), later(2.1)),
(later(1.9), later(2.1))]
for (start, end) in colliding_reservations:
response = self.client.post('/make_reservation/', {
'start': to_timestamp(start),
'end': to_timestamp(end),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 403)
def test_fail_reserve_busy_resource(self):
c = Client()
other_user = self.test_data['users'][5]
c.login(username=other_user.username, password='******')
resource1 = self.test_data['resources'][2]
response = c.post(
'/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
colliding_reservations = [(later(0.5), later(1.1)),
(later(1), later(2)),
(later(1.1), later(2.1)),
(later(1.9), later(2.1))]
for (start, end) in colliding_reservations:
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(start),
'end': to_timestamp(end),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 403)
def test_fail_overlapping_reservations(self):
resource1 = self.test_data['resources'][2]
resource2 = self.test_data['resources'][3]
forbidden_reservations = [
(later(3.2), later(3.8)),
(later(3.1), later(3.9)),
(later(3.3), later(3.7)),
(later(3.2), later(3.3)),
(later(3.5), later(3.8)),
(later(3.5), later(4)),
(later(3), later(3.5))]
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(3.2)),
'end': to_timestamp(later(3.8)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
for (start, end) in forbidden_reservations:
response = self.client.post('/make_reservation/', {
'start': to_timestamp(start),
'end': to_timestamp(end),
'resource_id': resource2.id})
self.assertEqual(response.status_code, 403)
def test_fail_overlapping_reservations(self):
resource1 = self.test_data['resources'][2]
resource2 = self.test_data['resources'][3]
forbidden_reservations = [(later(3.2), later(3.8)),
(later(3.1), later(3.9)),
(later(3.3), later(3.7)),
(later(3.2), later(3.3)),
(later(3.5), later(3.8)),
(later(3.5), later(4)),
(later(3), later(3.5))]
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(3.2)),
'end': to_timestamp(later(3.8)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
for (start, end) in forbidden_reservations:
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(start),
'end': to_timestamp(end),
'resource_id': resource2.id
})
self.assertEqual(response.status_code, 403)
def test_fail_new_reservation_starts_after_ends(self):
resource = self.test_data['resources'][2]
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(1)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 403)
def test_fail_unauthorized_reservation(self):
c = Client()
resource = self.test_data['resources'][2]
response = c.post('/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(3)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 302)
def test_fail_new_reservation_starts_after_ends(self):
resource = self.test_data['resources'][2]
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(1)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 403)
def test_fail_too_long_reservation(self):
resource1 = self.test_data['resources'][2]
start = 0
end = 1 + settings.MAX_RESERVATION_LENGTH
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(start)),
'end': to_timestamp(later(end)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 403)
def test_simple_reservation_success(self):
resource = self.test_data['resources'][2]
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(2 + settings.MAX_RESERVATION_LENGTH)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(Reservation.objects.filter(id=res_content['id']).exists())
def test_incomplete_profile_reservation_failure(self):
resource = self.test_data['resources'][2]
profile = self.user.profile
profile.full_name = ''
profile.save()
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(2 + settings.MAX_RESERVATION_LENGTH)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 403)
def test_fail_unauthorized_reservation(self):
c = Client()
resource = self.test_data['resources'][2]
response = c.post(
'/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(3)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 302)
def reservations_to_json_struct(reservations):
return [{
'title': r.user.username,
'is_own': r.is_own,
'id': r.id,
'start': to_timestamp(r.start),
'end': to_timestamp(r.end),
'solidity': r.solidity,
'color': r.bg_color,
'textColor': r.text_color
} for r in reservations]
def reservations_to_json_struct(reservations):
return [{
'title': r.user.username,
'is_own': r.is_own,
'id': r.id,
'start': to_timestamp(r.start),
'end': to_timestamp(r.end),
'solidity': r.solidity,
'color': r.bg_color,
'textColor': r.text_color}
for r in reservations]
def test_fail_too_long_reservation(self):
resource1 = self.test_data['resources'][2]
start = 0
end = 1 + settings.MAX_RESERVATION_LENGTH
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(start)),
'end': to_timestamp(later(end)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 403)
def test_reserve_over_deleted_success(self):
res = self.test_data['reservations'][10]
response = self.client2.post('/delete_reservation/', {
'id': res.id})
self.assertEqual(response.status_code, 200)
response = self.client.post('/make_reservation/', {
'start': to_timestamp(res.start),
'end': to_timestamp(res.end),
'resource_id': res.resource_id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(Reservation.objects.filter(id=res_content['id']).exists())
def test_utc_sv_conversions(self):
now = common.utc_now()
local_now = common.as_local_time(now)
self.assertEqual(now, local_now)
self.assertNotEquals(now.tzname(), local_now.tzname())
ts_sv = common.to_timestamp(local_now)
ts_utc = common.to_timestamp(now)
self.assertEqual(ts_sv, ts_utc)
self.assert_approx_equal(common.from_timestamp(ts_sv), common.from_timestamp(ts_utc))
def test_utc_sv_conversions(self):
now = common.utc_now()
local_now = common.as_local_time(now)
self.assertEqual(now, local_now)
self.assertNotEquals(now.tzname(), local_now.tzname())
ts_sv = common.to_timestamp(local_now)
ts_utc = common.to_timestamp(now)
self.assertEqual(ts_sv, ts_utc)
self.assert_approx_equal(common.from_timestamp(ts_sv),
common.from_timestamp(ts_utc))
def test_simple_reservation_success(self):
resource = self.test_data['resources'][2]
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(
later(2 + settings.MAX_RESERVATION_LENGTH)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(
Reservation.objects.filter(id=res_content['id']).exists())
def test_incomplete_profile_reservation_failure(self):
resource = self.test_data['resources'][2]
profile = self.user.profile
profile.full_name = ''
profile.save()
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(
later(2 + settings.MAX_RESERVATION_LENGTH)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 403)
def test_reserve_over_deleted_success(self):
res = self.test_data['reservations'][10]
response = self.client2.post('/delete_reservation/', {'id': res.id})
self.assertEqual(response.status_code, 200)
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(res.start),
'end': to_timestamp(res.end),
'resource_id': res.resource_id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(
Reservation.objects.filter(id=res_content['id']).exists())
def test_deleted_solidity(self):
res = self.test_data['reservations'][10]
self.assertTrue(res.is_solid())
response = self.client2.post('/make_reservation/', {
'start': to_timestamp(later(4)),
'end': to_timestamp(later(5)),
'resource_id': res.resource_id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertFalse(Reservation.objects.get(id=res_content['id']).is_solid())
self.assertTrue(res.is_solid())
response = self.client2.post('/delete_reservation/', {
'id': res.id})
self.assertTrue(Reservation.objects.get(id=res_content['id']).is_solid())
self.assertFalse(Reservation.objects.get(id=res.id).is_solid())
def test_succeed_two_serial_reservations(self):
resource1 = self.test_data['resources'][2]
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(Reservation.objects.filter(id=res_content['id']).exists())
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(3)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(Reservation.objects.filter(id=res_content['id']).exists())
def test_fail_overwrite_with_preliminary(self):
c = Client()
other_user = self.test_data['users'][5]
c.login(username=other_user.username, password='******')
resource1 = self.test_data['resources'][2]
response = c.post(
'/make_reservation/', {
'start': to_timestamp(later(3)),
'end': to_timestamp(later(4)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
id_res1 = res_content['id']
response = c.post(
'/make_reservation/', {
'start': to_timestamp(later(5)),
'end': to_timestamp(later(6)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
id_res2 = res_content['id']
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
id_res3 = res_content['id']
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 403)
res1 = get_object_or_404(Reservation, pk=int(id_res1))
res2 = get_object_or_404(Reservation, pk=int(id_res2))
res3 = get_object_or_404(Reservation, pk=int(id_res3))
self.assertFalse(res1.deleted)
self.assertFalse(res2.deleted)
self.assertFalse(res3.deleted)
def test_deleted_solidity(self):
res = self.test_data['reservations'][10]
self.assertTrue(res.is_solid())
response = self.client2.post(
'/make_reservation/', {
'start': to_timestamp(later(4)),
'end': to_timestamp(later(5)),
'resource_id': res.resource_id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertFalse(
Reservation.objects.get(id=res_content['id']).is_solid())
self.assertTrue(res.is_solid())
response = self.client2.post('/delete_reservation/', {'id': res.id})
self.assertTrue(
Reservation.objects.get(id=res_content['id']).is_solid())
self.assertFalse(Reservation.objects.get(id=res.id).is_solid())
def test_fail_third_reservation(self):
resource = self.test_data['resources'][2]
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 200)
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(3)),
'end': to_timestamp(later(4)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 200)
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(5)),
'end': to_timestamp(later(6)),
'resource_id': resource.id
})
self.assertEqual(response.status_code, 403)
def test_sv_ts_sv(self):
utc_now = common.utc_now()
local_now = common.as_local_time(utc_now)
ts = common.to_timestamp(local_now)
utc_from_ts = common.from_timestamp(ts)
local_from_ts = common.as_local_time(utc_from_ts)
self.assert_approx_equal(utc_now, utc_from_ts)
self.assert_approx_equal(local_now, local_from_ts)
self.assertEqual(utc_now, local_now)
self.assertEqual(utc_from_ts, local_from_ts)
def test_sv_ts_sv(self):
utc_now = common.utc_now()
local_now = common.as_local_time(utc_now)
ts = common.to_timestamp(local_now)
utc_from_ts = common.from_timestamp(ts)
local_from_ts = common.as_local_time(utc_from_ts)
self.assert_approx_equal(utc_now, utc_from_ts)
self.assert_approx_equal(local_now, local_from_ts)
self.assertEqual(utc_now, local_now)
self.assertEqual(utc_from_ts, local_from_ts)
def test_succeed_two_serial_reservations(self):
resource1 = self.test_data['resources'][2]
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(
Reservation.objects.filter(id=res_content['id']).exists())
response = self.client.post(
'/make_reservation/', {
'start': to_timestamp(later(2)),
'end': to_timestamp(later(3)),
'resource_id': resource1.id
})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
self.assertTrue(
Reservation.objects.filter(id=res_content['id']).exists())
def test_fail_overwrite_with_preliminary(self):
c = Client()
other_user = self.test_data['users'][5]
c.login(username=other_user.username, password='******')
resource1 = self.test_data['resources'][2]
response = c.post('/make_reservation/', {
'start': to_timestamp(later(3)),
'end': to_timestamp(later(4)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
id_res1 = res_content['id']
response = c.post('/make_reservation/', {
'start': to_timestamp(later(5)),
'end': to_timestamp(later(6)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
id_res2 = res_content['id']
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 200)
res_content = json.loads(response.content)
id_res3 = res_content['id']
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource1.id})
self.assertEqual(response.status_code, 403)
res1 = get_object_or_404(Reservation, pk=int(id_res1))
res2 = get_object_or_404(Reservation, pk=int(id_res2))
res3 = get_object_or_404(Reservation, pk=int(id_res3))
self.assertFalse(res1.deleted)
self.assertFalse(res2.deleted)
self.assertFalse(res3.deleted)
def test_fail_third_reservation(self):
resource = self.test_data['resources'][2]
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(1)),
'end': to_timestamp(later(2)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 200)
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(3)),
'end': to_timestamp(later(4)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 200)
response = self.client.post('/make_reservation/', {
'start': to_timestamp(later(5)),
'end': to_timestamp(later(6)),
'resource_id': resource.id})
self.assertEqual(response.status_code, 403)
def test_utc_conversions(self):
now = common.utc_now()
now_ts = common.to_timestamp(now)
now_from_ts = common.from_timestamp(now_ts)
self.assert_approx_equal(now, now_from_ts)
def test_utc_conversions(self):
now = common.utc_now()
now_ts = common.to_timestamp(now)
now_from_ts = common.from_timestamp(now_ts)
self.assert_approx_equal(now, now_from_ts)
