def test_api_terms_orders_by_location(self):
""" Tests that /api/terms shows terms from College Station first, then terms
in Galveston, then terms in Qatar
"""
# Arrange
expected = {
'Fall 2020 - College Station': '202031',
'Fall 2020 - Galveston': '202032',
'Fall 2020 - Qatar': '202033',
}
# Save departments to the database so they can be queried by /api/terms
now = timezone.now() # timezone prevents django naive datetime warning
terms = [
Term(code='202031', last_updated=now),
Term(code='202032', last_updated=now),
Term(code='202033', last_updated=now),
]
Term.objects.bulk_create(terms)
# Act
response = self.client.get('/api/terms')
# Assert
self.assertEqual(response.status_code, 200)
self.assert_dicts_equal_same_order(expected, response.json())
def test_api_term_serializer_gives_expected_output_non_professional(self):
""" Tests that the term serializer yields the correct data for
a non professional term
"""
# Arrange
expected = {'code': '201831', 'desc': 'Fall 2018 - College Station'}
model = Term(code='201831', last_updated=datetime.now())
# Act
serializer = TermSerializer(model)
# Assert
self.assertEqual(expected, serializer.data)
def test_api_term_serializer_get_desc_correctly_formats_professional_term(
self):
""" Checks that get_desc function in TermSerializer correctly combines components
when formatting a professional term
"""
# Arrange
expected = "Full Yr Professional 2019 - 2020"
model = Term(code='201941', last_updated=datetime.now())
# Act
result = TermSerializer.get_desc(self, model)
# Assert
self.assertEqual(expected, result)
def test_api_terms_orders_by_year(self):
""" Tests that /api/terms sorts descending by year """
# Arrange
expected = {
'Fall 2020 - College Station': '202031',
'Fall 2019 - College Station': '201931',
'Fall 2018 - College Station': '201831',
}
# Save departments to the database so they can be queried by /api/terms
now = timezone.now() # timezone prevents django naive datetime warning
terms = [
Term(code='201831', last_updated=now),
Term(code='201931', last_updated=now),
Term(code='202031', last_updated=now),
]
Term.objects.bulk_create(terms)
# Act
response = self.client.get('/api/terms')
# Assert
self.assertEqual(response.status_code, 200)
self.assert_dicts_equal_same_order(expected, response.json())
def handle(self, *args, **options):
# Can't use datetime.now(), otherwise django will say: "DateTimeField received a
# naive time zone while time zone support is active."
last_updated = timezone.now()
term_models = [
Term(code=term, last_updated=last_updated)
for term in get_all_terms()
]
# We're not doing a bulk upsert(delete, then bulk_create) because we don't want to
# delete old terms - we just want to fill in terms that haven't been scraped yet
Term.objects.bulk_create(term_models, ignore_conflicts=True)
print(f'Saved {len(term_models)} terms')
def test_term_exists_returns_date(self):
""" Tests that api/get_last_updated returns the correct last_updated date
when given the corresponding term
"""
# Arrange
expected = timezone.make_aware(datetime(2020, 1, 1))
code = '202031'
Term(code=code, last_updated=expected).save()
# Act
response = self.client.get(f'/api/get_last_updated?term={code}')
# Assert
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, expected)
def test_api_term_serializer_gives_expected_output_professional(self):
""" Tests that the term serializer yields the correct data for
a professional term
"""
# Arrange
expected = {
'code': '201941',
'desc': 'Full Yr Professional 2019 - 2020'
}
model = Term(code='201941', last_updated=datetime.now())
# Act
serializer = TermSerializer(model)
# Assert
self.assertEqual(expected, serializer.data)
def test_api_terms_orders_multiple_terms_correctly(self):
""" Tests that /api/terms sorts a large group of terms in the correct order """
# Arrange
expected = {
'Spring 2021 - College Station': '202111',
'Spring 2021 - Galveston': '202112',
'Spring 2021 - Qatar': '202113',
'Fall 2020 - College Station': '202031',
'Fall 2020 - Galveston': '202032',
'Fall 2020 - Qatar': '202033',
'Summer 2020 - College Station': '202021',
'Summer 2020 - Galveston': '202022',
'Summer 2020 - Qatar': '202023',
}
# Save departments to the database so they can be queried by /api/terms
now = timezone.now() # timezone prevents django naive datetime warning
terms = [
# Note that each group of 3 is in a different order
Term(code='202112', last_updated=now),
Term(code='202111', last_updated=now),
Term(code='202113', last_updated=now),
Term(code='202032', last_updated=now),
Term(code='202031', last_updated=now),
Term(code='202033', last_updated=now),
Term(code='202023', last_updated=now),
Term(code='202022', last_updated=now),
Term(code='202021', last_updated=now),
]
Term.objects.bulk_create(terms)
# Act
response = self.client.get('/api/terms')
# Assert
self.assertEqual(response.status_code, 200)
self.assert_dicts_equal_same_order(expected, response.json())
def save_terms(terms, options):
""" Creates terms objects to save """
start = time.time()
now = timezone.now(
) # use timezone.now() so Django doesn't complain about naive times
with transaction.atomic():
# Bulk upsert
term_models = [Term(code=term, last_updated=now) for term in terms]
if options['year'] or options['recent'] or options['term']:
queryset = Term.objects.filter(code__in=terms)
else: # If no options are provided, then we're scraping all terms
queryset = Term.objects.all()
queryset.delete()
Term.objects.bulk_create(term_models)
term_len = len(terms) if terms else 1
print(f"Saved {term_len} term(s) in {(time.time()-start):.2f} seconds")