def test_apply_diff(self):
diff = {'204': {'text': [('delete', 0, 2), ('insert', 4, 'AAB')],
'op': ''}}
da = diff_applier.DiffApplier(diff, None)
da.apply_diff('acbd', '204')
new_text = da.get_text()
self.assertEquals('<del>ac</del>bd<ins>AAB</ins>', new_text)
def test_tree_changes_new_section(self):
diff = {'9999-25': {'op': 'added',
'node': {'text': 'Some Text',
'node_type': 'REGTEXT',
'label': ['9999', '25'],
'children': []}}}
old_tree = {}
da = diff_applier.DiffApplier(diff, '9999-25')
da.tree_changes(old_tree)
self.assertEqual(old_tree['label'], ['9999', '25'])
def test_process_node_title_diff(self):
builder = HTMLBuilder(None, None, None)
diff = {
'204': {
'title': [('delete', 0, 2), ('insert', 4, 'AAC')],
'text': [('delete', 0, 2), ('insert', 4, 'AAB')],
'op': ''
}
}
da = diff_applier.DiffApplier(diff, None)
node = {"label_id": "204", "title": "abcd", 'node_type': APPENDIX}
builder.diff_applier = da
builder.process_node_title(node)
self.assertEqual('<del>ab</del>cd<ins>AAC</ins>', node['header'])
def test_add_nodes_empty_tree(self):
tree = {}
new_node = {
'text': 'new node text',
'children': [],
'label_id': '204-2',
'label': ['204', '2'],
'node_type': REGTEXT
}
da = diff_applier.DiffApplier({}, None)
adds = tree_builder.AddQueue()
adds.insert_all([('204-2', new_node)])
da.add_nodes_to_tree(tree, adds)
def test_process_node_title_section_space_diff(self):
"""" Diffs and sections spaces need to place nicely together. """
builder = HTMLBuilder(None, None, None)
diff = {'204': {'title': [('delete', 7, 9), ('insert', 10, 'AAC')],
'text': [('delete', 0, 2), ('insert', 4, 'AAB')],
'op': ''}}
da = diff_applier.DiffApplier(diff, None)
node = {
"label_id": u"204",
"title": u"§ 101.6 abcd",
'node_type': APPENDIX
}
builder.diff_applier = da
builder.process_node_title(node)
self.assertEqual(
u'§ 101.6<del> a</del>b<ins>AAC</ins>cd', node['header'])
def test_add_nodes_child_ops(self):
"""If we don't know the correct order of children, attempt to use data
from `child_ops`"""
def mk_node(section):
return {
'label': ['100', section],
'node_type': 'regtext',
'children': []
}
node_1, node_2 = mk_node('1'), mk_node('2')
node_2a, node_3 = mk_node('2a'), mk_node('3')
original = {
'label': ['100'],
'node_type': 'regtext',
'children': [node_1, node_2]
}
diff = {
'100': {
'op':
diff_applier.DiffApplier.MODIFIED_OP,
'child_ops': [[diff_applier.DiffApplier.EQUAL, 0, 1],
[diff_applier.DiffApplier.DELETE, 1, 2],
[diff_applier.DiffApplier.INSERT, 1, ['100-2a']],
[diff_applier.DiffApplier.INSERT, 2, ['100-3']]]
},
'100-2': {
'op': diff_applier.DiffApplier.DELETED_OP
},
'100-2a': {
'op': diff_applier.DiffApplier.ADDED_OP,
'node': node_2a
},
'100-3': {
'op': diff_applier.DiffApplier.ADDED_OP,
'node': node_3
}
}
adds = tree_builder.AddQueue()
adds.insert_all([('100-2a', node_2a), ('100-3', node_3)])
da = diff_applier.DiffApplier(diff, None)
da.add_nodes_to_tree(original, adds)
self.assertEqual(original['child_labels'],
['100-1', '100-2', '100-2a', '100-3'])
def test_add_nodes_to_tree(self):
tree = self.build_tree()
new_node = {
'text': 'child text',
'children': [],
'label_id': '204-2',
'label': ['204', '2'],
'node_type': REGTEXT
}
da = diff_applier.DiffApplier({}, None)
adds = tree_builder.AddQueue()
adds.insert_all([('204-2', new_node)])
da.add_nodes_to_tree(tree, adds)
self.assertEqual(len(tree['children']), 2)
self.assertEqual(tree['children'][0], new_node)
def test_new_regtext_changes(self, get_appliers, ApiReader):
"""We can add a whole new section without explosions"""
amendments = [{'instruction': '3. Add subpart M',
'changes': [
['111-Subpart-M', [{'node': {
'label': ['111', 'Subpart', 'M'],
'title': 'A New Subpart',
'child_labels': ['111-42', '111-43',
'111-44', '111-45']}}]],
['111-42', [{'some': 'thing'}]],
['111-43', [{'some': 'thing'}]],
['111-44', [{'some': 'thing'}]],
['111-45', [{'some': 'thing'}]]]},
{'instruction': '4. Unrelated'}]
version_info = {'111': {'left': '234-567', 'right': '8675-309'}}
# Section did not exist before
ApiReader.return_value.regulation.return_value = None
diff = {'111-44': {'op': 'added', 'node': {
'text': 'New node text', 'node_type': 'regtext',
'label': ['111', '44']}}}
get_appliers.return_value = (
layers_applier.InlineLayersApplier(),
layers_applier.ParagraphLayersApplier(),
layers_applier.SearchReplaceLayersApplier(),
diff_applier.DiffApplier(diff, '111-44'))
result = preamble.CFRChangesView.regtext_changes_context(
amendments, version_info, '111-44', '8675-309', 0)
self.assertEqual(result['instructions'], ['3. Add subpart M'])
self.assertEqual(result['tree']['marked_up'],
'<ins>New node text</ins>')
self.assertEqual(1, len(result['subparts']))
subpart_info = result['subparts'][0]
self.assertEqual('M', subpart_info.letter)
self.assertEqual('A New Subpart', subpart_info.title)
self.assertEqual(2, subpart_info.idx)
self.assertEqual(4, len(subpart_info.urls))
self.assertIn('111-42', subpart_info.urls[0])
self.assertIn('111-43', subpart_info.urls[1])
self.assertIn('111-44', subpart_info.urls[2])
self.assertIn('111-45', subpart_info.urls[3])
def test_set_child_labels_reorder(self):
"""Nodes which have been _moved_ should be ordered in their final
resting position"""
node1 = {'label': ['1', '1'], 'node_type': 'regtext', 'children': []}
node2 = {'label': ['1', '2'], 'node_type': 'regtext', 'children': []}
root = {
'label': ['1'],
'node_type': 'regtext',
'children': [node1, node2]
}
diff = {
'1': {
'op':
diff_applier.DiffApplier.MODIFIED_OP,
'child_ops':
[[diff_applier.DiffApplier.DELETE, 0, 2],
[diff_applier.DiffApplier.INSERT, 0, ['1-2', '1-1']]]
}
}
da = diff_applier.DiffApplier(diff, None)
da.set_child_labels(root)
self.assertEqual(root['child_labels'], ['1-2', '1-1'])
def test_delete_all(self):
da = diff_applier.DiffApplier({}, None)
original = 'abcd'
deleted = da.delete_all(original)
self.assertEqual('<del>abcd</del>', deleted)
def create_diff_applier(self):
diff = {'some': 'diff'}
da = diff_applier.DiffApplier(diff, None)
text = "abcd"
da.deconstruct_text(text)
return da
def test_create_applier(self):
diff = {'some': 'diff'}
da = diff_applier.DiffApplier(diff, None)
self.assertEquals(da.diff, diff)
