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)