def test_context_kind_and_counts(self):
"The kind and counts for publications, books and periodicals should be correct."
ReadingFactory(publication=PublicationFactory(title='Old Book',
kind='book'),
start_date=make_date('2016-06-15'),
end_date=make_date('2016-07-15'))
ReadingFactory(publication=PublicationFactory(title='2017 Book 2',
kind='book'),
start_date=make_date('2017-01-01'),
end_date=make_date('2017-01-20'))
ReadingFactory(publication=PublicationFactory(title='2017 Periodical',
kind='periodical'),
start_date=make_date('2017-02-01'),
end_date=make_date('2017-02-20'))
response = views.ReadingYearArchiveView.as_view()(self.request,
year='2017',
kind='books')
data = response.context_data
self.assertIn('publication_kind', data)
self.assertEqual(data['publication_kind'], 'book')
self.assertIn('publication_count', data)
self.assertEqual(data['publication_count'], 3)
self.assertIn('periodical_count', data)
self.assertEqual(data['periodical_count'], 1)
self.assertIn('book_count', data)
self.assertEqual(data['book_count'], 2)
def test_queryset(self):
"It should return in-progress publications."
in_progress = ReadingFactory(start_date=make_date('2017-02-10'), )
finished = ReadingFactory(
start_date=make_date('2017-01-15'),
end_date=make_date('2017-01-28'),
)
qs = in_progress_publications()
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0], in_progress.publication)
def test_queryset(self):
ReadingFactory(start_date=make_date('2015-02-10'),
end_date=make_date('2015-02-15'))
ReadingFactory(start_date=make_date('2017-02-10'),
end_date=make_date('2017-02-15'))
ReadingFactory(start_date=make_date('2017-03-10'),
end_date=make_date('2017-03-15'))
qs = reading_years()
self.assertEqual(len(qs), 2)
self.assertEqual(qs[0], make_date('2015-01-01'))
self.assertEqual(qs[1], make_date('2017-01-01'))
def test_two_readings(self):
"Shouldn't return a pub if it it had a reading before, and a reading after, the chosen date."
pub = PublicationFactory()
r1 = ReadingFactory(publication=pub,
start_date=make_date('2017-01-01'),
end_date=make_date('2017-01-31'))
r2 = ReadingFactory(publication=pub,
start_date=make_date('2017-03-01'),
end_date=make_date('2017-03-31'))
qs = day_publications(make_date('2017-02-15'))
self.assertEqual(len(qs), 0)
def test_unique_publications(self):
"Should only list each publication once."
pub = PublicationFactory()
r1 = ReadingFactory(publication=pub,
start_date=make_date('2017-01-01'),
end_date=make_date('2017-01-31'))
r2 = ReadingFactory(publication=pub,
start_date=make_date('2017-01-31'),
end_date=make_date('2017-02-15'))
qs = day_publications(make_date('2017-01-31'))
self.assertEqual(len(qs), 1)
def test_context_in_progress(self):
"It should have in-progress publications in the context."
in_progress = ReadingFactory(start_date=make_date('2017-02-10'), )
finished = ReadingFactory(
start_date=make_date('2017-01-15'),
end_date=make_date('2017-01-28'),
)
response = views.ReadingHomeView.as_view()(self.request)
context = response.context_data
self.assertIn('in_progress_publication_list', context)
self.assertEqual(len(context['in_progress_publication_list']), 1)
self.assertEqual(context['in_progress_publication_list'][0],
in_progress.publication)
def test_ended_readings(self):
"It returns publications whose ended readings were around the date"
pub1 = PublicationFactory()
pub2 = PublicationFactory()
# pub1 started before and ended after the date:
ReadingFactory(publication=pub1,
start_date=make_date('2017-02-10'),
end_date=make_date('2017-02-20'))
# pub2 was over before the date:
ReadingFactory(publication=pub2,
start_date=make_date('2017-01-01'),
end_date=make_date('2017-01-10'))
qs = day_publications(make_date('2017-02-15'))
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0], pub1)
def test_in_progress_readings(self):
"It returns publications that were still in progress on the date."
pub1 = PublicationFactory()
pub2 = PublicationFactory()
# pub1 started before the date:
ReadingFactory(publication=pub1,
start_date=make_date('2017-02-10'),
end_date=None)
# pub2 started after the date:
ReadingFactory(publication=pub2,
start_date=make_date('2017-03-01'),
end_date=None)
qs = day_publications(make_date('2017-02-15'))
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0], pub1)
def test_data(self):
"Test data returned."
ReadingFactory.create_batch(3,
publication=PublicationFactory(kind='book'),
end_date=make_date('1998-01-01'))
ReadingFactory(publication=PublicationFactory(kind='book'),
end_date=make_date('2000-01-01'))
result = ReadingGenerator(kind='book').get_per_year()
self.assertIn('data', result)
self.assertEqual(result['data'], [
{'label': '1998', 'value': 3, 'url': '/terry/reading/1998/books/'},
{'label': '1999', 'value': 0},
{'label': '2000', 'value': 1, 'url': '/terry/reading/2000/books/'},
])
def test_start_ym(self):
"Month-based start date, no end"
r = ReadingFactory(start_date=make_date('2017-02-01'),
start_granularity=4)
self.assertEqual(
reading_dates(r),
'Started in <time datetime="2017-02">February 2017</time>')
def test_start_ymd(self):
"Complete start date, no end"
r = ReadingFactory(start_date=make_date('2017-02-01'),
start_granularity=3)
self.assertEqual(
reading_dates(r),
'Started on <time datetime="2017-02-01">1 February 2017</time>')
def test_y_to_y_same_year(self):
"Only years for start and end, and the same year."
r = ReadingFactory(start_date=make_date('2017-01-01'),
start_granularity=6,
end_date=make_date('2017-01-01'),
end_granularity=6)
self.assertEqual(reading_dates(r), '<time datetime="2017">2017</time>')
def test_ym_to_ym_same_month(self):
"Month and year for start and end, and same month."
r = ReadingFactory(start_date=make_date('2017-01-01'),
start_granularity=4,
end_date=make_date('2017-01-01'),
end_granularity=4)
self.assertEqual(reading_dates(r),
'<time datetime="2017-01">January 2017</time>')
def test_ymd_to_ymd_same_day(self):
"Complete dates, start and finish on same day."
r = ReadingFactory(start_date=make_date('2017-02-01'),
start_granularity=3,
end_date=make_date('2017-02-01'),
end_granularity=3)
self.assertEqual(reading_dates(r),
'<time datetime="2017-02-01">1 February 2017</time>')
def test_num(self):
"It should return `num` items."
d = make_date('2017-02-15')
for i in range(2, 6):
c = IndividualCreatorFactory()
pub = PublicationFactory()
PublicationRoleFactory(publication=pub, creator=c, role_name='')
# It'll cut off any with only 1 reading, so:
ReadingFactory.create_batch(i,
publication=pub,
start_date=d,
end_date=d)
data = most_read_creators_card(num=3)
self.assertIn('object_list', data)
self.assertEqual(len(data['object_list']), 3)
def test_context_reading_list(self):
"Should include Readings ending in chosen year, earliest end_date first."
ReadingFactory(publication=PublicationFactory(title='Old Pub'),
start_date=make_date('2016-06-15'),
end_date=make_date('2016-07-15'))
ReadingFactory(publication=PublicationFactory(title='2017 Pub 2'),
start_date=make_date('2017-01-01'),
end_date=make_date('2017-01-20'))
response = views.ReadingYearArchiveView.as_view()(self.request,
year='2017')
context = response.context_data
self.assertIn('reading_list', context)
self.assertEqual(len(context['reading_list']), 2)
self.assertEqual(context['reading_list'][0].publication.title,
'2017 Pub 2')
self.assertEqual(context['reading_list'][1].publication.title,
'2017 Pub 1')
def test_ymd_to_ymd_diff_years(self):
"Complete dates, start and finish in different years"
r = ReadingFactory(start_date=make_date('2016-12-30'),
start_granularity=3,
end_date=make_date('2017-01-06'),
end_granularity=3)
self.assertEqual(
reading_dates(r),
'<time datetime="2016-12-30">30 December 2016</time> to <time datetime="2017-01-06">6 January 2017</time>'
)
def test_ym_to_ym_diff_months_same_year(self):
"Month and year for start and end, and different months, same year."
r = ReadingFactory(start_date=make_date('2017-01-01'),
start_granularity=4,
end_date=make_date('2017-02-01'),
end_granularity=4)
self.assertEqual(
reading_dates(r),
'<time datetime="2017-01">January</time> to <time datetime="2017-02">February 2017</time>'
)
def test_ym_to_ym_diff_years(self):
"Month and year for start and end, and different years."
r = ReadingFactory(start_date=make_date('2016-12-01'),
start_granularity=4,
end_date=make_date('2017-01-01'),
end_granularity=4)
self.assertEqual(
reading_dates(r),
'<time datetime="2016-12">December 2016</time> to <time datetime="2017-01">January 2017</time>'
)
def test_y_to_y_diff_year(self):
"Only years for start and end, and different years."
r = ReadingFactory(start_date=make_date('2016-01-01'),
start_granularity=6,
end_date=make_date('2017-01-01'),
end_granularity=6)
self.assertEqual(
reading_dates(r),
'<time datetime="2016">2016</time> to <time datetime="2017">2017</time>'
)
def test_ymd_to_y(self):
"Complete start date to year-based end date"
r = ReadingFactory(start_date=make_date('2016-12-30'),
start_granularity=3,
end_date=make_date('2017-01-06'),
end_granularity=6)
self.assertEqual(
reading_dates(r),
'<time datetime="2016-12-30">30 December 2016</time> to <time datetime="2017">2017</time>'
)
def test_y_to_ymd(self):
"Year-based start date, complete end date"
r = ReadingFactory(start_date=make_date('2016-12-30'),
start_granularity=6,
end_date=make_date('2017-01-06'),
end_granularity=3)
self.assertEqual(
reading_dates(r),
'<time datetime="2016">2016</time> to <time datetime="2017-01-06">6 January 2017</time>'
)
def test_ymd_to_ymd_same_year(self):
"Complete dates, start and finish in different months of same year."
r = ReadingFactory(start_date=make_date('2017-01-30'),
start_granularity=3,
end_date=make_date('2017-02-06'),
end_granularity=3)
self.assertEqual(
reading_dates(r),
'<time datetime="2017-01-30">30 January</time> to <time datetime="2017-02-06">6 February 2017</time>'
)
def test_ymd_to_ym_same_year(self):
"Complete start date, month-based end date, in same year."
r = ReadingFactory(start_date=make_date('2017-01-01'),
start_granularity=3,
end_date=make_date('2017-02-01'),
end_granularity=4)
self.assertEqual(
reading_dates(r),
'<time datetime="2017-01-01">1 January</time> to <time datetime="2017-02">February 2017</time>'
)
def test_context_next_prev_years(self):
"Context should include date objects representing next/prev years, if any."
ReadingFactory(publication=PublicationFactory(title='Old Pub'),
start_date=make_date('2016-06-15'),
end_date=make_date('2016-07-15'))
response = views.ReadingYearArchiveView.as_view()(self.request,
year='2017')
self.assertIn('previous_year', response.context_data)
self.assertIn('next_year', response.context_data)
self.assertEqual(response.context_data['previous_year'],
make_date('2016-01-01'))
def test_returns_queryset(self):
"It should return 10 items by default."
d = make_date('2017-02-15')
for i in range(11):
c = IndividualCreatorFactory()
pub = PublicationFactory()
PublicationRoleFactory(publication=pub, creator=c, role_name='')
ReadingFactory(publication=pub, start_date=d, end_date=d)
creators = most_read_creators()
self.assertEqual(len(creators), 10)
def test_returns_correct_data(self):
d = make_date('2017-02-15')
for i in range(2, 13):
c = IndividualCreatorFactory()
pub = PublicationFactory()
PublicationRoleFactory(publication=pub, creator=c, role_name='')
# It'll cut off any with only 1 reading, so:
ReadingFactory.create_batch(i,
publication=pub,
start_date=d,
end_date=d)
data = most_read_creators_card()
self.assertIn('card_title', data)
self.assertIn('score_attr', data)
self.assertIn('object_list', data)
self.assertEqual(data['card_title'], 'Most read authors')
self.assertEqual(data['score_attr'], 'num_readings')
self.assertEqual(len(data['object_list']), 10)
def test_num(self):
"It should return `num` items."
d = make_date('2017-02-15')
for i in range(4):
c = IndividualCreatorFactory()
pub = PublicationFactory()
PublicationRoleFactory(publication=pub, creator=c, role_name='')
ReadingFactory(publication=pub, start_date=d, end_date=d)
creators = most_read_creators(num=3)
self.assertEqual(len(creators), 3)
def setUp(self):
# Books only in 2015:
ReadingFactory.create_batch(
2,
publication=PublicationFactory(kind='book'),
end_date=make_date('2015-01-01'))
# Nothing in 2016.
# Books and periodicals in 2017:
ReadingFactory.create_batch(
3,
publication=PublicationFactory(kind='book'),
end_date=make_date('2017-09-01'))
ReadingFactory.create_batch(
2,
publication=PublicationFactory(kind='periodical'),
end_date=make_date('2017-09-01'))
# Periodicals only in 2018:
ReadingFactory.create_batch(
2,
publication=PublicationFactory(kind='periodical'),
end_date=make_date('2018-01-01'))
def test_start_y(self):
"Year-based start date, no end"
r = ReadingFactory(start_date=make_date('2017-02-01'),
start_granularity=6)
self.assertEqual(reading_dates(r),
'Started in <time datetime="2017">2017</time>')
def test_end_y(self):
"Year-based end date, no start"
r = ReadingFactory(end_date=make_date('2017-02-01'), end_granularity=6)
self.assertEqual(reading_dates(r),
'Finished in <time datetime="2017">2017</time>')
