def create_zosia(commit=True, **kwargs):
time = now()
place, _ = Place.objects.get_or_create(name='Mieszko',
address='FooBar@Katowice')
defaults = {
'active': False,
'start_date': time,
'place': place,
'registration_start': time,
'registration_end': timedelta_since_now(minutes=10),
'rooming_start': timedelta_since_now(days=-1),
'rooming_end': timedelta_since_now(days=1),
'lecture_registration_start': time,
'lecture_registration_end': timedelta_since_now(minutes=10),
'price_accommodation': PRICE_ACCOMMODATION,
'price_accommodation_breakfast': PRICE_BREAKFAST,
'price_accommodation_dinner': PRICE_DINNER,
'price_whole_day': PRICE_FULL,
'price_base': PRICE_BASE,
'price_transport': PRICE_TRANSPORT,
'account_number': 'PL59 1090 2402 4156 9594 3379 3484',
'account_owner': 'Joan Doe',
'account_bank': 'SuperBank',
'account_address': 'ul. Fajna 42, 51-109, Wrocław'
}
defaults.update(kwargs)
zosia = Zosia(**defaults)
if commit:
zosia.save()
return zosia
def create_zosia(commit=True, **kwargs):
time = now()
place, _ = Place.objects.get_or_create(name='Mieszko',
address='FooBar@Katowice')
defaults = {
'active': False,
'start_date': time,
'place': place,
'registration_start': time,
'registration_end': time,
'rooming_start': timedelta_since_now(days=-1),
'rooming_end': timedelta_since_now(days=1),
'lecture_registration_start': time,
'lecture_registration_end': time,
'price_accomodation': PRICE_ACCOMODATION,
'price_accomodation_breakfast': PRICE_BREAKFAST,
'price_accomodation_dinner': PRICE_DINNER,
'price_whole_day': PRICE_BONUS,
'price_base': PRICE_BASE,
'price_transport': PRICE_TRANSPORT,
'account_number': '',
}
defaults.update(kwargs)
zosia = Zosia(**defaults)
if commit:
zosia.save()
return zosia
def make(self, user, expiration_date=None):
if expiration_date is None:
expiration_date = timedelta_since_now(delta=ROOM_LOCK_TIMEOUT)
return self.create(user=user,
password=random_string(4),
expiration_date=expiration_date)
def test_room_is_unlocked_after_expiration_date(self):
self.room_1.join(self.normal_1)
self.room_1.set_lock(self.normal_1,
expiration_date=timedelta_since_now(days=-30))
room_assertions.assertUnlocked(self.room_1)
self.room_1.join(self.normal_2)
room_assertions.assertJoined(self.normal_2, self.room_1)
def test_staff_cannot_lock_room_for_nonexisting_user(self):
self.client.force_authenticate(user=self.staff_1)
expiration_date = timedelta_since_now(days=1)
data = {"user": 0, "expiration_date": expiration_date}
response = self.client.post(self.url_2, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_get_regular_user_after_registration_without_prefs(self):
self.client.login(email="*****@*****.**",
password="******")
self.zosia.registration_end = timedelta_since_now(hours=-1)
self.zosia.save()
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, 200)
self.assertRedirects(response, reverse('index'))
def test_staff_cannot_lock_nonexisting_room(self):
self.client.force_authenticate(user=self.staff_2)
url = reverse("rooms_api_lock", kwargs={"version": "v1", "pk": 0})
expiration_date = timedelta_since_now(days=1)
data = {"user": self.normal_1.pk, "expiration_date": expiration_date}
response = self.client.post(url, data)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_staff_can_lock_locked_room(self):
self.room_1.join(self.normal_1)
self.room_1.set_lock(self.normal_1)
room_assertions.assertLocked(self.room_1, self.normal_1)
self.room_1.set_lock(self.normal_1, self.staff_1,
expiration_date=timedelta_since_now(days=7))
self.refresh()
room_assertions.assertLocked(self.room_1, self.normal_1)
def test_user_cannot_join_before_rooming_starts(self):
self.client.force_authenticate(user=self.normal_1)
create_user_preferences(self.normal_1,
self.zosia,
payment_accepted=True)
self.zosia.rooming_start = timedelta_since_now(days=7)
self.zosia.save()
data = {"user": self.normal_1.pk}
response = self.client.post(self.url_1, data)
self.room_1.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_staff_can_add_user_to_room_after_rooming_ends(self):
self.client.force_authenticate(user=self.staff_1)
create_user_preferences(self.normal_1,
self.zosia,
payment_accepted=True)
self.zosia.rooming_end = timedelta_since_now(days=-7)
self.zosia.save()
data = {"user": self.normal_1.pk}
response = self.client.post(self.url_1, data)
self.room_1.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
room_assertions.assertJoined(self.normal_1, self.room_1)
def test_get_regular_user_after_registration_with_prefs(self):
self.client.login(email="*****@*****.**",
password="******")
self.zosia.registration_end = timedelta_since_now(hours=-1)
self.zosia.save()
org = create_organization(name='ksi', accepted=True)
user_prefs = create_user_preferences(self.normal,
self.zosia,
organization=org)
response = self.client.get(self.url, follow=True)
self.assertEqual(response.status_code, 200)
context = response.context[-1]
self.assertEqual(context['form'].__class__, UserPreferencesForm)
self.assertEqual(context['object'], user_prefs)
def test_staff_can_lock_room_with_expiration_date(self):
self.client.force_authenticate(user=self.staff_1)
create_user_preferences(self.normal_1,
self.zosia,
payment_accepted=True)
self.room_1.join(self.normal_1)
expiration_date = timedelta_since_now(days=1)
data = {"user": self.normal_1.pk, "expiration_date": expiration_date}
response = self.client.post(self.url_1, data)
self.room_1.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
room_assertions.assertLocked(self.room_1, self.normal_1)
self.assertEqual(self.room_1.lock.expiration_date, expiration_date)
def test_user_can_unlock_after_rooming_ends(self):
self.client.force_authenticate(user=self.normal_2)
create_user_preferences(self.normal_2,
self.zosia,
payment_accepted=True)
self.room_2.join(self.normal_2)
self.room_2.set_lock(self.normal_2)
self.zosia.rooming_end = timedelta_since_now(days=-7)
self.zosia.save()
response = self.client.post(self.url_2, {})
self.room_2.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
room_assertions.assertLocked(self.room_2, self.normal_2)
def test_staff_can_lock_before_rooming_starts(self):
self.client.force_authenticate(user=self.staff_1)
create_user_preferences(user=self.normal_1,
zosia=self.zosia,
payment_accepted=True)
self.room_1.join(self.normal_1)
self.zosia.rooming_start = timedelta_since_now(days=7)
self.zosia.save()
data = {"user": self.normal_1.pk}
response = self.client.post(self.url_1, data, format="json")
self.room_1.refresh_from_db()
self.assertEqual(response.status_code, status.HTTP_200_OK)
room_assertions.assertLocked(self.room_1, self.normal_1)
def create_active_zosia(place, **kwargs):
today = now()
start_date = timedelta_since_now(days=350)
start = today
end = start_date
data = {
'active': True,
'place': place,
'registration_start': start,
'registration_end': end,
'start_date': start_date,
'rooming_start': start,
'rooming_end': end,
'lecture_registration_start': start,
'lecture_registration_end': end,
}
return create_zosia(**data)
def setUp(self):
time = now()
place = Place.objects.create(name="Mieszko", address="foo")
self.zosia = Zosia.objects.create(
start_date=timedelta_since_now(days=1),
active=True,
place=place,
price_accommodation=23,
registration_end=time,
registration_start=time,
rooming_start=time,
rooming_end=time,
price_transport=0,
lecture_registration_start=time,
lecture_registration_end=time,
price_accommodation_dinner=0,
price_accommodation_breakfast=0,
price_whole_day=0)
self.user = create_user(0)
