def test_Page_compare_ge(self, page_tuple):
"""Compare pages using >= operator"""
page_name, (page_date, suffix, prefix, page_nums, section) = page_tuple
page_1 = msutils.Page(page_name)
page_2 = msutils.Page(
Path(_make_page_name(prefix, page_nums, section,
page_date + timedelta(1),
suffix)))
self.assertGreaterEqual(page_1, page_1)
self.assertGreaterEqual(page_2, page_1)
def test_filter_pages_for_date_filters_mixed_dates(self):
"""Only pages with matching date are returned"""
same_date_pages = [msutils.Page(path) for path in self.pdf_names]
mixed_date_pages = same_date_pages + [
msutils.Page(pathlib.Path(f'1_Front_3107{year}.pdf'))
for year in range(50, 60)
]
self.assertEqual(
same_date_pages,
msutils.edition._filter_pages_for_date(mixed_date_pages,
date=self.no_edition))
def test_multiple_pages(self):
"""external_name correctly formats non-single pages"""
page = msutils.Page(Path('2-3_Home_040516.indd'))
expected = 'MS_2016_05_04_002-003.indd'
self.assertEqual(
page.external_name(),
expected)
def test_Page_two_equal(self, page1_tuple, page2_tuple):
"""Pages instantiated from the same path are the same
In this case, we instantiate two Pages with different paths
and assert that they should compare equal to each other if
and only if their list comparison keys compare equal.
"""
p1_path, p1_list = page1_tuple
p2_path, p2_list = page2_tuple
page_1 = msutils.Page(p1_path)
page_2 = msutils.Page(p2_path)
if p1_list == p2_list:
self.assertEqual(page_1, page_2)
else:
self.assertNotEqual(page_1, page_2)
def test_Page_external_name(self, page_tuple):
"""external_name formats as expected
For single pages without a prefix:
MS_1929_12_31_001.pdf
Where that is MS, %Y, %m, %d, page number and file extension.
For multiple pages without a prefix:
MS_1929_12_31_002-003.indd
For single pages with a prefix:
MS_A_1929_12_31_001.pdf
Where the prefix comes before the page number.
For multiple pages with a prefix:
MS_A_1929_12_31_002-003.indd
"""
name, (p_date, suffix, prefix, p_nums, _) = page_tuple
page = msutils.Page(name)
nums_str = '-'.join(f'{n:03}' for n in p_nums)
formatted = f'MS_{prefix}_{p_date:%Y_%m_%d}_{nums_str}.{suffix}'
formatted = formatted.replace('__', '_')
self.assertEqual(page.external_name(), formatted)
def test_known_invalid_no_date(self):
"""Filenames with no date raise ValueError"""
filenames = ['14-15 Features.indd',
'17_Shares ad.indd']
for fn in filenames:
with self.assertRaisesRegex(ValueError, 'invalid filename'):
msutils.Page(Path(fn))
def test_filter_pages_for_date_all_same(self):
"""No pages filtered if date is what is expected."""
pages = [msutils.Page(path) for path in self.pdf_names]
self.assertEqual(
pages,
msutils.edition._filter_pages_for_date(pages,
date=self.no_edition))
def test_Page_self_equal(self, arg_tuple):
"""Pages that have matching attributes compare equal
In this case, we instantiate two Pages with the same path
and assert that they should compare equal to each other.
Page should compare on the following, in this order:
* Date
* Type (file extension)
* Prefix
* Page number (left-hand if a spread)
* Section (case-insensitively)
"""
page_path, _ = arg_tuple
page_1 = msutils.Page(page_path)
page_2 = msutils.Page(page_path)
self.assertEqual(page_1, page_2)
def test_repr(self):
"""Page returns 'Page(page.path)' for __repr__"""
orig_path = Path('/test/path/1_Front_040516.indd')
page = msutils.Page(orig_path)
self.assertEqual(
'Page({})'.format(repr(orig_path)),
repr(page)
)
def test_known_invalid_5digit_date(self):
"""Filenames with ambiguous 5-digit date raise ValueError"""
filenames = ['11_Arts_26314.indd',
'16-17_Arts_14115.indd',
'16-17_Arts_21115.indd',
'16-17_Arts_28115.indd']
for fn in filenames:
with self.assertRaisesRegex(ValueError, 'invalid filename'):
msutils.Page(Path(fn))
def test_multiple_separator_chars(self):
"""Extra separator chars are excluded from section name"""
filename = Path('11_Arts_ 231214.indd')
expected = {'pages': (11,),
'section': 'Arts',
'date': date(2014, 12, 23)}
result = msutils.Page(filename)
for attr, value in expected.items():
self.assertEqual(value, getattr(result, attr))
def test_hyphen_as_separator(self):
"""Correctly parse filename with hyphen as separator"""
filename = Path('10-11-FEATURES-251014.indd')
expected = {'pages': (10, 11),
'section': 'FEATURES',
'date': date(2014, 10, 25)}
result = msutils.Page(filename)
for attr, value in expected.items():
self.assertEqual(value, getattr(result, attr))
def test_space_as_separator(self):
"""Correctly parse filename with space as separator"""
filename = Path('14-15 Features 150314.indd')
expected = {'pages': (14, 15),
'section': 'Features',
'date': date(2014, 3, 15)}
result = msutils.Page(filename)
for attr, value in expected.items():
self.assertEqual(value, getattr(result, attr))
def test_extra_underscore_in_section(self):
"""Correctly parse filename with underscore in section"""
filename = Path('4-5_advert_Home_280414.indd')
expected = {'pages': (4, 5),
'section': 'advert_Home',
'date': date(2014, 4, 28)}
result = msutils.Page(filename)
for attr, value in expected.items():
self.assertEqual(value, getattr(result, attr))
def test_simple_indd_filename(self):
"""Page correctly parses simple front InDesign file"""
filename = Path('1_Front_040516.indd')
expected = {'pages': (1,),
'section': 'Front',
'date': date(2016, 5, 4)}
result = msutils.Page(filename)
for attr, value in expected.items():
self.assertEqual(value, getattr(result, attr))
def test_Page_accepts_known_good(self, name):
"""Page should accept known-good names from a corpus
No assertions here, as Page will raise a ValueError
"""
try:
msutils.Page(page_path=Path(name))
except ValueError as e:
self.fail(e)
def test_Page_compare_lt_gt(self, page1_tuple, page2_tuple):
"""Pages sort according to their comparison keys
In this case, we instantiate two Pages with different paths
and assert that they should compare less than or greater
than based on how their list comparison keys compare.
"""
p1_path, p1_list = page1_tuple
p2_path, p2_list = page2_tuple
assume(p1_list != p2_list) # Skip test if the pages are equal
page_1 = msutils.Page(p1_path)
page_2 = msutils.Page(p2_path)
if p1_list < p2_list:
self.assertLess(page_1, page_2)
elif p1_list > p2_list:
self.assertGreater(page_1, page_2)
def test_too_many_numbers_in_date(self):
"""Raise ValueError if date is not 6 numbers long"""
filename = Path('1_Front_0400516.indd')
with self.assertRaisesRegex(ValueError, 'invalid filename'):
msutils.Page(filename)
def test_clearly_invalid_filename(self):
"""Page should raise ValueError with invalid filename"""
filename = Path('not a filename')
with self.assertRaisesRegex(ValueError, 'invalid filename'):
msutils.Page(filename)
def test_path_stored_name_only(self):
"""Page correctly stores a name-only path"""
p = Path('1_Front_040516.indd')
result = msutils.Page(p)
self.assertEqual(p, result.path)
def test_basic_case_pdf(self):
"""external_name formats a known correct InDesign page"""
page = msutils.Page(Path('1_Front_040516.pdf'))
expected = 'MS_2016_05_04_001.pdf'
self.assertEqual(page.external_name(),
expected)
def test_path_stored_full_path(self):
"""Page correctly stores full path supplied in constructor"""
p = Path('/fake/but/full/path/1_Front_040516.indd')
result = msutils.Page(p)
self.assertEqual(p, result.path)
def test_path_user_expanded(self):
"""Page expands ~ in supplied path"""
p = Path('~/fake/pages/dir/1_Front_040516.indd')
result = msutils.Page(p)
self.assertEqual(p.expanduser(), result.path)
def test_type_stored_pdf(self):
"""Page correctly stores 'indd' under .type"""
page = msutils.Page(Path('1_Front_040516.pdf'))
self.assertEqual('pdf', page.type)
def test_Page_rejects_known_bad(self, name):
"""Page should reject known-bad names from a corpus"""
with self.assertRaises(ValueError):
msutils.Page(page_path=Path(name))
def test_type_stored_lower(self):
"""Page correctly lowercases the file's type"""
page = msutils.Page(Path('1_Front_040516.INDD'))
self.assertEqual('indd', page.type)
def test_prefix_stored(self):
"""Page stores any prefix in the filename"""
page = msutils.Page(Path('W4_Back_240314.indd'))
self.assertEqual(page.prefix, 'W')
def test_Page_comparison_keys(self, arg_tuple):
page_path, keys = arg_tuple
page = msutils.Page(page_path)
self.assertEqual(
msutils.Page._comparison_keys(page),
keys)
def test_str(self):
"""Page returns original filename for __str__"""
orig_path = Path('1_Front_040516.indd')
page = msutils.Page(orig_path)
self.assertEqual(orig_path.name, str(page))
