class SharedTestCase(test.TestCase):
"""A shared test case that provides utility functions for testing code easily."""
def setUp(self) -> None:
self.email = "*****@*****.**"
self.password = "******"
self.first_name = "Kennedy"
self.last_name = "Doe"
self.wave1 = None
self.user = User.objects.create_user(email=self.email,
password=self.password,
is_active=True)
self.email2 = "*****@*****.**"
self.first_name2 = "Kris"
self.last_name2 = "Doh"
self.user2 = User.objects.create_user(email=self.email2,
password=self.password,
is_active=True)
self.admin_email = "*****@*****.**"
self.admin_password = "******"
self.admin = User.objects.create_superuser(self.admin_email,
self.admin_password,
is_active=True)
self.resume_file_name = "resume.pdf"
self.resume = SimpleUploadedFile(self.resume_file_name, b"dummy")
self.resume_file_data = {"resume": self.resume}
self.first_school = School.objects.create(name="first school")
self.second_school = School.objects.create(name="second school")
self.application_fields = {
"first_name": self.first_name,
"last_name": self.last_name,
"shirt_size": application_models.WOMENS_XXS,
"major": "Computer Science",
"school": self.first_school,
"gender": application_models.FEMALE,
"classification": application_models.FRESHMAN,
"grad_year": timezone.now().year + 1,
"num_hackathons_attended": application_models.HACKATHONS_0,
"user": self.user,
"race": [application_models.NO_ANSWER],
"extra_links": "A",
"question1": "B",
"question2": "C",
"question3": "D",
"is_adult": True,
"agree_to_coc": True,
**self.resume_file_data,
}
def create_active_wave(self):
start = timezone.now() - timezone.timedelta(days=1)
end = start + timezone.timedelta(days=30)
self.wave1 = Wave(start=start, end=end, num_days_to_rsvp=30)
self.wave1.save()
def setUp(self):
super().setUp()
self.wave2_start = timezone.datetime(3000, 9, 7, 3, tzinfo=pytz.utc)
self.wave2_end = self.wave2_start + timezone.timedelta(days=30)
self.wave2 = Wave(start=self.wave2_start,
end=self.wave2_end,
num_days_to_rsvp=5)
self.wave2.save()
def test_active_wave(self):
curr_wave = Wave(
start=timezone.now() - timezone.timedelta(days=5),
end=timezone.now() + timezone.timedelta(days=5),
num_days_to_rsvp=5,
)
curr_wave.save()
wave = Wave.objects.active_wave()
self.assertEqual(wave, curr_wave)
def test_next_wave_gets_next_existing_wave(self):
next_wave = Wave(
start=timezone.now() + timezone.timedelta(days=5),
end=timezone.now() + timezone.timedelta(days=6),
num_days_to_rsvp=5,
)
next_wave.save()
wave = Wave.objects.next_wave()
self.assertEqual(wave, next_wave)
def test_cant_create_overlapping_waves(self):
bad_wave_start, bad_wave_end = (
self.wave2_start,
self.wave2_start + timezone.timedelta(days=15),
)
bad_wave = Wave(start=bad_wave_start,
end=bad_wave_end,
num_days_to_rsvp=5)
with self.assertRaises(ValidationError):
bad_wave.full_clean()
class WaveModelTestCase(test_case.SharedTestCase):
def setUp(self):
super().setUp()
self.wave2_start = timezone.datetime(3000, 9, 7, 3, tzinfo=pytz.utc)
self.wave2_end = self.wave2_start + timezone.timedelta(days=30)
self.wave2 = Wave(start=self.wave2_start,
end=self.wave2_end,
num_days_to_rsvp=5)
self.wave2.save()
def test_cant_have_end_before_start(self):
bad_wave = Wave(start=self.wave2_end, end=self.wave2_start)
with self.assertRaises(ValidationError):
bad_wave.full_clean()
def test_cant_create_overlapping_waves(self):
bad_wave_start, bad_wave_end = (
self.wave2_start,
self.wave2_start + timezone.timedelta(days=15),
)
bad_wave = Wave(start=bad_wave_start,
end=bad_wave_end,
num_days_to_rsvp=5)
with self.assertRaises(ValidationError):
bad_wave.full_clean()
def test_can_modify_existing_wave(self):
new_end = self.wave2.end - timezone.timedelta(days=1)
self.wave2.end = new_end
self.wave2.full_clean()
self.wave2.save()
self.wave2.refresh_from_db()
self.assertEqual(new_end, self.wave2.end)
def handle(self, *args, **options):
"""
Function that creates Users and Applications to make testing easier.
To run use -- python manage.py shell < shared/seed.py
WARNING - Will delete most of the Users and Applications when run.
DO not use in production
"""
self.stdout.write("Starting the seeding process.")
num_users = options["num_users"]
num_active = options["num_active"]
num_apps = options["num_applications"]
assert num_users >= num_active >= num_apps
User.objects.filter(is_superuser=False).delete()
Application.objects.filter(last_name=LAST_NAME).delete()
Wave.objects.all().delete()
wave_start = timezone.now()
wave_end = wave_start + timedelta(days=10)
wave = Wave(start=wave_start, end=wave_end, num_days_to_rsvp=5)
wave.full_clean()
wave.save()
seeds = []
for i in range(num_users):
random_name = random.choice(COMMON_NAMES)
email = random_name + str(i) + "@seed.com"
is_active = True if i < num_active else False
will_apply = True if i < num_apps else False
user = User.objects.create_user(email, PASSWORD, is_active=is_active)
seeds.append((user, will_apply, random_name))
random.shuffle(seeds)
for user, will_apply, random_name in seeds:
if will_apply:
application = Application(
first_name=random_name,
last_name=LAST_NAME,
notes="",
major="Major",
race=[random.choice(RACES[1:])[0]],
classification=random.choice(CLASSIFICATIONS[1:])[0],
gender=random.choice(GENDERS[1:])[0],
grad_year=random.choice(GRAD_YEARS[1:])[0],
num_hackathons_attended=random.choice(HACKATHON_TIMES[1:])[0],
extra_links="a",
question1="b",
question2="c",
question3="d",
status=random.choice([STATUS_PENDING, STATUS_ADMITTED]),
agree_to_coc=True,
is_adult=True,
additional_accommodations="",
resume="f.pdf",
wave_id=wave.pk,
user_id=user.pk,
)
application.save()
def test_waves_transition_correctly(self):
expiring_wave = Wave(
start=timezone.now() - timezone.timedelta(days=5),
end=timezone.now(),
num_days_to_rsvp=5,
)
expiring_wave.save()
future_wave = Wave(
start=timezone.now() + timezone.timedelta(seconds=1),
end=timezone.now() + timezone.timedelta(days=6),
num_days_to_rsvp=5,
)
future_wave.save()
self.assertEqual(Wave.objects.next_wave(), future_wave)
def test_cant_have_end_before_start(self):
bad_wave = Wave(start=self.wave2_end, end=self.wave2_start)
with self.assertRaises(ValidationError):
bad_wave.full_clean()
def create_active_wave(self):
start = timezone.now() - timezone.timedelta(days=1)
end = start + timezone.timedelta(days=30)
self.wave1 = Wave(start=start, end=end, num_days_to_rsvp=30)
self.wave1.save()