def test_order():
v1 = Version('first', date(2001, 1, 1), Citation(1, 1))
v2 = Version('eff', date(2002, 2, 2), Citation(1, 1))
v3 = Version('cit', date(2002, 2, 2), Citation(3, 3))
v4 = Version('cit >id', date(2002, 2, 2), Citation(3, 3))
for permutation in permutations([v1, v2, v3, v4]):
assert list(sorted(permutation)) == [v1, v2, v3, v4]
def create_versions():
"""Generate some dummy data"""
entry.Version(11, 222,
'aaa').write(Version('aaa', date(2002, 2, 2), Citation(2,
2)))
entry.Version(11, 222,
'bbb').write(Version('bbb', date(2001, 1, 1), Citation(1,
1)))
entry.Version(11, 222,
'ccc').write(Version('ccc', date(2003, 3, 3), Citation(3,
3)))
def test_last_versions_not_printed(monkeypatch):
"""We should only find the annual editions which have been published
already"""
# 2001 exists; no other years do
monkeypatch.setattr(annual_editions.annual, 'find_volume', Mock())
annual_editions.annual.find_volume = lambda year, title, part: year == 2001
path = entry.Version('12', '1000')
(path / '1111').write(Version('1111', date(2000, 12, 1), Citation(1, 1)))
(path / '2222').write(Version('2222', date(2001, 12, 1), Citation(1, 1)))
results = list(annual_editions.last_versions(12, 1000))
assert results == [annual_editions.LastVersionInYear('1111', 2001)]
def test_last_versions_multiple_versions(monkeypatch):
"""If multiple versions affect the same annual edition, we should only
receive the last"""
monkeypatch.setattr(annual_editions.annual, 'find_volume', Mock())
annual_editions.annual.find_volume.return_value = True
path = entry.Version('12', '1000')
(path / '1111').write(Version('1111', date(2000, 12, 1), Citation(1, 1)))
(path / '2222').write(Version('2222', date(2000, 12, 2), Citation(1, 2)))
(path / '3333').write(Version('3333', date(2001, 12, 1), Citation(1, 1)))
results = list(annual_editions.last_versions(12, 1000))
assert results == [
annual_editions.LastVersionInYear('2222', 2001),
annual_editions.LastVersionInYear('3333', 2002)
]
def test_process_if_needed_missing_writes(monkeypatch):
"""If output isn't already present, we should process. If it is present,
we don't need to, unless a dependency has changed."""
monkeypatch.setattr(annual_editions, 'gpo_cfr', Mock())
build_tree = annual_editions.gpo_cfr.builder.build_tree
build_tree.return_value = Node()
last_versions = [annual_editions.LastVersionInYear('1111', 2000)]
entry.Version('12', '1000', '1111').write(
Version('1111', date(2000, 1, 1), Citation(1, 1)))
entry.Entry('annual', '12', '1000', 2000).write(b'<ROOT></ROOT>')
annual_editions.process_if_needed('12', '1000', last_versions)
assert build_tree.called
build_tree.reset_mock()
entry.Entry('tree', '12', '1000', '1111').write(b'tree-here')
annual_editions.process_if_needed('12', '1000', last_versions)
assert not build_tree.called
# Simulate a change to an input file
label_id = str(entry.Annual(12, 1000, 2000))
new_time = timezone.now() + timedelta(hours=1)
DBEntry.objects.filter(label_id=label_id).update(modified=new_time)
annual_editions.process_if_needed('12', '1000', last_versions)
assert build_tree.called
def from_json(json_str):
json_dict = json.loads(json_str)
effective = json_dict.get('effective')
if effective:
effective = datetime.strptime(effective, '%Y-%m-%d').date()
return Version(json_dict['identifier'], effective,
Citation(**json_dict['fr_citation']))
def test_creates_version(monkeypatch):
monkeypatch.setattr(proposal_versions, 'entry', Mock())
notice = proposal_versions.entry.Notice.return_value.read.return_value
notice.fr_citation = Citation(1, 2)
notice.cfr_ref_pairs = [(11, 111), (11, 222), (22, 222), (22, 333)]
result = CliRunner().invoke(proposal_versions.proposal_versions, ['dddd'])
assert result.exception is None
assert proposal_versions.entry.Notice.call_args == call('dddd')
assert proposal_versions.entry.Version.call_args_list == [
call(11, 111, 'dddd'),
call(11, 222, 'dddd'),
call(22, 222, 'dddd'),
call(22, 333, 'dddd')
]
write_args = proposal_versions.entry.Version.return_value.write.call_args
assert write_args == call(Version('dddd', None, Citation(1, 2)))
def test_process_cfr_layers():
"""All layers for a single version should get written."""
version_entry = entry.Version(12, 1000, '1234')
version_entry.write(Version('1234', date.today(), Citation(1, 1)))
entry.Tree('12', '1000', '1234').write(Node())
layers.process_cfr_layers(['keyterms', 'meta'], 12, version_entry)
assert entry.Layer.cfr(12, 1000, '1234', 'keyterms').exists()
assert entry.Layer.cfr(12, 1000, '1234', 'meta').exists()
def create_version_entry_if_needed(volume, cfr_part):
"""Only write the version entry if it doesn't already exist. If we
overwrote one, we'd be invalidating all related trees, etc."""
version_id = _version_id(volume.year, cfr_part)
version_dir = entry.FinalVersion(volume.title, cfr_part)
if version_id not in [c.path[-1] for c in version_dir.sub_entries()]:
(version_dir / version_id).write(
Version(version_id,
effective=volume.publication_date,
fr_citation=Citation(volume.vol_num, 1)))
def test_process_if_needed_missing_dependency_error():
"""If the annual XML or version isn't present, we should see a dependency
error."""
last_versions = [annual_editions.LastVersionInYear('1111', 2000)]
with pytest.raises(dependency.Missing):
annual_editions.process_if_needed('12', '1000', last_versions)
entry.Version('12', '1000', '1111').write(
Version('1111', date(2000, 1, 1), Citation(1, 1)))
with pytest.raises(dependency.Missing):
annual_editions.process_if_needed('12', '1000', last_versions)
def test_process_version_if_needed_success():
"""If the requirements are present we should write the version data"""
notice_xml = NoticeXML(XMLBuilder().xml)
notice_xml.effective = date(2001, 1, 1)
notice_xml.fr_volume = 2
notice_xml.start_page = 3
entry.Notice('vvv').write(notice_xml)
full_issuance.process_version_if_needed('title', 'part', 'vvv')
result = entry.Version('title', 'part', 'vvv').read()
assert result.identifier == 'vvv'
assert result.effective == date(2001, 1, 1)
assert result.fr_citation == Citation(2, 3)
def test_write_to_disk():
"""If a version has been delayed, its effective date should be part of the
serialized json"""
xml = Mock(effective=date(2002, 2, 2),
version_id='111',
fr_citation=Citation(1, 1))
path = entry.Version('12', '1000')
versions.write_to_disk(xml, path / '111')
xml.version_id = '222'
versions.write_to_disk(xml, path / '222',
versions.Delay(by='333', until=date(2004, 4, 4)))
assert (path / '111').read().effective == date(2002, 2, 2)
assert (path / '222').read().effective == date(2004, 4, 4)
def test_parents_of():
final1 = Version(str(randrange(1000)), date(2002, 2, 2), Citation(1, 1))
prop1 = Version(str(randrange(1000)), None, Citation(2, 2))
final2 = Version(str(randrange(1000)), date(2004, 4, 4), Citation(3, 3))
prop2 = Version('222', None, Citation(4, 4))
prop3 = Version('333', None, Citation(6, 6))
prop4 = Version('444', None, Citation(6, 6))
correct_order = [final1, prop1, final2, prop2, prop3, prop4]
for permutation in permutations(correct_order):
assert list(sorted(permutation)) == correct_order
paired = list(zip(correct_order, Version.parents_of(correct_order)))
assert paired == [(final1, None), (prop1, final1), (final2, final1),
(prop2, final2), (prop3, final2), (prop4, final2)]
def test_transform_notice(monkeypatch):
"""We should add version information and the SxS functions should be
called"""
monkeypatch.setattr(write_to, 'add_footnotes', Mock())
monkeypatch.setattr(write_to, 'process_sxs', Mock())
entry.Version(11, 222,
'v1').write(Version('v1', date(2002, 2, 2), Citation(1, 1)))
entry.Version(11, 222,
'v2').write(Version('v2', date(2003, 3, 3), Citation(2, 2)))
entry.Version(11, 222,
'v3').write(Version('v3', date(2004, 4, 4), Citation(3, 3)))
entry.Version(11, 223,
'v1').write(Version('v1', date(2002, 2, 2), Citation(1, 1)))
entry.Version(11, 224,
'v1').write(Version('v1', date(2002, 2, 2), Citation(1, 1)))
entry.Version(11, 222,
'proposal').write(Version('proposal', None, Citation(4, 4)))
entry.Version(11, 223,
'proposal').write(Version('proposal', None, Citation(4, 4)))
notice_xml = Mock()
notice_xml.as_dict.return_value = {}
notice_xml.version_id = 'proposal'
notice_xml.cfr_ref_pairs = [(11, 222), (11, 223)]
result = write_to.transform_notice(notice_xml)
assert result['versions'] == {
222: {
'left': 'v3',
'right': 'proposal'
},
223: {
'left': 'v1',
'right': 'proposal'
}
}
assert write_to.add_footnotes.called
assert write_to.process_sxs.called
def test_stale_layers(monkeypatch):
"""We should have dependencies between all of the layers and their
associated trees. We should also tie the meta layer to the version"""
monkeypatch.setattr(layers, 'LAYER_CLASSES',
{'cfr': {
'keyterms': None,
'other': None
}})
version_entry = entry.Version(111, 22, 'aaa')
version_entry.write(Version('aaa', date.today(), Citation(1, 1)))
tree_entry = entry.Tree(111, 22, 'aaa')
with pytest.raises(dependency.Missing):
layers.stale_layers(tree_entry, 'cfr')
entry.Entry('tree', 111, 22, 'bbb').write(b'') # wrong version
with pytest.raises(dependency.Missing):
layers.stale_layers(tree_entry, 'cfr')
entry.Entry('tree', 111, 22, 'aaa').write(b'')
assert set(layers.stale_layers(tree_entry, 'cfr')) == {'keyterms', 'other'}
assert str(version_entry) in dependency.Graph().dependencies(
str(entry.Layer.cfr(111, 22, 'aaa', 'meta')))
def fr_citation(self):
return Citation(self.fr_volume, self.start_page)