diff options
Diffstat (limited to 'tests')
33 files changed, 571 insertions, 1006 deletions
diff --git a/tests/cli_tests.py b/tests/cli_tests.py index 4728c6b..7a2ed23 100644 --- a/tests/cli_tests.py +++ b/tests/cli_tests.py @@ -1,28 +1,26 @@ import os import base64 -from nose.tools import istest, assert_equal import spur import tempman -from .testing import test_path +from .testing import assert_equal, generate_test_path _local = spur.LocalShell() -@istest -def html_is_printed_to_stdout_if_output_file_is_not_set(): - docx_path = test_path("single-paragraph.docx") + +def test_html_is_printed_to_stdout_if_output_file_is_not_set(): + docx_path = generate_test_path("single-paragraph.docx") result = _local.run(["mammoth", docx_path]) assert_equal(b"", result.stderr_output) assert_equal(b"<p>Walking on imported air</p>", result.output) -@istest -def html_is_written_to_file_if_output_file_is_set(): +def test_html_is_written_to_file_if_output_file_is_set(): with tempman.create_temp_dir() as temp_dir: output_path = os.path.join(temp_dir.path, "output.html") - docx_path = test_path("single-paragraph.docx") + docx_path = generate_test_path("single-paragraph.docx") result = _local.run(["mammoth", docx_path, output_path]) assert_equal(b"", result.stderr_output) assert_equal(b"", result.output) @@ -32,34 +30,32 @@ def html_is_written_to_file_if_output_file_is_set(): _image_base_64 = b"iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAAAAXNSR0IArs4c6QAAAAlwSFlzAAAOvgAADr4B6kKxwAAAABNJREFUKFNj/M+ADzDhlWUYqdIAQSwBE8U+X40AAAAASUVORK5CYII=" -@istest -def inline_images_are_included_in_output_if_writing_to_single_file(): - docx_path = test_path("tiny-picture.docx") + +def test_inline_images_are_included_in_output_if_writing_to_single_file(): + docx_path = generate_test_path("tiny-picture.docx") result = _local.run(["mammoth", docx_path]) assert_equal(b"""<p><img src="data:image/png;base64,""" + _image_base_64 + b"""" /></p>""", result.output) -@istest -def images_are_written_to_separate_files_if_output_dir_is_set(): +def test_images_are_written_to_separate_files_if_output_dir_is_set(): with tempman.create_temp_dir() as temp_dir: output_path = os.path.join(temp_dir.path, "tiny-picture.html") image_path = os.path.join(temp_dir.path, "1.png") - - docx_path = test_path("tiny-picture.docx") + + docx_path = generate_test_path("tiny-picture.docx") result = _local.run(["mammoth", docx_path, "--output-dir", temp_dir.path]) assert_equal(b"", result.stderr_output) assert_equal(b"", result.output) with open(output_path) as output_file: assert_equal("""<p><img src="1.png" /></p>""", output_file.read()) - + with open(image_path, "rb") as image_file: assert_equal(_image_base_64, base64.b64encode(image_file.read())) - -@istest -def style_map_is_used_if_set(): + +def test_style_map_is_used_if_set(): with tempman.create_temp_dir() as temp_dir: - docx_path = test_path("single-paragraph.docx") + docx_path = generate_test_path("single-paragraph.docx") style_map_path = os.path.join(temp_dir.path, "style-map") with open(style_map_path, "w") as style_map_file: style_map_file.write("p => span:fresh") @@ -68,9 +64,8 @@ def style_map_is_used_if_set(): assert_equal(b"<span>Walking on imported air</span>", result.output) -@istest -def output_format_markdown_option_generates_markdown_output(): - docx_path = test_path("single-paragraph.docx") +def test_output_format_markdown_option_generates_markdown_output(): + docx_path = generate_test_path("single-paragraph.docx") result = _local.run(["mammoth", docx_path, "--output-format=markdown"]) assert_equal(b"", result.stderr_output) assert_equal(b"Walking on imported air\n\n", result.output) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..a342abb --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,9 @@ +import funk +import pytest + + +@pytest.fixture(name="mocks") +def _fixture_mocks(): + mocks = funk.Mocks() + yield mocks + mocks.verify() diff --git a/tests/conversion_tests.py b/tests/conversion_tests.py index c4e667f..8f02048 100644 --- a/tests/conversion_tests.py +++ b/tests/conversion_tests.py @@ -4,24 +4,21 @@ from __future__ import unicode_literals import io -from nose.tools import istest, assert_equal - from mammoth import documents, results, html from mammoth.conversion import convert_document_element_to_html, _comment_author_label from mammoth.docx.xmlparser import parse_xml from mammoth.styles.parser import read_style_mapping +from .testing import assert_equal -@istest -def plain_paragraph_is_converted_to_plain_paragraph(): +def test_plain_paragraph_is_converted_to_plain_paragraph(): result = convert_document_element_to_html( documents.paragraph(children=[_run_with_text("Hello")]) ) assert_equal('<p>Hello</p>', result.value) -@istest -def multiple_paragraphs_are_converted_to_multiple_paragraphs(): +def test_multiple_paragraphs_are_converted_to_multiple_paragraphs(): result = convert_document_element_to_html( documents.document([ documents.paragraph(children=[_run_with_text("Hello")]), @@ -31,16 +28,14 @@ def multiple_paragraphs_are_converted_to_multiple_paragraphs(): assert_equal('<p>Hello</p><p>there</p>', result.value) -@istest -def empty_paragraphs_are_ignored(): +def test_empty_paragraphs_are_ignored(): result = convert_document_element_to_html( documents.paragraph(children=[_run_with_text("")]) ) assert_equal('', result.value) -@istest -def style_mappings_using_style_ids_can_be_used_to_map_paragraphs(): +def test_style_mappings_using_style_ids_can_be_used_to_map_paragraphs(): result = convert_document_element_to_html( documents.paragraph(style_id="TipsParagraph", children=[ _run_with_text("Tip") @@ -52,8 +47,7 @@ def style_mappings_using_style_ids_can_be_used_to_map_paragraphs(): assert_equal('<p class="tip">Tip</p>', result.value) -@istest -def style_mappings_using_style_names_can_be_used_to_map_paragraphs(): +def test_style_mappings_using_style_names_can_be_used_to_map_paragraphs(): result = convert_document_element_to_html( documents.paragraph(style_id="TipsParagraph", style_name="Tips Paragraph", children=[ _run_with_text("Tip") @@ -65,8 +59,7 @@ def style_mappings_using_style_names_can_be_used_to_map_paragraphs(): assert_equal('<p class="tip">Tip</p>', result.value) -@istest -def style_names_in_style_mappings_are_case_insensitive(): +def test_style_names_in_style_mappings_are_case_insensitive(): result = convert_document_element_to_html( documents.paragraph(style_id="TipsParagraph", style_name="Tips Paragraph", children=[ _run_with_text("Tip") @@ -78,8 +71,7 @@ def style_names_in_style_mappings_are_case_insensitive(): assert_equal('<p class="tip">Tip</p>', result.value) -@istest -def default_paragraph_style_is_used_if_no_matching_style_is_found(): +def test_default_paragraph_style_is_used_if_no_matching_style_is_found(): result = convert_document_element_to_html( documents.paragraph(style_id="TipsParagraph", children=[ _run_with_text("Tip") @@ -88,8 +80,7 @@ def default_paragraph_style_is_used_if_no_matching_style_is_found(): assert_equal('<p>Tip</p>', result.value) -@istest -def default_paragraph_style_is_specified_by_mapping_plain_paragraphs(): +def test_default_paragraph_style_is_specified_by_mapping_plain_paragraphs(): result = convert_document_element_to_html( documents.paragraph(style_id="TipsParagraph", children=[ _run_with_text("Tip") @@ -101,8 +92,7 @@ def default_paragraph_style_is_specified_by_mapping_plain_paragraphs(): assert_equal('<p class="tip">Tip</p>', result.value) -@istest -def warning_is_emitted_if_paragraph_style_is_unrecognised(): +def test_warning_is_emitted_if_paragraph_style_is_unrecognised(): result = convert_document_element_to_html( documents.paragraph( style_id="Heading1", @@ -113,16 +103,14 @@ def warning_is_emitted_if_paragraph_style_is_unrecognised(): assert_equal([results.warning("Unrecognised paragraph style: Heading 1 (Style ID: Heading1)")], result.messages) -@istest -def no_warning_if_there_is_no_style_for_plain_paragraphs(): +def test_no_warning_if_there_is_no_style_for_plain_paragraphs(): result = convert_document_element_to_html( documents.paragraph(children=[_run_with_text("Tip")]), ) assert_equal([], result.messages) -@istest -def bulleted_paragraphs_are_converted_using_matching_styles(): +def test_bulleted_paragraphs_are_converted_using_matching_styles(): result = convert_document_element_to_html( documents.paragraph(children=[ _run_with_text("Hello") @@ -134,8 +122,7 @@ def bulleted_paragraphs_are_converted_using_matching_styles(): assert_equal('<ul><li>Hello</li></ul>', result.value) -@istest -def bulleted_styles_dont_match_plain_paragraph(): +def test_bulleted_styles_dont_match_plain_paragraph(): result = convert_document_element_to_html( documents.paragraph(children=[ _run_with_text("Hello") @@ -147,16 +134,14 @@ def bulleted_styles_dont_match_plain_paragraph(): assert_equal('<p>Hello</p>', result.value) -@istest -def bold_runs_are_wrapped_in_strong_tags_by_default(): +def test_bold_runs_are_wrapped_in_strong_tags_by_default(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_bold=True), ) assert_equal("<strong>Hello</strong>", result.value) -@istest -def bold_runs_can_be_configured_with_style_mapping(): +def test_bold_runs_can_be_configured_with_style_mapping(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_bold=True), style_map=[_style_mapping("b => em")] @@ -164,16 +149,14 @@ def bold_runs_can_be_configured_with_style_mapping(): assert_equal("<em>Hello</em>", result.value) -@istest -def italic_runs_are_wrapped_in_emphasis_tags_by_default(): +def test_italic_runs_are_wrapped_in_emphasis_tags_by_default(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_italic=True), ) assert_equal("<em>Hello</em>", result.value) -@istest -def italic_runs_can_be_configured_with_style_mapping(): +def test_italic_runs_can_be_configured_with_style_mapping(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_italic=True), style_map=[_style_mapping("i => strong")] @@ -181,16 +164,14 @@ def italic_runs_can_be_configured_with_style_mapping(): assert_equal("<strong>Hello</strong>", result.value) -@istest -def underline_runs_are_ignored_by_default(): +def test_underline_runs_are_ignored_by_default(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_underline=True), ) assert_equal("Hello", result.value) -@istest -def underline_runs_can_be_mapped_using_style_mapping(): +def test_underline_runs_can_be_mapped_using_style_mapping(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_underline=True), style_map=[ @@ -200,8 +181,7 @@ def underline_runs_can_be_mapped_using_style_mapping(): assert_equal("<em>Hello</em>", result.value) -@istest -def style_mapping_for_underline_runs_does_not_close_parent_elements(): +def test_style_mapping_for_underline_runs_does_not_close_parent_elements(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_underline=True, is_bold=True), style_map=[ @@ -211,16 +191,14 @@ def style_mapping_for_underline_runs_does_not_close_parent_elements(): assert_equal("<strong><em>Hello</em></strong>", result.value) -@istest -def strikethrough_runs_are_wrapped_in_s_elements_by_default(): +def test_strikethrough_runs_are_wrapped_in_s_elements_by_default(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_strikethrough=True), ) assert_equal("<s>Hello</s>", result.value) -@istest -def strikethrough_runs_can_be_configured_with_style_mapping(): +def test_strikethrough_runs_can_be_configured_with_style_mapping(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_strikethrough=True), style_map=[ @@ -230,16 +208,14 @@ def strikethrough_runs_can_be_configured_with_style_mapping(): assert_equal("<del>Hello</del>", result.value) -@istest -def sml_caps_runs_are_ignored_by_default(): +def test_sml_caps_runs_are_ignored_by_default(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_all_caps=True), ) assert_equal("Hello", result.value) -@istest -def all_caps_runs_can_be_mapped_using_style_mapping(): +def test_all_caps_runs_can_be_mapped_using_style_mapping(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_all_caps=True), style_map=[ @@ -249,16 +225,14 @@ def all_caps_runs_can_be_mapped_using_style_mapping(): assert_equal("<span>Hello</span>", result.value) -@istest -def small_caps_runs_are_ignored_by_default(): +def test_small_caps_runs_are_ignored_by_default(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_small_caps=True), ) assert_equal("Hello", result.value) -@istest -def small_caps_runs_can_be_mapped_using_style_mapping(): +def test_small_caps_runs_can_be_mapped_using_style_mapping(): result = convert_document_element_to_html( documents.run(children=[documents.text("Hello")], is_small_caps=True), style_map=[ @@ -268,8 +242,7 @@ def small_caps_runs_can_be_mapped_using_style_mapping(): assert_equal("<span>Hello</span>", result.value) -@istest -def superscript_runs_are_wrapped_in_sup_tags(): +def test_superscript_runs_are_wrapped_in_sup_tags(): result = convert_document_element_to_html( documents.run( children=[documents.text("Hello")], @@ -279,8 +252,7 @@ def superscript_runs_are_wrapped_in_sup_tags(): assert_equal("<sup>Hello</sup>", result.value) -@istest -def subscript_runs_are_wrapped_in_sub_tags(): +def test_subscript_runs_are_wrapped_in_sub_tags(): result = convert_document_element_to_html( documents.run( children=[documents.text("Hello")], @@ -290,8 +262,7 @@ def subscript_runs_are_wrapped_in_sub_tags(): assert_equal("<sub>Hello</sub>", result.value) -@istest -def runs_are_converted_by_satisfying_matching_paths(): +def test_runs_are_converted_by_satisfying_matching_paths(): result = convert_document_element_to_html( documents.run(style_id="TipsRun", children=[documents.Text("Tip")]), style_map=[ @@ -301,16 +272,14 @@ def runs_are_converted_by_satisfying_matching_paths(): assert_equal('<span class="tip">Tip</span>', result.value) -@istest -def docx_hyperlink_with_href_is_converted_to_anchor_tag(): +def test_docx_hyperlink_with_href_is_converted_to_anchor_tag(): result = convert_document_element_to_html( documents.hyperlink(href="http://example.com", children=[documents.Text("Hello")]), ) assert_equal('<a href="http://example.com">Hello</a>', result.value) -@istest -def docx_hyperlinks_can_be_collapsed(): +def test_docx_hyperlinks_can_be_collapsed(): result = convert_document_element_to_html( documents.document(children=[ documents.hyperlink(href="http://example.com", children=[documents.Text("Hello ")]), @@ -320,8 +289,7 @@ def docx_hyperlinks_can_be_collapsed(): assert_equal('<a href="http://example.com">Hello world</a>', result.value) -@istest -def docx_hyperlink_with_internal_anchor_reference_is_converted_to_anchor_tag(): +def test_docx_hyperlink_with_internal_anchor_reference_is_converted_to_anchor_tag(): result = convert_document_element_to_html( documents.hyperlink(anchor="start", children=[documents.Text("Hello")]), id_prefix="doc-42-", @@ -329,8 +297,7 @@ def docx_hyperlink_with_internal_anchor_reference_is_converted_to_anchor_tag(): assert_equal('<a href="#doc-42-start">Hello</a>', result.value) -@istest -def hyperlink_target_frame_is_used_as_anchor_target(): +def test_hyperlink_target_frame_is_used_as_anchor_target(): result = convert_document_element_to_html( documents.hyperlink( anchor="start", @@ -341,8 +308,7 @@ def hyperlink_target_frame_is_used_as_anchor_target(): assert_equal('<a href="#start" target="_blank">Hello</a>', result.value) -@istest -def bookmarks_are_converted_to_anchors_with_ids(): +def test_bookmarks_are_converted_to_anchors_with_ids(): result = convert_document_element_to_html( documents.bookmark(name="start"), id_prefix="doc-42-", @@ -350,14 +316,12 @@ def bookmarks_are_converted_to_anchors_with_ids(): assert_equal('<a id="doc-42-start"></a>', result.value) -@istest -def docx_tab_is_converted_to_tab_in_html(): +def test_docx_tab_is_converted_to_tab_in_html(): result = convert_document_element_to_html(documents.tab()) assert_equal('\t', result.value) -@istest -def docx_table_is_converted_to_table_in_html(): +def test_docx_table_is_converted_to_table_in_html(): table = documents.table([ documents.table_row([ documents.table_cell([_paragraph_with_text("Top left")]), @@ -377,8 +341,7 @@ def docx_table_is_converted_to_table_in_html(): assert_equal(expected_html, result.value) -@istest -def table_style_mappings_can_be_used_to_map_tables(): +def test_table_style_mappings_can_be_used_to_map_tables(): table = documents.table([], style_name="Normal Table") result = convert_document_element_to_html( table, @@ -390,8 +353,7 @@ def table_style_mappings_can_be_used_to_map_tables(): assert_equal(expected_html, result.value) -@istest -def header_rows_are_wrapped_in_thead(): +def test_header_rows_are_wrapped_in_thead(): table = documents.table([ documents.table_row([documents.table_cell([])], is_header=True), documents.table_row([documents.table_cell([])], is_header=True), @@ -406,8 +368,7 @@ def header_rows_are_wrapped_in_thead(): assert_equal(expected_html, result.value) -@istest -def tbody_is_omitted_if_all_rows_are_headers(): +def test_tbody_is_omitted_if_all_rows_are_headers(): table = documents.table([ documents.table_row([documents.table_cell([])], is_header=True), ]) @@ -419,8 +380,7 @@ def tbody_is_omitted_if_all_rows_are_headers(): assert_equal(expected_html, result.value) -@istest -def unexpected_table_children_do_not_cause_error(): +def test_unexpected_table_children_do_not_cause_error(): table = documents.table([ documents.tab(), ]) @@ -429,8 +389,7 @@ def unexpected_table_children_do_not_cause_error(): assert_equal(expected_html, result.value) -@istest -def empty_cells_are_preserved_in_table(): +def test_empty_cells_are_preserved_in_table(): table = documents.table([ documents.table_row([ documents.table_cell([_paragraph_with_text("")]), @@ -445,8 +404,7 @@ def empty_cells_are_preserved_in_table(): assert_equal(expected_html, result.value) -@istest -def empty_rows_are_preserved_in_table(): +def test_empty_rows_are_preserved_in_table(): table = documents.table([ documents.table_row([ documents.table_cell([_paragraph_with_text("Row 1")]), @@ -461,8 +419,7 @@ def empty_rows_are_preserved_in_table(): assert_equal(expected_html, result.value) -@istest -def table_cells_are_written_with_colspan_if_not_equal_to_one(): +def test_table_cells_are_written_with_colspan_if_not_equal_to_one(): table = documents.table([ documents.table_row([ documents.table_cell([_paragraph_with_text("Top left")], colspan=2), @@ -477,8 +434,7 @@ def table_cells_are_written_with_colspan_if_not_equal_to_one(): assert_equal(expected_html, result.value) -@istest -def table_cells_are_written_with_rowspan_if_not_equal_to_one(): +def test_table_cells_are_written_with_rowspan_if_not_equal_to_one(): table = documents.table([ documents.table_row([ documents.table_cell([], rowspan=2), @@ -492,20 +448,17 @@ def table_cells_are_written_with_rowspan_if_not_equal_to_one(): assert_equal(expected_html, result.value) -@istest -def line_break_is_converted_to_br(): +def test_line_break_is_converted_to_br(): result = convert_document_element_to_html(documents.line_break) assert_equal("<br />", result.value) -@istest -def breaks_that_are_not_line_breaks_are_ignored(): +def test_breaks_that_are_not_line_breaks_are_ignored(): result = convert_document_element_to_html(documents.page_break) assert_equal("", result.value) -@istest -def breaks_can_be_mapped_using_style_mappings(): +def test_breaks_can_be_mapped_using_style_mappings(): result = convert_document_element_to_html( documents.page_break, style_map=[ @@ -515,23 +468,20 @@ def breaks_can_be_mapped_using_style_mappings(): assert_equal("<hr />", result.value) -@istest -def images_are_converted_to_img_tags_with_data_uri(): +def test_images_are_converted_to_img_tags_with_data_uri(): image = documents.image(alt_text=None, content_type="image/png", open=lambda: io.BytesIO(b"abc")) result = convert_document_element_to_html(image) assert_equal('<img src="data:image/png;base64,YWJj" />', result.value) -@istest -def images_have_alt_tags_if_available(): +def test_images_have_alt_tags_if_available(): image = documents.image(alt_text="It's a hat", content_type="image/png", open=lambda: io.BytesIO(b"abc")) result = convert_document_element_to_html(image) image_html = parse_xml(io.StringIO(result.value)) assert_equal('It\'s a hat', image_html.attributes["alt"]) -@istest -def can_define_custom_conversion_for_images(): +def test_can_define_custom_conversion_for_images(): def convert_image(image): with image.open() as image_file: return [html.element("img", {"alt": image_file.read().decode("ascii")})] @@ -541,8 +491,7 @@ def can_define_custom_conversion_for_images(): assert_equal('<img alt="abc" />', result.value) -@istest -def footnote_reference_is_converted_to_superscript_intra_page_link(): +def test_footnote_reference_is_converted_to_superscript_intra_page_link(): footnote_reference = documents.note_reference("footnote", "4") result = convert_document_element_to_html( footnote_reference, @@ -551,8 +500,7 @@ def footnote_reference_is_converted_to_superscript_intra_page_link(): assert_equal('<sup><a href="#doc-42-footnote-4" id="doc-42-footnote-ref-4">[1]</a></sup>', result.value) -@istest -def footnotes_are_included_after_the_main_body(): +def test_footnotes_are_included_after_the_main_body(): footnote_reference = documents.note_reference("footnote", "4") document = documents.document( [documents.paragraph([ @@ -572,8 +520,7 @@ def footnotes_are_included_after_the_main_body(): assert_equal(expected_html, result.value) -@istest -def comments_are_ignored_by_default(): +def test_comments_are_ignored_by_default(): reference = documents.comment_reference("4") comment = documents.comment( comment_id="4", @@ -591,8 +538,7 @@ def comments_are_ignored_by_default(): assert_equal(expected_html, result.value) -@istest -def comment_references_are_linked_to_comment_after_main_body(): +def test_comment_references_are_linked_to_comment_after_main_body(): reference = documents.comment_reference("4") comment = documents.comment( comment_id="4", @@ -621,8 +567,7 @@ def comment_references_are_linked_to_comment_after_main_body(): assert_equal(expected_html, result.value) -@istest -def when_initials_are_not_blank_then_comment_author_label_is_initials(): +def test_when_initials_are_not_blank_then_comment_author_label_is_initials(): assert_equal("TP", _comment_author_label(documents.comment( comment_id="0", body=[], @@ -630,8 +575,7 @@ def when_initials_are_not_blank_then_comment_author_label_is_initials(): ))) -@istest -def when_initials_are_blank_then_comment_author_label_is_blank(): +def test_when_initials_are_blank_then_comment_author_label_is_blank(): assert_equal("", _comment_author_label(documents.comment( comment_id="0", body=[], diff --git a/tests/docx/body_xml_tests.py b/tests/docx/body_xml_tests.py index d7f5509..eade1e6 100644 --- a/tests/docx/body_xml_tests.py +++ b/tests/docx/body_xml_tests.py @@ -3,10 +3,9 @@ import io import sys -from precisely import assert_that, is_sequence -from nose.tools import istest, assert_equal -from nose_parameterized import parameterized, param import funk +from precisely import assert_that, is_sequence +import pytest from mammoth import documents, results from mammoth.docx.xmlparser import element as xml_element, text as xml_text @@ -23,27 +22,25 @@ from .document_matchers import ( is_table, is_row, ) +from ..testing import assert_equal if sys.version_info >= (3, ): unichr = chr -@istest -def text_from_text_element_is_read(): +def test_text_from_text_element_is_read(): element = _text_element("Hello!") assert_equal(documents.Text("Hello!"), _read_and_get_document_xml_element(element)) -@istest -def can_read_text_within_run(): +def test_can_read_text_within_run(): element = _run_element_with_text("Hello!") assert_equal( documents.run([documents.Text("Hello!")]), _read_and_get_document_xml_element(element) ) -@istest -def can_read_text_within_paragraph(): +def test_can_read_text_within_paragraph(): element = _paragraph_element_with_text("Hello!") assert_equal( documents.paragraph([documents.run([documents.Text("Hello!")])]), @@ -51,15 +48,12 @@ def can_read_text_within_paragraph(): ) -@istest class ParagraphTests(object): - @istest - def paragraph_has_no_style_if_it_has_no_properties(self): + def test_paragraph_has_no_style_if_it_has_no_properties(self): element = xml_element("w:p") assert_equal(None, _read_and_get_document_xml_element(element).style_id) - @istest - def paragraph_has_style_id_and_name_read_from_paragraph_properties_if_present(self): + def test_paragraph_has_style_id_and_name_read_from_paragraph_properties_if_present(self): style_xml = xml_element("w:pStyle", {"w:val": "Heading1"}) properties_xml = xml_element("w:pPr", {}, [style_xml]) paragraph_xml = xml_element("w:p", {}, [properties_xml]) @@ -72,8 +66,7 @@ class ParagraphTests(object): assert_equal("Heading1", paragraph.style_id) assert_equal("Heading 1", paragraph.style_name) - @istest - def warning_is_emitted_when_paragraph_style_cannot_be_found(self): + def test_warning_is_emitted_when_paragraph_style_cannot_be_found(self): style_xml = xml_element("w:pStyle", {"w:val": "Heading1"}) properties_xml = xml_element("w:pPr", {}, [style_xml]) paragraph_xml = xml_element("w:p", {}, [properties_xml]) @@ -84,27 +77,23 @@ class ParagraphTests(object): assert_equal(None, paragraph.style_name) assert_equal([results.warning("Paragraph style with ID Heading1 was referenced but not defined in the document")], result.messages) - @istest - def paragraph_has_no_justification_if_it_has_no_justificiation_properties(self): + def test_paragraph_has_no_justification_if_it_has_no_justificiation_properties(self): paragraph_xml = xml_element("w:p") paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal(None, paragraph.alignment) - @istest - def paragraph_has_justification_read_from_paragraph_properties_if_present(self): + def test_paragraph_has_justification_read_from_paragraph_properties_if_present(self): justification_xml = xml_element("w:jc", {"w:val": "center"}) properties_xml = xml_element("w:pPr", {}, [justification_xml]) paragraph_xml = xml_element("w:p", {}, [properties_xml]) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("center", paragraph.alignment) - @istest - def paragraph_has_no_numbering_if_it_has_no_numbering_properties(self): + def test_paragraph_has_no_numbering_if_it_has_no_numbering_properties(self): element = xml_element("w:p") assert_equal(None, _read_and_get_document_xml_element(element).numbering) - @istest - def paragraph_has_numbering_properties_from_paragraph_properties_if_present(self): + def test_paragraph_has_numbering_properties_from_paragraph_properties_if_present(self): paragraph_xml = self._paragraph_with_numbering_properties([ xml_element("w:ilvl", {"w:val": "1"}), xml_element("w:numId", {"w:val": "42"}), @@ -116,8 +105,7 @@ class ParagraphTests(object): assert_equal("1", paragraph.numbering.level_index) assert_equal(True, paragraph.numbering.is_ordered) - @istest - def numbering_on_paragraph_style_takes_precedence_over_numpr(self): + def test_numbering_on_paragraph_style_takes_precedence_over_numpr(self): numbering_properties_xml = xml_element("w:numPr", {}, [ xml_element("w:ilvl", {"w:val": "1"}), xml_element("w:numId", {"w:val": "42"}), @@ -136,8 +124,7 @@ class ParagraphTests(object): assert_equal(True, paragraph.numbering.is_ordered) - @istest - def numbering_properties_are_ignored_if_lvl_is_missing(self): + def test_numbering_properties_are_ignored_if_lvl_is_missing(self): paragraph_xml = self._paragraph_with_numbering_properties([ xml_element("w:numId", {"w:val": "42"}), ]) @@ -147,8 +134,7 @@ class ParagraphTests(object): assert_equal(None, paragraph.numbering) - @istest - def numbering_properties_are_ignored_if_num_id_is_missing(self): + def test_numbering_properties_are_ignored_if_num_id_is_missing(self): paragraph_xml = self._paragraph_with_numbering_properties([ xml_element("w:ilvl", {"w:val": "1"}), ]) @@ -164,46 +150,38 @@ class ParagraphTests(object): return xml_element("w:p", {}, [properties_xml]) -@istest class ParagraphIndentTests(object): - @istest - def when_w_start_is_set_then_start_indent_is_read_from_w_start(self): + def test_when_w_start_is_set_then_start_indent_is_read_from_w_start(self): paragraph_xml = self._paragraph_with_indent({"w:start": "720", "w:left": "40"}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("720", paragraph.indent.start) - @istest - def when_w_start_is_not_set_then_start_indent_is_read_from_w_left(self): + def test_when_w_start_is_not_set_then_start_indent_is_read_from_w_left(self): paragraph_xml = self._paragraph_with_indent({"w:left": "720"}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("720", paragraph.indent.start) - @istest - def when_w_end_is_set_then_end_indent_is_read_from_w_end(self): + def test_when_w_end_is_set_then_end_indent_is_read_from_w_end(self): paragraph_xml = self._paragraph_with_indent({"w:end": "720", "w:right": "40"}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("720", paragraph.indent.end) - @istest - def when_w_end_is_not_set_then_end_indent_is_read_from_w_right(self): + def test_when_w_end_is_not_set_then_end_indent_is_read_from_w_right(self): paragraph_xml = self._paragraph_with_indent({"w:right": "720"}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("720", paragraph.indent.end) - @istest - def paragraph_has_indent_first_line_read_from_paragraph_properties_if_present(self): + def test_paragraph_has_indent_first_line_read_from_paragraph_properties_if_present(self): paragraph_xml = self._paragraph_with_indent({"w:firstLine": "720"}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("720", paragraph.indent.first_line) - @istest - def paragraph_has_indent_hanging_read_from_paragraph_properties_if_present(self): + def test_paragraph_has_indent_hanging_read_from_paragraph_properties_if_present(self): paragraph_xml = self._paragraph_with_indent({"w:hanging": "720"}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal("720", paragraph.indent.hanging) - @istest - def when_indent_attributes_arent_set_then_indents_are_none(self): + def test_when_indent_attributes_arent_set_then_indents_are_none(self): paragraph_xml = self._paragraph_with_indent({}) paragraph = _read_and_get_document_xml_element(paragraph_xml) assert_equal(None, paragraph.indent.start) @@ -217,15 +195,12 @@ class ParagraphIndentTests(object): return xml_element("w:p", {}, [properties_xml]) -@istest class RunTests(object): - @istest - def run_has_no_style_if_it_has_no_properties(self): + def test_run_has_no_style_if_it_has_no_properties(self): element = xml_element("w:r") assert_equal(None, _read_and_get_document_xml_element(element).style_id) - @istest - def run_has_style_id_and_name_read_from_run_properties_if_present(self): + def test_run_has_style_id_and_name_read_from_run_properties_if_present(self): style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"}) styles = Styles.create( @@ -236,8 +211,7 @@ class RunTests(object): assert_equal("Heading1Char", run.style_id) assert_equal("Heading 1 Char", run.style_name) - @istest - def warning_is_emitted_when_run_style_cannot_be_found(self): + def test_warning_is_emitted_when_run_style_cannot_be_found(self): style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"}) properties_xml = xml_element("w:rPr", {}, [style_xml]) run_xml = xml_element("w:r", {}, [properties_xml]) @@ -249,139 +223,118 @@ class RunTests(object): assert_equal([results.warning("Run style with ID Heading1Char was referenced but not defined in the document")], result.messages) - @istest - def run_is_not_bold_if_bold_element_is_not_present(self): + def test_run_is_not_bold_if_bold_element_is_not_present(self): run = self._read_run_with_properties([]) assert_equal(False, run.is_bold) - @istest - def run_is_bold_if_bold_element_is_present(self): + def test_run_is_bold_if_bold_element_is_present(self): run = self._read_run_with_properties([xml_element("w:b")]) assert_equal(True, run.is_bold) - @istest - def run_is_not_italic_if_italic_element_is_not_present(self): + def test_run_is_not_italic_if_italic_element_is_not_present(self): run = self._read_run_with_properties([]) assert_equal(False, run.is_italic) - @istest - def run_is_italic_if_italic_element_is_present(self): + def test_run_is_italic_if_italic_element_is_present(self): run = self._read_run_with_properties([xml_element("w:i")]) assert_equal(True, run.is_italic) - @istest - def run_is_not_underlined_if_underline_element_is_not_present(self): + def test_run_is_not_underlined_if_underline_element_is_not_present(self): run = self._read_run_with_properties([]) assert_equal(False, run.is_underline) - @istest - def run_is_not_underlined_if_underline_element_is_present_without_val_attribute(self): + def test_run_is_not_underlined_if_underline_element_is_present_without_val_attribute(self): run = self._read_run_with_properties([xml_element("w:u")]) assert_equal(False, run.is_underline) - @istest - def run_is_not_underlined_if_underline_element_is_present_and_val_is_false(self): + def test_run_is_not_underlined_if_underline_element_is_present_and_val_is_false(self): run = self._read_run_with_properties([xml_element("w:u", {"w:val": "false"})]) assert_equal(False, run.is_underline) - @istest - def run_is_not_underlined_if_underline_element_is_present_and_val_is_0(self): + def test_run_is_not_underlined_if_underline_element_is_present_and_val_is_0(self): run = self._read_run_with_properties([xml_element("w:u", {"w:val": "0"})]) assert_equal(False, run.is_underline) - @istest - def run_is_not_underlined_if_underline_element_is_present_and_val_is_none(self): + def test_run_is_not_underlined_if_underline_element_is_present_and_val_is_none(self): run = self._read_run_with_properties([xml_element("w:u", {"w:val": "none"})]) assert_equal(False, run.is_underline) - @istest - def run_is_underlined_if_underline_element_is_present_and_val_is_not_none_or_falsy(self): + def test_run_is_underlined_if_underline_element_is_present_and_val_is_not_none_or_falsy(self): run = self._read_run_with_properties([xml_element("w:u", {"w:val": "single"})]) assert_equal(True, run.is_underline) - @istest - def run_is_not_struckthrough_if_strikethrough_element_is_not_present(self): + def test_run_is_not_struckthrough_if_strikethrough_element_is_not_present(self): run = self._read_run_with_properties([]) assert_equal(False, run.is_strikethrough) - @istest - def run_is_struckthrough_if_strikethrough_element_is_present(self): + def test_run_is_struckthrough_if_strikethrough_element_is_present(self): run = self._read_run_with_properties([xml_element("w:strike")]) assert_equal(True, run.is_strikethrough) - @istest - def run_is_not_small_caps_if_small_caps_element_is_not_present(self): + def test_run_is_not_small_caps_if_small_caps_element_is_not_present(self): run = self._read_run_with_properties([]) assert_equal(False, run.is_small_caps) - @istest - def run_is_small_caps_if_small_caps_element_is_present(self): + def test_run_is_small_caps_if_small_caps_element_is_present(self): run = self._read_run_with_properties([xml_element("w:smallCaps")]) assert_equal(True, run.is_small_caps) - run_boolean_property_test = lambda func: parameterized([ - param(attr_name="is_bold", tag_name="w:b"), - param(attr_name="is_underline", tag_name="w:u"), - param(attr_name="is_italic", tag_name="w:i"), - param(attr_name="is_strikethrough", tag_name="w:strike"), - param(attr_name="is_all_caps", tag_name="w:caps"), - param(attr_name="is_small_caps", tag_name="w:smallCaps"), - ])(istest(func)) - - @run_boolean_property_test - def run_boolean_property_is_false_if_element_is_present_and_val_is_false(self, attr_name, tag_name): + run_boolean_property_test_params = [ + ("is_bold", "w:b"), + ("is_underline", "w:u"), + ("is_italic", "w:i"), + ("is_strikethrough", "w:strike"), + ("is_all_caps", "w:caps"), + ("is_small_caps", "w:smallCaps"), + ] + + @pytest.mark.parametrize("attr_name, tag_name", run_boolean_property_test_params) + def test_run_boolean_property_is_false_if_element_is_present_and_val_is_false(self, attr_name, tag_name): run = self._read_run_with_properties([xml_element(tag_name, {"w:val": "false"})]) assert_equal(False, getattr(run, attr_name)) - @run_boolean_property_test - def run_boolean_property_is_false_if_element_is_present_and_val_is_0(self, attr_name, tag_name): + @pytest.mark.parametrize("attr_name, tag_name", run_boolean_property_test_params) + def test_run_boolean_property_is_false_if_element_is_present_and_val_is_0(self, attr_name, tag_name): run = self._read_run_with_properties([xml_element(tag_name, {"w:val": "0"})]) assert_equal(False, getattr(run, attr_name)) - @run_boolean_property_test - def run_boolean_property_is_true_if_element_is_present_and_val_is_true(self, attr_name, tag_name): + @pytest.mark.parametrize("attr_name, tag_name", run_boolean_property_test_params) + def test_run_boolean_property_is_true_if_element_is_present_and_val_is_true(self, attr_name, tag_name): run = self._read_run_with_properties([xml_element(tag_name, {"w:val": "true"})]) assert_equal(True, getattr(run, attr_name)) - @run_boolean_property_test - def run_boolean_property_is_true_if_element_is_present_and_val_is_1(self, attr_name, tag_name): + @pytest.mark.parametrize("attr_name, tag_name", run_boolean_property_test_params) + def test_run_boolean_property_is_true_if_element_is_present_and_val_is_1(self, attr_name, tag_name): run = self._read_run_with_properties([xml_element(tag_name, {"w:val": "1"})]) assert_equal(True, getattr(run, attr_name)) - @istest - def run_has_baseline_vertical_alignment_if_vertical_alignment_element_is_not_present(self): + def test_run_has_baseline_vertical_alignment_if_vertical_alignment_element_is_not_present(self): run = self._read_run_with_properties([]) assert_equal(documents.VerticalAlignment.baseline, run.vertical_alignment) - @istest - def run_has_vertical_alignment_read_from_vertical_alignment_element(self): + def test_run_has_vertical_alignment_read_from_vertical_alignment_element(self): run = self._read_run_with_properties([xml_element("w:vertAlign", {"w:val": "superscript"})]) assert_equal(documents.VerticalAlignment.superscript, run.vertical_alignment) - @istest - def run_has_none_font_by_default(self): + def test_run_has_none_font_by_default(self): run = self._read_run_with_properties([]) assert_equal(None, run.font) - @istest - def run_has_font_read_from_properties(self): + def test_run_has_font_read_from_properties(self): font_xml = xml_element("w:rFonts", {"w:ascii": "Arial"}) run = self._read_run_with_properties([font_xml]) assert_equal("Arial", run.font) - @istest - def run_has_none_font_size_by_default(self): + def test_run_has_none_font_size_by_default(self): run = self._read_run_with_properties([]) assert_equal(None, run.font_size) - @istest - def run_has_font_size_read_from_properties(self): + def test_run_has_font_size_read_from_properties(self): font_size_xml = xml_element("w:sz", {"w:val": "28"}) run = self._read_run_with_properties([font_size_xml]) assert_equal(14, run.font_size) - @istest - def run_with_invalid_w_sz_has_none_font_size(self): + def test_run_with_invalid_w_sz_has_none_font_size(self): font_size_xml = xml_element("w:sz", {"w:val": "28a"}) run = self._read_run_with_properties([font_size_xml]) assert_equal(None, run.font_size) @@ -392,7 +345,6 @@ class RunTests(object): return _read_and_get_document_xml_element(run_xml, styles=styles) -@istest class ComplexFieldTests(object): _URI = "http://example.com" _BEGIN_COMPLEX_FIELD = xml_element("w:r", {}, [ @@ -417,8 +369,7 @@ class ComplexFieldTests(object): def _is_empty_hyperlinked_run(self): return self._is_hyperlinked_run(children=[]) - @istest - def runs_in_a_complex_field_for_hyperlinks_without_switch_are_read_as_external_hyperlinks(self): + def test_runs_in_a_complex_field_for_hyperlinks_without_switch_are_read_as_external_hyperlinks(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, self._HYPERLINK_INSTRTEXT, @@ -440,8 +391,7 @@ class ComplexFieldTests(object): is_empty_run, ))) - @istest - def runs_in_a_complex_field_for_hyperlinks_with_l_switch_are_read_as_internal_hyperlinks(self): + def test_runs_in_a_complex_field_for_hyperlinks_with_l_switch_are_read_as_internal_hyperlinks(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, xml_element("w:instrText", {}, [ @@ -465,8 +415,7 @@ class ComplexFieldTests(object): is_empty_run, ))) - @istest - def runs_after_a_complex_field_for_hyperlinks_are_not_read_as_hyperlinks(self): + def test_runs_after_a_complex_field_for_hyperlinks_are_not_read_as_hyperlinks(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, self._HYPERLINK_INSTRTEXT, @@ -485,8 +434,7 @@ class ComplexFieldTests(object): )), ))) - @istest - def can_handle_split_instr_text_elements(self): + def test_can_handle_split_instr_text_elements(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, xml_element("w:instrText", {}, [ @@ -513,8 +461,7 @@ class ComplexFieldTests(object): is_empty_run, ))) - @istest - def hyperlink_is_not_ended_by_end_of_nested_complex_field(self): + def test_hyperlink_is_not_ended_by_end_of_nested_complex_field(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, self._HYPERLINK_INSTRTEXT, @@ -545,8 +492,7 @@ class ComplexFieldTests(object): is_empty_run, ))) - @istest - def complex_field_nested_within_a_hyperlink_complex_field_is_wrapped_with_the_hyperlink(self): + def test_complex_field_nested_within_a_hyperlink_complex_field_is_wrapped_with_the_hyperlink(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, self._HYPERLINK_INSTRTEXT, @@ -577,8 +523,7 @@ class ComplexFieldTests(object): is_empty_run, ))) - @istest - def field_without_separate_fld_char_is_ignored(self): + def test_field_without_separate_fld_char_is_ignored(self): element = xml_element("w:p", {}, [ self._BEGIN_COMPLEX_FIELD, self._HYPERLINK_INSTRTEXT, @@ -605,43 +550,37 @@ class ComplexFieldTests(object): ))) -@istest -def can_read_tab_element(): +def test_can_read_tab_element(): element = xml_element("w:tab") tab = _read_and_get_document_xml_element(element) assert_equal(documents.tab(), tab) -@istest -def no_break_hyphen_element_is_read_as_non_breaking_hyphen_character(): +def test_no_break_hyphen_element_is_read_as_non_breaking_hyphen_character(): element = xml_element("w:noBreakHyphen") tab = _read_and_get_document_xml_element(element) assert_equal(documents.text(unichr(0x2011)), tab) -@istest -def soft_hyphen_element_is_read_as_soft_hyphen_character(): +def test_soft_hyphen_element_is_read_as_soft_hyphen_character(): element = xml_element("w:softHyphen") tab = _read_and_get_document_xml_element(element) assert_equal(documents.text(u"\u00ad"), tab) -@istest -def w_sym_with_supported_font_and_supported_code_point_in_ascii_range_is_converted_to_text(): +def test_w_sym_with_supported_font_and_supported_code_point_in_ascii_range_is_converted_to_text(): element = xml_element("w:sym", {"w:font": "Wingdings", "w:char": "28"}) text = _read_and_get_document_xml_element(element) assert_equal(documents.text(u"🕿"), text) -@istest -def w_sym_with_supported_font_and_supported_code_point_in_private_use_area_is_converted_to_text(): +def test_w_sym_with_supported_font_and_supported_code_point_in_private_use_area_is_converted_to_text(): element = xml_element("w:sym", {"w:font": "Wingdings", "w:char": "F028"}) text = _read_and_get_document_xml_element(element) assert_equal(documents.text(u"🕿"), text) -@istest -def w_sym_with_unsupported_font_and_code_point_produces_empty_result_with_warning(): +def test_w_sym_with_unsupported_font_and_code_point_produces_empty_result_with_warning(): element = xml_element("w:sym", {"w:font": "Dingwings", "w:char": "28"}) result = _read_document_xml_element(element) @@ -651,10 +590,8 @@ def w_sym_with_unsupported_font_and_code_point_produces_empty_result_with_warnin assert_equal(None, result.value) -@istest class TableTests(object): - @istest - def word_table_is_read_as_document_table_element(self): + def test_word_table_is_read_as_document_table_element(self): element = xml_element("w:tbl", {}, [ xml_element("w:tr", {}, [ xml_element("w:tc", {}, [ @@ -672,13 +609,11 @@ class TableTests(object): ]) assert_equal(expected_result, table) - @istest - def table_has_no_style_if_it_has_no_properties(self): + def test_table_has_no_style_if_it_has_no_properties(self): element = xml_element("w:tbl") assert_equal(None, _read_and_get_document_xml_element(element).style_id) - @istest - def table_has_style_id_and_name_read_from_paragraph_properties_if_present(self): + def test_table_has_style_id_and_name_read_from_paragraph_properties_if_present(self): style_xml = xml_element("w:tblStyle", {"w:val": "TableNormal"}) properties_xml = xml_element("w:tblPr", {}, [style_xml]) table_xml = xml_element("w:tbl", {}, [properties_xml]) @@ -691,8 +626,7 @@ class TableTests(object): assert_equal("TableNormal", paragraph.style_id) assert_equal("Normal Table", paragraph.style_name) - @istest - def warning_is_emitted_when_table_style_cannot_be_found(self): + def test_warning_is_emitted_when_table_style_cannot_be_found(self): style_xml = xml_element("w:tblStyle", {"w:val": "TableNormal"}) properties_xml = xml_element("w:tblPr", {}, [style_xml]) table_xml = xml_element("w:tbl", {}, [properties_xml]) @@ -703,8 +637,7 @@ class TableTests(object): assert_equal(None, table.style_name) assert_equal([results.warning("Table style with ID TableNormal was referenced but not defined in the document")], result.messages) - @istest - def tbl_header_marks_table_row_as_header(self): + def test_tbl_header_marks_table_row_as_header(self): element = xml_element("w:tbl", {}, [ xml_element("w:tr", {}, [ xml_element("w:trPr", {}, [ @@ -722,8 +655,7 @@ class TableTests(object): )) - @istest - def gridspan_is_read_as_colspan_for_table_cell(self): + def test_gridspan_is_read_as_colspan_for_table_cell(self): element = xml_element("w:tbl", {}, [ xml_element("w:tr", {}, [ xml_element("w:tc", {}, [ @@ -745,8 +677,7 @@ class TableTests(object): assert_equal(expected_result, table) - @istest - def vmerge_is_read_as_rowspan_for_table_cell(self): + def test_vmerge_is_read_as_rowspan_for_table_cell(self): element = xml_element("w:tbl", {}, [ w_tr(w_tc()), w_tr(w_tc(properties=[w_vmerge("restart")])), @@ -765,8 +696,7 @@ class TableTests(object): assert_equal(expected_result, result) - @istest - def vmerge_without_val_is_treated_as_continue(self): + def test_vmerge_without_val_is_treated_as_continue(self): element = xml_element("w:tbl", {}, [ w_tr(w_tc(properties=[w_vmerge("restart")])), w_tr(w_tc(properties=[w_vmerge(None)])), @@ -779,8 +709,7 @@ class TableTests(object): assert_equal(expected_result, result) - @istest - def vmerge_accounts_for_cells_spanning_columns(self): + def test_vmerge_accounts_for_cells_spanning_columns(self): element = xml_element("w:tbl", {}, [ w_tr(w_tc(), w_tc(), w_tc(properties=[w_vmerge("restart")])), w_tr(w_tc(properties=[w_gridspan("2")]), w_tc(properties=[w_vmerge("continue")])), @@ -797,8 +726,7 @@ class TableTests(object): assert_equal(expected_result, result) - @istest - def no_vertical_cell_merging_if_merged_cells_do_not_line_up(self): + def test_no_vertical_cell_merging_if_merged_cells_do_not_line_up(self): element = xml_element("w:tbl", {}, [ w_tr(w_tc(properties=[w_gridspan("2")]), w_tc(properties=[w_vmerge("restart")])), w_tr(w_tc(), w_tc(properties=[w_vmerge("continue")])), @@ -811,42 +739,35 @@ class TableTests(object): assert_equal(expected_result, result) - @istest - def warning_if_non_row_in_table(self): + def test_warning_if_non_row_in_table(self): element = xml_element("w:tbl", {}, [xml_element("w:p")]) result = _read_document_xml_element(element) expected_warning = results.warning("unexpected non-row element in table, cell merging may be incorrect") assert_equal([expected_warning], result.messages) - @istest - def warning_if_non_cell_in_table_row(self): + def test_warning_if_non_cell_in_table_row(self): element = xml_element("w:tbl", {}, [w_tr(xml_element("w:p"))]) result = _read_document_xml_element(element) expected_warning = results.warning("unexpected non-cell element in table row, cell merging may be incorrect") assert_equal([expected_warning], result.messages) -@istest -def children_of_w_ins_are_converted_normally(): +def test_children_of_w_ins_are_converted_normally(): _assert_children_are_converted_normally("w:ins") -@istest -def children_of_w_object_are_converted_normally(): +def test_children_of_w_object_are_converted_normally(): _assert_children_are_converted_normally("w:object") -@istest -def children_of_w_smart_tag_are_converted_normally(): +def test_children_of_w_smart_tag_are_converted_normally(): _assert_children_are_converted_normally("w:smartTag") -@istest -def children_of_v_group_are_converted_normally(): +def test_children_of_v_group_are_converted_normally(): _assert_children_are_converted_normally("v:group") -@istest -def children_of_v_rect_are_converted_normally(): +def test_children_of_v_rect_are_converted_normally(): _assert_children_are_converted_normally("v:rect") @@ -862,10 +783,8 @@ def _assert_children_are_converted_normally(tag_name): ) -@istest class HyperlinkTests(object): - @istest - def hyperlink_is_read_as_external_hyperlink_if_it_has_a_relationship_id(self): + def test_hyperlink_is_read_as_external_hyperlink_if_it_has_a_relationship_id(self): relationships = Relationships([ _hyperlink_relationship("r42", "http://example.com"), ]) @@ -876,8 +795,7 @@ class HyperlinkTests(object): _read_and_get_document_xml_element(element, relationships=relationships) ) - @istest - def hyperlink_is_read_as_external_hyperlink_if_it_has_a_relationship_id_and_an_anchor(self): + def test_hyperlink_is_read_as_external_hyperlink_if_it_has_a_relationship_id_and_an_anchor(self): relationships = Relationships([ _hyperlink_relationship("r42", "http://example.com/"), ]) @@ -888,8 +806,7 @@ class HyperlinkTests(object): _read_and_get_document_xml_element(element, relationships=relationships) ) - @istest - def existing_fragment_is_replaced_when_anchor_is_set_on_external_link(self): + def test_existing_fragment_is_replaced_when_anchor_is_set_on_external_link(self): relationships = Relationships([ _hyperlink_relationship("r42", "http://example.com/#previous"), ]) @@ -900,8 +817,7 @@ class HyperlinkTests(object): _read_and_get_document_xml_element(element, relationships=relationships) ) - @istest - def hyperlink_is_read_as_internal_hyperlink_if_it_has_an_anchor_attribute(self): + def test_hyperlink_is_read_as_internal_hyperlink_if_it_has_an_anchor_attribute(self): run_element = xml_element("w:r") element = xml_element("w:hyperlink", {"w:anchor": "start"}, [run_element]) assert_equal( @@ -909,8 +825,7 @@ class HyperlinkTests(object): _read_and_get_document_xml_element(element) ) - @istest - def hyperlink_is_ignored_if_it_does_not_have_a_relationship_id_nor_anchor(self): + def test_hyperlink_is_ignored_if_it_does_not_have_a_relationship_id_nor_anchor(self): run_element = xml_element("w:r") element = xml_element("w:hyperlink", {}, [run_element]) assert_equal( @@ -918,8 +833,7 @@ class HyperlinkTests(object): _read_and_get_document_xml_element(element) ) - @istest - def target_frame_is_read(self): + def test_target_frame_is_read(self): element = xml_element("w:hyperlink", { "w:anchor": "start", "w:tgtFrame": "_blank", @@ -929,8 +843,7 @@ class HyperlinkTests(object): is_hyperlink(target_frame="_blank"), ) - @istest - def empty_target_frame_is_ignored(self): + def test_empty_target_frame_is_ignored(self): element = xml_element("w:hyperlink", { "w:anchor": "start", "w:tgtFrame": "", @@ -941,15 +854,12 @@ class HyperlinkTests(object): ) -@istest class BookmarkTests(object): - @istest - def go_back_bookmark_is_ignored(self): + def test_go_back_bookmark_is_ignored(self): element = xml_element("w:bookmarkStart", {"w:name": "_GoBack"}) assert_equal(None, _read_and_get_document_xml_element(element)) - @istest - def bookmark_start_is_read_if_name_is_not_go_back(self): + def test_bookmark_start_is_read_if_name_is_not_go_back(self): element = xml_element("w:bookmarkStart", {"w:name": "start"}) assert_equal( documents.bookmark("start"), @@ -957,34 +867,28 @@ class BookmarkTests(object): ) -@istest class BreakTests(object): - @istest - def br_without_explicit_type_is_read_as_line_break(self): + def test_br_without_explicit_type_is_read_as_line_break(self): break_element = xml_element("w:br", {}, []) result = _read_document_xml_element(break_element) assert_equal(documents.line_break, result.value) - @istest - def br_with_text_wrapping_type_is_read_as_line_break(self): + def test_br_with_text_wrapping_type_is_read_as_line_break(self): break_element = xml_element("w:br", {"w:type": "textWrapping"}, []) result = _read_document_xml_element(break_element) assert_equal(documents.line_break, result.value) - @istest - def br_with_page_type_is_read_as_page_break(self): + def test_br_with_page_type_is_read_as_page_break(self): break_element = xml_element("w:br", {"w:type": "page"}, []) result = _read_document_xml_element(break_element) assert_equal(documents.page_break, result.value) - @istest - def br_with_column_type_is_read_as_column_break(self): + def test_br_with_column_type_is_read_as_column_break(self): break_element = xml_element("w:br", {"w:type": "column"}, []) result = _read_document_xml_element(break_element) assert_equal(documents.column_break, result.value) - @istest - def warning_on_break_types_that_arent_recognised(self): + def test_warning_on_break_types_that_arent_recognised(self): break_element = xml_element("w:br", {"w:type": "unknownBreakType"}, []) result = _read_document_xml_element(break_element) expected_warning = results.warning("Unsupported break type: unknownBreakType") @@ -992,7 +896,6 @@ class BreakTests(object): assert_equal(None, result.value) -@istest class ImageTests(object): IMAGE_BYTES = b"Not an image at all!" IMAGE_RELATIONSHIP_ID = "rId5" @@ -1016,8 +919,7 @@ class ImageTests(object): docx_file=docx_file, ) - @istest - def can_read_imagedata_elements_with_rid_attribute(self): + def test_can_read_imagedata_elements_with_rid_attribute(self): imagedata_element = xml_element("v:imagedata", { "r:id": self.IMAGE_RELATIONSHIP_ID, "o:title": "It's a hat" @@ -1031,8 +933,7 @@ class ImageTests(object): with image.open() as image_file: assert_equal(self.IMAGE_BYTES, image_file.read()) - @istest - def when_imagedata_element_has_no_relationship_id_then_it_is_ignored_with_warning(self): + def test_when_imagedata_element_has_no_relationship_id_then_it_is_ignored_with_warning(self): imagedata_element = xml_element("v:imagedata") result = _read_document_xml_element(imagedata_element) @@ -1041,8 +942,7 @@ class ImageTests(object): assert_equal(None, result.value) - @istest - def can_read_inline_pictures(self): + def test_can_read_inline_pictures(self): drawing_element = _create_inline_image( blip=_embedded_blip(self.IMAGE_RELATIONSHIP_ID), description="It's a hat", @@ -1057,8 +957,7 @@ class ImageTests(object): assert_equal(self.IMAGE_BYTES, image_file.read()) - @istest - def alt_text_title_is_used_if_alt_text_description_is_missing(self): + def test_alt_text_title_is_used_if_alt_text_description_is_missing(self): drawing_element = _create_inline_image( blip=_embedded_blip(self.IMAGE_RELATIONSHIP_ID), title="It's a hat", @@ -1073,8 +972,7 @@ class ImageTests(object): assert_equal(self.IMAGE_BYTES, image_file.read()) - @istest - def alt_text_title_is_used_if_alt_text_description_is_blank(self): + def test_alt_text_title_is_used_if_alt_text_description_is_blank(self): drawing_element = _create_inline_image( blip=_embedded_blip(self.IMAGE_RELATIONSHIP_ID), description=" ", @@ -1090,8 +988,7 @@ class ImageTests(object): assert_equal(self.IMAGE_BYTES, image_file.read()) - @istest - def alt_text_description_is_preferred_to_alt_text_title(self): + def test_alt_text_description_is_preferred_to_alt_text_title(self): drawing_element = _create_inline_image( blip=_embedded_blip(self.IMAGE_RELATIONSHIP_ID), description="It's a hat", @@ -1106,8 +1003,7 @@ class ImageTests(object): with image.open() as image_file: assert_equal(self.IMAGE_BYTES, image_file.read()) - @istest - def can_read_anchored_pictures(self): + def test_can_read_anchored_pictures(self): drawing_element = _create_anchored_image( blip=_embedded_blip(self.IMAGE_RELATIONSHIP_ID), description="It's a hat", @@ -1121,10 +1017,7 @@ class ImageTests(object): with image.open() as image_file: assert_equal(self.IMAGE_BYTES, image_file.read()) - - @istest - @funk.with_mocks - def can_read_linked_pictures(self, mocks): + def test_can_read_linked_pictures(self, mocks): drawing_element = _create_inline_image( blip=_linked_blip("rId5"), description="It's a hat", @@ -1153,8 +1046,7 @@ class ImageTests(object): with image.open() as image_file: assert_equal(self.IMAGE_BYTES, image_file.read()) - @istest - def warning_if_blip_has_no_image_file(self): + def test_warning_if_blip_has_no_image_file(self): drawing = _create_inline_image( blip=xml_element("a:blip"), description="It's a hat", @@ -1165,9 +1057,7 @@ class ImageTests(object): assert_equal([results.warning("Could not find image file for a:blip element")], result.messages) assert_equal(None, result.value) - @istest - @funk.with_mocks - def warning_if_unsupported_image_type(self, mocks): + def test_warning_if_unsupported_image_type(self, mocks): drawing_element = _create_inline_image( blip=_embedded_blip("rId5"), description="It's a hat", @@ -1193,8 +1083,7 @@ class ImageTests(object): expected_warning = results.warning("Image of type image/x-emf is unlikely to display in web browsers") assert_equal([expected_warning], result.messages) - @istest - def no_elements_created_if_image_cannot_be_found_in_w_drawing(self): + def test_no_elements_created_if_image_cannot_be_found_in_w_drawing(self): drawing = xml_element("w:drawing") result = _read_document_xml_element(drawing) @@ -1202,8 +1091,7 @@ class ImageTests(object): assert_equal([], result.messages) assert_equal(None, result.value) - @istest - def no_elements_created_if_image_cannot_be_found_in_wp_inline(self): + def test_no_elements_created_if_image_cannot_be_found_in_wp_inline(self): drawing = xml_element("wp:inline") result = _read_document_xml_element(drawing) @@ -1212,47 +1100,40 @@ class ImageTests(object): assert_equal(None, result.value) -@istest -def footnote_reference_has_id_read(): +def test_footnote_reference_has_id_read(): footnote_xml = xml_element("w:footnoteReference", {"w:id": "4"}) footnote = _read_and_get_document_xml_element(footnote_xml) assert_equal("4", footnote.note_id) -@istest -def comment_reference_has_id_read(): +def test_comment_reference_has_id_read(): comment_reference_xml = xml_element("w:commentReference", {"w:id": "4"}) comment_reference = _read_and_get_document_xml_element(comment_reference_xml) assert_equal(documents.CommentReference("4"), comment_reference) -@istest -def ignored_elements_are_ignored_without_message(): +def test_ignored_elements_are_ignored_without_message(): element = xml_element("w:bookmarkEnd") result = _read_document_xml_element(element) assert_equal(None, result.value) assert_equal([], result.messages) -@istest -def unrecognised_elements_emit_warning(): +def test_unrecognised_elements_emit_warning(): element = xml_element("w:huh", {}, []) result = _read_document_xml_element(element) expected_warning = results.warning("An unrecognised element was ignored: w:huh") assert_equal([expected_warning], result.messages) -@istest -def unrecognised_elements_are_ignored(): +def test_unrecognised_elements_are_ignored(): element = xml_element("w:huh", {}, []) assert_equal(None, _read_document_xml_element(element).value) -@istest -def unrecognised_children_are_ignored(): +def test_unrecognised_children_are_ignored(): element = xml_element("w:r", {}, [_text_element("Hello!"), xml_element("w:huh", {}, [])]) assert_equal( documents.run([documents.Text("Hello!")]), _read_document_xml_element(element).value ) -@istest -def text_boxes_have_content_appended_after_containing_paragraph(): +def test_text_boxes_have_content_appended_after_containing_paragraph(): text_box = xml_element("w:pict", {}, [ xml_element("v:shape", {}, [ xml_element("v:textbox", {}, [ @@ -1268,8 +1149,7 @@ def text_boxes_have_content_appended_after_containing_paragraph(): result = _read_and_get_document_xml_elements(paragraph) assert_equal(result[1].style_id, "textbox-content") -@istest -def alternate_content_is_read_using_fallback(): +def test_alternate_content_is_read_using_fallback(): element = xml_element("mc:AlternateContent", {}, [ xml_element("mc:Choice", {"Requires": "wps"}, [ _paragraph_with_style_id("first") @@ -1281,8 +1161,7 @@ def alternate_content_is_read_using_fallback(): result = _read_and_get_document_xml_element(element) assert_equal("second", result.style_id) -@istest -def sdt_is_read_using_sdt_content(): +def test_sdt_is_read_using_sdt_content(): element = xml_element("w:sdt", {}, [ xml_element("w:sdtContent", {}, [ xml_element("w:t", {}, [xml_text("Blackdown")]), @@ -1291,8 +1170,7 @@ def sdt_is_read_using_sdt_content(): result = _read_and_get_document_xml_element(element) assert_equal(documents.text("Blackdown"), result) -@istest -def text_nodes_are_ignored_when_reading_children(): +def test_text_nodes_are_ignored_when_reading_children(): element = xml_element("w:r", {}, [xml_text("[text]")]) assert_equal( documents.run([]), diff --git a/tests/docx/comments_xml_tests.py b/tests/docx/comments_xml_tests.py index 1d5dd8d..010185f 100644 --- a/tests/docx/comments_xml_tests.py +++ b/tests/docx/comments_xml_tests.py @@ -1,13 +1,11 @@ -from nose.tools import istest, assert_equal - from mammoth import documents from mammoth.docx.xmlparser import element as xml_element from mammoth.docx.comments_xml import read_comments_xml_element from mammoth.docx import body_xml +from ..testing import assert_equal -@istest -def id_and_body_of_comment_is_read(): +def test_id_and_body_of_comment_is_read(): body = [xml_element("w:p")] comments = read_comments_xml_element(xml_element("w:comments", {}, [ xml_element("w:comment", {"w:id": "1"}, body), @@ -17,8 +15,7 @@ def id_and_body_of_comment_is_read(): assert_equal("1", comments.value[0].comment_id) -@istest -def when_optional_attributes_of_comment_are_missing_then_they_are_read_as_none(): +def test_when_optional_attributes_of_comment_are_missing_then_they_are_read_as_none(): comments = read_comments_xml_element(xml_element("w:comments", {}, [ xml_element("w:comment", {"w:id": "1"}, []), ]), body_reader=body_xml.reader()) @@ -27,8 +24,7 @@ def when_optional_attributes_of_comment_are_missing_then_they_are_read_as_none() assert_equal(None, comment.author_initials) -@istest -def when_optional_attributes_of_comment_are_blank_then_they_are_read_as_none(): +def test_when_optional_attributes_of_comment_are_blank_then_they_are_read_as_none(): comments = read_comments_xml_element(xml_element("w:comments", {}, [ xml_element("w:comment", {"w:id": "1", "w:author": " ", "w:initials": " "}, []), ]), body_reader=body_xml.reader()) @@ -37,8 +33,7 @@ def when_optional_attributes_of_comment_are_blank_then_they_are_read_as_none(): assert_equal(None, comment.author_initials) -@istest -def when_optional_attributes_of_comment_are_not_blank_then_they_are_read(): +def test_when_optional_attributes_of_comment_are_not_blank_then_they_are_read(): comments = read_comments_xml_element(xml_element("w:comments", {}, [ xml_element("w:comment", {"w:id": "1", "w:author": "The Piemaker", "w:initials": "TP"}, []), ]), body_reader=body_xml.reader()) diff --git a/tests/docx/content_types_xml_tests.py b/tests/docx/content_types_xml_tests.py index 8b104d9..14920b4 100644 --- a/tests/docx/content_types_xml_tests.py +++ b/tests/docx/content_types_xml_tests.py @@ -1,11 +1,9 @@ -from nose.tools import istest, assert_equal - from mammoth.docx.xmlparser import element as xml_element from mammoth.docx.content_types_xml import read_content_types_xml_element +from ..testing import assert_equal -@istest -def content_type_is_based_on_default_for_extension_if_there_is_no_override(): +def test_content_type_is_based_on_default_for_extension_if_there_is_no_override(): element = xml_element("content-types:Types", {}, [ xml_element("content-types:Default", { "Extension": "png", @@ -19,8 +17,7 @@ def content_type_is_based_on_default_for_extension_if_there_is_no_override(): ) -@istest -def content_type_is_based_on_override_if_present(): +def test_content_type_is_based_on_override_if_present(): element = xml_element("content-types:Types", {}, [ xml_element("content-types:Default", { "Extension": "png", @@ -38,8 +35,7 @@ def content_type_is_based_on_override_if_present(): ) -@istest -def fallback_content_types_have_common_image_types(): +def test_fallback_content_types_have_common_image_types(): element = xml_element("content-types:Types", {}, []) content_types = read_content_types_xml_element(element) assert_equal( @@ -72,8 +68,7 @@ def fallback_content_types_have_common_image_types(): ) -@istest -def fallback_content_types_are_case_insensitive(): +def test_fallback_content_types_are_case_insensitive(): element = xml_element("content-types:Types", {}, []) content_types = read_content_types_xml_element(element) assert_equal( diff --git a/tests/docx/document_xml_tests.py b/tests/docx/document_xml_tests.py index fa63775..e93392c 100644 --- a/tests/docx/document_xml_tests.py +++ b/tests/docx/document_xml_tests.py @@ -1,33 +1,29 @@ -from nose.tools import istest, assert_equal - from mammoth import documents from mammoth.docx.xmlparser import element as xml_element, text as xml_text from mammoth.docx.document_xml import read_document_xml_element from mammoth.docx import body_xml +from ..testing import assert_equal -@istest class ReadXmlElementTests(object): - @istest - def can_read_text_within_document(self): + def test_can_read_text_within_document(self): element = _document_element_with_text("Hello!") assert_equal( documents.document([documents.paragraph([documents.run([documents.Text("Hello!")])])]), _read_and_get_document_xml_element(element) ) - - @istest - def footnotes_of_document_are_read(self): + + def test_footnotes_of_document_are_read(self): notes = [documents.note("footnote", "4", [documents.paragraph([])])] - + body_xml = xml_element("w:body") document_xml = xml_element("w:document", {}, [body_xml]) - + document = _read_and_get_document_xml_element(document_xml, notes=notes) footnote = document.notes.find_note("footnote", "4") assert_equal("4", footnote.note_id) assert isinstance(footnote.body[0], documents.Paragraph) - + def _read_and_get_document_xml_element(*args, **kwargs): body_reader = body_xml.reader() diff --git a/tests/docx/docx_tests.py b/tests/docx/docx_tests.py index 830f334..ee6b928 100644 --- a/tests/docx/docx_tests.py +++ b/tests/docx/docx_tests.py @@ -2,17 +2,13 @@ import io import textwrap import zipfile -from nose.tools import istest, assert_equal - from mammoth import docx, documents, zips -from ..testing import assert_raises, test_path +from ..testing import assert_equal, assert_raises, generate_test_path -@istest class ReadTests(object): - @istest - def can_read_document_with_single_paragraph_with_single_run_of_text(self): - with open(test_path("single-paragraph.docx"), "rb") as fileobj: + def test_can_read_document_with_single_paragraph_with_single_run_of_text(self): + with open(generate_test_path("single-paragraph.docx"), "rb") as fileobj: result = docx.read(fileobj=fileobj) expected_document = documents.document([ documents.paragraph([ @@ -29,8 +25,7 @@ _relationship_namespaces = { } -@istest -def main_document_is_found_using_package_relationships(): +def test_main_document_is_found_using_package_relationships(): fileobj = _create_zip({ "word/document2.xml": textwrap.dedent("""\ <?xml version="1.0" encoding="utf-8" ?> @@ -62,8 +57,7 @@ def main_document_is_found_using_package_relationships(): assert_equal(expected_document, result.value) -@istest -def error_is_raised_when_main_document_part_does_not_exist(): +def test_error_is_raised_when_main_document_part_does_not_exist(): fileobj = _create_zip({ "_rels/.rels": textwrap.dedent("""\ <?xml version="1.0" encoding="utf-8"?> @@ -78,9 +72,8 @@ def error_is_raised_when_main_document_part_does_not_exist(): str(error), ) -class TestPartPaths(object): - @istest - def main_document_part_is_found_using_package_relationships(self): +class PartPathsTests(object): + def test_main_document_part_is_found_using_package_relationships(self): fileobj = _create_zip({ "word/document2.xml": " ", "_rels/.rels": textwrap.dedent("""\ @@ -92,55 +85,44 @@ class TestPartPaths(object): }) part_paths = self._find_part_paths(fileobj) assert_equal("word/document2.xml", part_paths.main_document) - - @istest - def when_relationship_for_main_document_cannot_be_found_then_fallback_is_used(self): + + def test_when_relationship_for_main_document_cannot_be_found_then_fallback_is_used(self): fileobj = _create_zip({ "word/document.xml": " ", }) part_paths = self._find_part_paths(fileobj) assert_equal("word/document.xml", part_paths.main_document) - - @istest - def comments_part_is_found_using_main_document_relationships(self): + + def test_comments_part_is_found_using_main_document_relationships(self): self._assert_path_is_found_using_main_document_relationships("comments") - - @istest - def when_relationship_for_comments_cannot_be_found_then_fallback_is_used(self): + + def test_when_relationship_for_comments_cannot_be_found_then_fallback_is_used(self): self._assert_when_relationship_for_part_cannot_be_found_then_fallback_is_used("comments") - - @istest - def endnotes_part_is_found_using_main_document_relationships(self): + + def test_endnotes_part_is_found_using_main_document_relationships(self): self._assert_path_is_found_using_main_document_relationships("endnotes") - - @istest - def when_relationship_for_endnotes_cannot_be_found_then_fallback_is_used(self): + + def test_when_relationship_for_endnotes_cannot_be_found_then_fallback_is_used(self): self._assert_when_relationship_for_part_cannot_be_found_then_fallback_is_used("endnotes") - - @istest - def footnotes_part_is_found_using_main_document_relationships(self): + + def test_footnotes_part_is_found_using_main_document_relationships(self): self._assert_path_is_found_using_main_document_relationships("footnotes") - - @istest - def when_relationship_for_footnotes_cannot_be_found_then_fallback_is_used(self): + + def test_when_relationship_for_footnotes_cannot_be_found_then_fallback_is_used(self): self._assert_when_relationship_for_part_cannot_be_found_then_fallback_is_used("footnotes") - - @istest - def numbering_part_is_found_using_main_document_relationships(self): + + def test_numbering_part_is_found_using_main_document_relationships(self): self._assert_path_is_found_using_main_document_relationships("numbering") - - @istest - def when_relationship_for_numbering_cannot_be_found_then_fallback_is_used(self): + + def test_when_relationship_for_numbering_cannot_be_found_then_fallback_is_used(self): self._assert_when_relationship_for_part_cannot_be_found_then_fallback_is_used("numbering") - - @istest - def styles_part_is_found_using_main_document_relationships(self): + + def test_styles_part_is_found_using_main_document_relationships(self): self._assert_path_is_found_using_main_document_relationships("styles") - - @istest - def when_relationship_for_styles_cannot_be_found_then_fallback_is_used(self): + + def test_when_relationship_for_styles_cannot_be_found_then_fallback_is_used(self): self._assert_when_relationship_for_part_cannot_be_found_then_fallback_is_used("styles") - + def _assert_path_is_found_using_main_document_relationships(self, name): fileobj = _create_zip({ "_rels/.rels": textwrap.dedent("""\ @@ -160,7 +142,7 @@ class TestPartPaths(object): }) part_paths = self._find_part_paths(fileobj) assert_equal("word/target-path.xml", getattr(part_paths, name)) - + def _assert_when_relationship_for_part_cannot_be_found_then_fallback_is_used(self, name): fileobj = _create_zip({ "_rels/.rels": textwrap.dedent("""\ @@ -173,21 +155,21 @@ class TestPartPaths(object): }) part_paths = self._find_part_paths(fileobj) assert_equal("word/{0}.xml".format(name), getattr(part_paths, name)) - - + + def _find_part_paths(self, fileobj): return docx._find_part_paths(zips.open_zip(fileobj, "r")) def _create_zip(files): fileobj = io.BytesIO() - + zip_file = zipfile.ZipFile(fileobj, "w") try: for name, contents in files.items(): zip_file.writestr(name, contents) finally: zip_file.close() - + fileobj.seek(0) return fileobj diff --git a/tests/docx/files_tests.py b/tests/docx/files_tests.py index f6c0120..6845cc2 100644 --- a/tests/docx/files_tests.py +++ b/tests/docx/files_tests.py @@ -1,12 +1,9 @@ -from nose.tools import istest, assert_equal - from mammoth.docx.files import Files, InvalidFileReferenceError -from ..testing import test_path, assert_raises +from ..testing import generate_test_path, assert_equal, assert_raises -@istest -def can_open_files_with_file_uri(): - path = test_path("tiny-picture.png") +def test_can_open_files_with_file_uri(): + path = generate_test_path("tiny-picture.png") files = Files(None) with files.open("file:///" + path) as image_file: contents = image_file.read() @@ -15,18 +12,16 @@ def can_open_files_with_file_uri(): assert_equal(source_file.read(), contents) -@istest -def can_open_files_with_relative_uri(): - files = Files(test_path("")) +def test_can_open_files_with_relative_uri(): + files = Files(generate_test_path("")) with files.open("tiny-picture.png") as image_file: contents = image_file.read() assert_equal(bytes, type(contents)) - with open(test_path("tiny-picture.png"), "rb") as source_file: + with open(generate_test_path("tiny-picture.png"), "rb") as source_file: assert_equal(source_file.read(), contents) -@istest -def given_base_is_not_set_when_opening_relative_uri_then_error_is_raised(): +def test_given_base_is_not_set_when_opening_relative_uri_then_error_is_raised(): files = Files(None) error = assert_raises(InvalidFileReferenceError, lambda: files.open("not-a-real-file.png")) expected_message = ( @@ -35,8 +30,7 @@ def given_base_is_not_set_when_opening_relative_uri_then_error_is_raised(): assert_equal(expected_message, str(error)) -@istest -def error_is_raised_if_relative_uri_cannot_be_opened(): +def test_error_is_raised_if_relative_uri_cannot_be_opened(): files = Files("/tmp") error = assert_raises(InvalidFileReferenceError, lambda: files.open("not-a-real-file.png")) expected_message = ( @@ -46,8 +40,7 @@ def error_is_raised_if_relative_uri_cannot_be_opened(): assert_equal(expected_message, str(error)) -@istest -def error_is_raised_if_file_uri_cannot_be_opened(): +def test_error_is_raised_if_file_uri_cannot_be_opened(): files = Files("/tmp") error = assert_raises(InvalidFileReferenceError, lambda: files.open("file:///not-a-real-file.png")) expected_message = "could not open external image: 'file:///not-a-real-file.png' (document directory: '/tmp')\n" diff --git a/tests/docx/notes_xml_tests.py b/tests/docx/notes_xml_tests.py index 56a7681..086e6d8 100644 --- a/tests/docx/notes_xml_tests.py +++ b/tests/docx/notes_xml_tests.py @@ -1,13 +1,11 @@ -from nose.tools import istest, assert_equal - from mammoth import documents from mammoth.docx.xmlparser import element as xml_element from mammoth.docx.notes_xml import read_footnotes_xml_element from mammoth.docx import body_xml +from ..testing import assert_equal -@istest -def id_and_body_of_footnote_are_read(): +def test_id_and_body_of_footnote_are_read(): footnote_body = [xml_element("w:p")] footnotes = read_footnotes_xml_element(xml_element("w:footnotes", {}, [ xml_element("w:footnote", {"w:id": "1"}, footnote_body), @@ -17,13 +15,11 @@ def id_and_body_of_footnote_are_read(): assert_equal("1", footnotes.value[0].note_id) -@istest -def continuation_separator_is_ignored(): +def test_continuation_separator_is_ignored(): _assert_footnote_type_is_ignored("continuationSeparator") -@istest -def separator_is_ignored(): +def test_separator_is_ignored(): _assert_footnote_type_is_ignored("separator") @@ -33,4 +29,4 @@ def _assert_footnote_type_is_ignored(footnote_type): xml_element("w:footnote", {"w:id": "1", "w:type": footnote_type}, footnote_body), ]), body_reader=None) assert_equal(0, len(footnotes.value)) - + diff --git a/tests/docx/numbering_xml_tests.py b/tests/docx/numbering_xml_tests.py index 6c1d843..b6959a6 100644 --- a/tests/docx/numbering_xml_tests.py +++ b/tests/docx/numbering_xml_tests.py @@ -1,12 +1,10 @@ -from nose.tools import istest, assert_equal - from mammoth.docx.xmlparser import element as xml_element from mammoth.docx.numbering_xml import read_numbering_xml_element from mammoth.docx.styles_xml import NumberingStyle, Styles +from ..testing import assert_equal -@istest -def find_level_returns_none_if_num_with_id_cannot_be_found(): +def test_find_level_returns_none_if_num_with_id_cannot_be_found(): numbering = _read_numbering_xml_element(xml_element("w:numbering")) assert_equal(None, numbering.find_level("47", "0")) @@ -26,32 +24,27 @@ _sample_numbering_xml = xml_element("w:numbering", {}, [ ]) -@istest -def level_includes_level_index(): +def test_level_includes_level_index(): numbering = _read_numbering_xml_element(_sample_numbering_xml) assert_equal("0", numbering.find_level("47", "0").level_index) assert_equal("1", numbering.find_level("47", "1").level_index) -@istest -def list_is_not_ordered_if_formatted_as_bullet(): +def test_list_is_not_ordered_if_formatted_as_bullet(): numbering = _read_numbering_xml_element(_sample_numbering_xml) assert_equal(False, numbering.find_level("47", "0").is_ordered) -@istest -def list_is_ordered_if_formatted_as_decimal(): +def test_list_is_ordered_if_formatted_as_decimal(): numbering = _read_numbering_xml_element(_sample_numbering_xml) assert_equal(True, numbering.find_level("47", "1").is_ordered) -@istest -def find_level_returns_none_if_level_cannot_be_found(): +def test_find_level_returns_none_if_level_cannot_be_found(): numbering = _read_numbering_xml_element(_sample_numbering_xml) assert_equal(None, numbering.find_level("47", "2")) -@istest -def num_referencing_non_existent_abstract_num_is_ignored(): +def test_num_referencing_non_existent_abstract_num_is_ignored(): element = xml_element("w:numbering", {}, [ xml_element("w:num", {"w:numId": "47"}, [ xml_element("w:abstractNumId", {"w:val": "42"}) @@ -63,8 +56,7 @@ def num_referencing_non_existent_abstract_num_is_ignored(): assert_equal(None, numbering.find_level("47", "0")) -@istest -def when_abstract_num_has_num_style_link_then_style_is_used_to_find_num(): +def test_when_abstract_num_has_num_style_link_then_style_is_used_to_find_num(): numbering = _read_numbering_xml_element( xml_element("w:numbering", {}, [ xml_element("w:abstractNum", {"w:abstractNumId": "100"}, [ @@ -88,8 +80,7 @@ def when_abstract_num_has_num_style_link_then_style_is_used_to_find_num(): # See: 17.9.23 pStyle (Paragraph Style's Associated Numbering Level) in ECMA-376, 4th Edition -@istest -def numbering_level_can_be_found_by_paragraph_style_id(): +def test_numbering_level_can_be_found_by_paragraph_style_id(): numbering = _read_numbering_xml_element( xml_element("w:numbering", {}, [ xml_element("w:abstractNum", {"w:abstractNumId": "42"}, [ diff --git a/tests/docx/office_xml_tests.py b/tests/docx/office_xml_tests.py index 5b8b1e1..f87fa75 100644 --- a/tests/docx/office_xml_tests.py +++ b/tests/docx/office_xml_tests.py @@ -2,13 +2,11 @@ from __future__ import unicode_literals import io -from nose.tools import istest, assert_equal - from mammoth.docx import xmlparser as xml, office_xml +from ..testing import assert_equal -@istest -def alternate_content_is_replaced_by_contents_of_fallback(): +def test_alternate_content_is_replaced_by_contents_of_fallback(): xml_string = ( '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' + '<numbering xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">' + @@ -21,6 +19,6 @@ def alternate_content_is_replaced_by_contents_of_fallback(): '</mc:Fallback>' + '</mc:AlternateContent>' + '</numbering>') - + result = office_xml.read(io.StringIO(xml_string)) assert_equal([xml.element("fallback")], result.children) diff --git a/tests/docx/relationships_xml_tests.py b/tests/docx/relationships_xml_tests.py index 5e52142..2c5b6ce 100644 --- a/tests/docx/relationships_xml_tests.py +++ b/tests/docx/relationships_xml_tests.py @@ -1,11 +1,9 @@ -from nose.tools import istest, assert_equal - from mammoth.docx.xmlparser import element as xml_element from mammoth.docx.relationships_xml import read_relationships_xml_element +from ..testing import assert_equal -@istest -def relationship_targets_can_be_found_by_id(): +def test_relationship_targets_can_be_found_by_id(): element = xml_element("relationships:Relationships", {}, [ xml_element("relationships:Relationship", { "Id": "rId8", @@ -25,8 +23,7 @@ def relationship_targets_can_be_found_by_id(): ) -@istest -def relationship_targets_can_be_found_by_type(): +def test_relationship_targets_can_be_found_by_type(): element = xml_element("relationships:Relationships", {}, [ xml_element("relationships:Relationship", { "Id": "rId2", @@ -51,8 +48,7 @@ def relationship_targets_can_be_found_by_type(): ) -@istest -def when_there_are_no_relationships_of_requested_type_then_empty_list_is_returned(): +def test_when_there_are_no_relationships_of_requested_type_then_empty_list_is_returned(): element = xml_element("relationships:Relationships", {}, []) relationships = read_relationships_xml_element(element) assert_equal( diff --git a/tests/docx/style_map_tests.py b/tests/docx/style_map_tests.py index b774b66..81349fc 100644 --- a/tests/docx/style_map_tests.py +++ b/tests/docx/style_map_tests.py @@ -1,56 +1,48 @@ import io from zipfile import ZipFile -from nose.tools import istest, assert_equal - from mammoth.docx.style_map import write_style_map, read_style_map from mammoth.zips import open_zip from mammoth.docx import xmlparser as xml +from ..testing import assert_equal -@istest -def reading_embedded_style_map_on_document_without_embedded_style_map_returns_none(): +def test_reading_embedded_style_map_on_document_without_embedded_style_map_returns_none(): fileobj = _normal_docx() assert_equal(None, read_style_map(fileobj)) -@istest -def writing_style_map_preserves_unrelated_files(): +def test_writing_style_map_preserves_unrelated_files(): fileobj = _normal_docx() write_style_map(fileobj, "p => h1") with open_zip(fileobj, "r") as zip_file: assert_equal("placeholder", zip_file.read_str("placeholder")) -@istest -def embedded_style_map_can_be_read_after_being_written(): +def test_embedded_style_map_can_be_read_after_being_written(): fileobj = _normal_docx() write_style_map(fileobj, "p => h1") assert_equal("p => h1", read_style_map(fileobj)) -@istest -def embedded_style_map_is_written_to_separate_file(): +def test_embedded_style_map_is_written_to_separate_file(): fileobj = _normal_docx() write_style_map(fileobj, "p => h1") with open_zip(fileobj, "r") as zip_file: assert_equal("p => h1", zip_file.read_str("mammoth/style-map")) -@istest -def embedded_style_map_is_referenced_in_relationships(): +def test_embedded_style_map_is_referenced_in_relationships(): fileobj = _normal_docx() write_style_map(fileobj, "p => h1") assert_equal(expected_relationships_xml, _read_relationships_xml(fileobj)) - -@istest -def embedded_style_map_has_override_content_type_in_content_types_xml(): + +def test_embedded_style_map_has_override_content_type_in_content_types_xml(): fileobj = _normal_docx() write_style_map(fileobj, "p => h1") assert_equal(expected_content_types_xml, _read_content_types_xml(fileobj)) -@istest -def can_overwrite_existing_style_map(): +def test_can_overwrite_existing_style_map(): fileobj = _normal_docx() write_style_map(fileobj, "p => h1") write_style_map(fileobj, "p => h2") diff --git a/tests/docx/styles_xml_tests.py b/tests/docx/styles_xml_tests.py index 580d91d..165d86c 100644 --- a/tests/docx/styles_xml_tests.py +++ b/tests/docx/styles_xml_tests.py @@ -1,18 +1,15 @@ -from nose.tools import istest, assert_equal - from mammoth.docx.xmlparser import element as xml_element from mammoth.docx.styles_xml import read_styles_xml_element +from ..testing import assert_equal -@istest -def paragraph_style_is_null_if_no_style_with_that_id_exists(): +def test_paragraph_style_is_null_if_no_style_with_that_id_exists(): element = xml_element("w:styles") styles = read_styles_xml_element(element) assert_equal(None, styles.find_paragraph_style_by_id("Heading1")) -@istest -def paragraph_style_can_be_found_by_id(): +def test_paragraph_style_can_be_found_by_id(): element = xml_element("w:styles", {}, [ _paragraph_style_element("Heading1", "Heading 1"), ]) @@ -23,8 +20,7 @@ def paragraph_style_can_be_found_by_id(): ) -@istest -def character_style_can_be_found_by_id(): +def test_character_style_can_be_found_by_id(): element = xml_element("w:styles", {}, [ _character_style_element("Heading1Char", "Heading 1 Char"), ]) @@ -35,8 +31,7 @@ def character_style_can_be_found_by_id(): ) -@istest -def table_style_can_be_found_by_id(): +def test_table_style_can_be_found_by_id(): element = xml_element("w:styles", {}, [ _table_style_element("TableNormal", "Normal Table"), ]) @@ -47,8 +42,7 @@ def table_style_can_be_found_by_id(): ) -@istest -def paragraph_and_character_styles_are_distinct(): +def test_paragraph_and_character_styles_are_distinct(): element = xml_element("w:styles", {}, [ _paragraph_style_element("Heading1", "Heading 1"), _character_style_element("Heading1Char", "Heading 1 Char"), @@ -58,8 +52,7 @@ def paragraph_and_character_styles_are_distinct(): assert_equal(None, styles.find_paragraph_style_by_id("Heading1Char")) -@istest -def styles_include_names(): +def test_styles_include_names(): element = xml_element("w:styles", {}, [ _paragraph_style_element("Heading1", "Heading 1"), ]) @@ -70,8 +63,7 @@ def styles_include_names(): ) -@istest -def style_name_is_none_if_name_element_does_not_exist(): +def test_style_name_is_none_if_name_element_does_not_exist(): element = xml_element("w:styles", {}, [ _style_without_name_element("paragraph", "Heading1"), _style_without_name_element("character", "Heading1Char") @@ -81,15 +73,13 @@ def style_name_is_none_if_name_element_does_not_exist(): assert_equal(None, styles.find_character_style_by_id("Heading1Char").name) -@istest -def numbering_style_is_none_if_no_style_with_that_id_exists(): +def test_numbering_style_is_none_if_no_style_with_that_id_exists(): element = xml_element("w:styles", {}, []) styles = read_styles_xml_element(element) assert_equal(None, styles.find_numbering_style_by_id("List1")) -@istest -def numbering_style_has_none_num_id_if_style_has_no_paragraph_properties(): +def test_numbering_style_has_none_num_id_if_style_has_no_paragraph_properties(): element = xml_element("w:styles", {}, [ xml_element("w:style", {"w:type": "numbering", "w:styleId": "List1"}), ]) @@ -97,8 +87,7 @@ def numbering_style_has_none_num_id_if_style_has_no_paragraph_properties(): assert_equal(None, styles.find_numbering_style_by_id("List1").num_id) -@istest -def numbering_style_has_num_id_read_from_paragraph_properties(): +def test_numbering_style_has_num_id_read_from_paragraph_properties(): element = xml_element("w:styles", {}, [ xml_element("w:style", {"w:type": "numbering", "w:styleId": "List1"}, [ xml_element("w:pPr", {}, [ diff --git a/tests/docx/uris_tests.py b/tests/docx/uris_tests.py index 6b9c264..298a40a 100644 --- a/tests/docx/uris_tests.py +++ b/tests/docx/uris_tests.py @@ -1,18 +1,15 @@ -from nose.tools import istest, assert_equal - from mammoth.docx.uris import uri_to_zip_entry_name +from ..testing import assert_equal -@istest -def when_path_does_not_have_leading_slash_then_path_is_resolved_relative_to_base(): +def test_when_path_does_not_have_leading_slash_then_path_is_resolved_relative_to_base(): assert_equal( "one/two/three/four", uri_to_zip_entry_name("one/two", "three/four"), ) -@istest -def when_path_has_leading_slash_then_base_is_ignored(): +def test_when_path_has_leading_slash_then_base_is_ignored(): assert_equal( "three/four", uri_to_zip_entry_name("one/two", "/three/four"), diff --git a/tests/docx/xmlparser_tests.py b/tests/docx/xmlparser_tests.py index 65a2f25..8c960eb 100644 --- a/tests/docx/xmlparser_tests.py +++ b/tests/docx/xmlparser_tests.py @@ -1,89 +1,73 @@ import io -from nose.tools import istest, assert_equal - from mammoth.docx.xmlparser import parse_xml, element as xml_element, text as xml_text +from ..testing import assert_equal -@istest -def can_parse_self_closing_element(): +def test_can_parse_self_closing_element(): xml = _parse_xml_string(b"<body/>") assert_equal(xml_element("body", {}, []), xml) -@istest -def can_parse_empty_element_with_separate_closing_tag(): +def test_can_parse_empty_element_with_separate_closing_tag(): xml = _parse_xml_string(b"<body></body>") assert_equal(xml_element("body", {}, []), xml) -@istest -def can_parse_attributes_of_tag(): +def test_can_parse_attributes_of_tag(): xml = _parse_xml_string(b"<body name='bob'></body>") assert_equal(xml_element("body", {"name": "bob"}, []), xml) -@istest -def can_parse_text_element(): +def test_can_parse_text_element(): xml = _parse_xml_string(b"<body>Hello!</body>") assert_equal(xml_element("body", {}, [xml_text("Hello!")]), xml) -@istest -def can_parse_text_element_before_new_tag(): +def test_can_parse_text_element_before_new_tag(): xml = _parse_xml_string(b"<body>Hello!<br/></body>") assert_equal(xml_element("body", {}, [xml_text("Hello!"), xml_element("br", {}, [])]), xml) -@istest -def can_parse_element_with_children(): +def test_can_parse_element_with_children(): xml = _parse_xml_string(b"<body><a/><b/></body>") assert_equal([xml_element("a", {}, []), xml_element("b", {}, [])], xml.children) -@istest -def unmapped_namespaces_uris_are_included_in_braces_as_prefix(): +def test_unmapped_namespaces_uris_are_included_in_braces_as_prefix(): xml = _parse_xml_string(b'<w:body xmlns:w="word"/>') assert_equal("{word}body", xml.name) -@istest -def mapped_namespaces_uris_are_translated_using_namespace_map(): +def test_mapped_namespaces_uris_are_translated_using_namespace_map(): xml = _parse_xml_string(b'<w:body xmlns:w="word"/>', [("x", "word")]) assert_equal("x:body", xml.name) -@istest -def namespace_of_attributes_is_mapped_to_prefix(): +def test_namespace_of_attributes_is_mapped_to_prefix(): xml = _parse_xml_string(b'<w:body xmlns:w="word" w:val="Hello!"/>', [("x", "word")]) assert_equal("Hello!", xml.attributes["x:val"]) -@istest -def whitespace_between_xml_declaration_and_root_tag_is_ignored(): +def test_whitespace_between_xml_declaration_and_root_tag_is_ignored(): xml = _parse_xml_string(b'<?xml version="1.0" ?>\n<body/>') assert_equal("body", xml.name) - -@istest + class FindChildTests(object): - @istest - def returns_none_if_no_children(self): + def test_returns_none_if_no_children(self): xml = xml_element("a") assert_equal(None, xml.find_child("b")) - - @istest - def returns_none_if_no_matching_children(self): + + def test_returns_none_if_no_matching_children(self): xml = xml_element("a", {}, [xml_element("c")]) assert_equal(None, xml.find_child("b")) - - @istest - def returns_first_matching_child(self): + + def test_returns_first_matching_child(self): xml = xml_element("a", {}, [xml_element("b", {"id": 1}), xml_element("b", {"id": 2})]) assert_equal(1, xml.find_child("b").attributes["id"]) - - @istest - def ignores_text_nodes(self): + + def test_ignores_text_nodes(self): xml = xml_element("a", {}, [xml_text("Hello!")]) assert_equal(None, xml.find_child("b")) diff --git a/tests/html/collapse_tests.py b/tests/html/collapse_tests.py index 5dc7e6c..ebffd69 100644 --- a/tests/html/collapse_tests.py +++ b/tests/html/collapse_tests.py @@ -1,62 +1,55 @@ -from nose.tools import istest, assert_equal - from mammoth import html +from ..testing import assert_equal -@istest -def collapsing_does_nothing_to_single_text_node(): +def test_collapsing_does_nothing_to_single_text_node(): assert_equal( html.collapse([html.text("Bluebells")]), [html.text("Bluebells")]) -@istest -def consecutive_fresh_elements_are_not_collapsed(): +def test_consecutive_fresh_elements_are_not_collapsed(): assert_equal( html.collapse([html.element("p"), html.element("p")]), [html.element("p"), html.element("p")]) -@istest -def consecutive_collapsible_elements_are_collapsed_if_they_have_the_same_tag_and_attributes(): +def test_consecutive_collapsible_elements_are_collapsed_if_they_have_the_same_tag_and_attributes(): assert_equal( [html.collapsible_element("p", {}, [html.text("One"), html.text("Two")])], html.collapse([ html.collapsible_element("p", {}, [html.text("One")]), html.collapsible_element("p", {}, [html.text("Two")]) ])) - -@istest -def elements_with_different_tag_names_are_not_collapsed(): + +def test_elements_with_different_tag_names_are_not_collapsed(): assert_equal( [ html.collapsible_element("p", {}, [html.text("One")]), html.collapsible_element("div", {}, [html.text("Two")]) ], - + html.collapse([ html.collapsible_element("p", {}, [html.text("One")]), html.collapsible_element("div", {}, [html.text("Two")]) ])) - -@istest -def elements_with_different_attributes_are_not_collapsed(): + +def test_elements_with_different_attributes_are_not_collapsed(): assert_equal( [ html.collapsible_element("p", {"id": "a"}, [html.text("One")]), html.collapsible_element("p", {}, [html.text("Two")]) ], - + html.collapse([ html.collapsible_element("p", {"id": "a"}, [html.text("One")]), html.collapsible_element("p", {}, [html.text("Two")]) ])) -@istest -def children_of_collapsed_element_can_collapse_with_children_of_previous_element(): +def test_children_of_collapsed_element_can_collapse_with_children_of_previous_element(): assert_equal( [ html.collapsible_element("blockquote", {}, [ @@ -66,7 +59,7 @@ def children_of_collapsed_element_can_collapse_with_children_of_previous_element ]) ]), ], - + html.collapse([ html.collapsible_element("blockquote", {}, [ html.collapsible_element("p", {}, [html.text("One")]) @@ -77,8 +70,7 @@ def children_of_collapsed_element_can_collapse_with_children_of_previous_element ])) -@istest -def collapsible_element_can_collapse_into_previous_fresh_element(): +def test_collapsible_element_can_collapse_into_previous_fresh_element(): assert_equal( [html.element("p", {}, [html.text("One"), html.text("Two")])], html.collapse([ @@ -87,8 +79,7 @@ def collapsible_element_can_collapse_into_previous_fresh_element(): ])) -@istest -def element_with_choice_of_tag_names_can_collapse_into_previous_element_if_it_has_one_of_those_tag_names_as_its_main_tag_name(): +def test_element_with_choice_of_tag_names_can_collapse_into_previous_element_if_it_has_one_of_those_tag_names_as_its_main_tag_name(): assert_equal( [html.collapsible_element(["ol"])], html.collapse([ @@ -107,8 +98,7 @@ def element_with_choice_of_tag_names_can_collapse_into_previous_element_if_it_ha ])) -@istest -def when_separator_is_present_then_separator_is_prepended_to_collapsed_element(): +def test_when_separator_is_present_then_separator_is_prepended_to_collapsed_element(): assert_equal( [ html.element("pre", collapsible=False, children=[ diff --git a/tests/html/strip_empty_tests.py b/tests/html/strip_empty_tests.py index b72b50a..8660cff 100644 --- a/tests/html/strip_empty_tests.py +++ b/tests/html/strip_empty_tests.py @@ -1,65 +1,56 @@ -from nose.tools import istest, assert_equal - from mammoth import html +from ..testing import assert_equal -@istest -def text_nodes_with_text_are_not_stripped(): +def test_text_nodes_with_text_are_not_stripped(): assert_equal( [html.text("H")], html.strip_empty([html.text("H")])) -@istest -def empty_text_nodes_are_stripped(): +def test_empty_text_nodes_are_stripped(): assert_equal( [], html.strip_empty([html.text("")])) -@istest -def elements_with_non_empty_children_are_not_stripped(): +def test_elements_with_non_empty_children_are_not_stripped(): assert_equal( [html.element("p", {}, [html.text("H")])], html.strip_empty([html.element("p", {}, [html.text("H")])])) -@istest -def elements_with_no_children_are_stripped(): +def test_elements_with_no_children_are_stripped(): assert_equal( [], html.strip_empty([html.element("p")])) -@istest -def elements_with_only_empty_children_are_stripped(): +def test_elements_with_only_empty_children_are_stripped(): assert_equal( [], html.strip_empty([html.element("p", {}, [html.text("")])])) -@istest -def empty_children_are_removed(): +def test_empty_children_are_removed(): assert_equal( html.strip_empty([html.element("ul", {}, [ html.element("li", {}, [html.text("")]), html.element("li", {}, [html.text("H")]), ])]), - + [html.element("ul", {}, [ html.element("li", {}, [html.text("H")]) ])]) -@istest -def self_closing_elements_are_never_empty(): +def test_self_closing_elements_are_never_empty(): assert_equal( [html.element("br")], html.strip_empty([html.element("br")])) -@istest -def force_writes_are_never_empty(): +def test_force_writes_are_never_empty(): assert_equal( [html.force_write], html.strip_empty([html.force_write])) diff --git a/tests/images_tests.py b/tests/images_tests.py index 0ab29e1..6e2487d 100644 --- a/tests/images_tests.py +++ b/tests/images_tests.py @@ -1,18 +1,15 @@ import io -from nose.tools import istest from precisely import assert_that, has_attrs, is_sequence import mammoth -@istest -def inline_is_available_as_alias_of_img_element(): +def test_inline_is_available_as_alias_of_img_element(): assert mammoth.images.inline is mammoth.images.img_element -@istest -def data_uri_encodes_images_in_base64(): +def test_data_uri_encodes_images_in_base64(): image_bytes = b"abc" image = mammoth.documents.Image( alt_text=None, @@ -27,9 +24,7 @@ def data_uri_encodes_images_in_base64(): )) -@istest class ImgElementTests: - @istest def test_when_element_does_not_have_alt_text_then_alt_attribute_is_not_set(self): image_bytes = b"abc" image = mammoth.documents.Image( @@ -48,7 +43,6 @@ class ImgElementTests: has_attrs(attributes={"src": "<src>"}), )) - @istest def test_when_element_se_alt_text_then_alt_attribute_is_set(self): image_bytes = b"abc" image = mammoth.documents.Image( @@ -67,7 +61,6 @@ class ImgElementTests: has_attrs(attributes={"alt": "<alt>", "src": "<src>"}), )) - @istest def test_image_alt_text_can_be_overridden_by_alt_attribute_returned_from_function(self): image_bytes = b"abc" image = mammoth.documents.Image( diff --git a/tests/lists_tests.py b/tests/lists_tests.py index 49d5331..b8a37f0 100644 --- a/tests/lists_tests.py +++ b/tests/lists_tests.py @@ -1,13 +1,10 @@ -from nose.tools import istest, assert_equal - from mammoth.lists import unique +from .testing import assert_equal -@istest -def unique_of_empty_list_is_empty_list(): +def test_unique_of_empty_list_is_empty_list(): assert_equal([], unique([])) -@istest -def unique_removes_duplicates_while_preserving_order(): +def test_unique_removes_duplicates_while_preserving_order(): assert_equal(["apple", "banana"], unique(["apple", "banana", "apple"])) diff --git a/tests/mammoth_tests.py b/tests/mammoth_tests.py index 1dcbaa9..b8c6a11 100644 --- a/tests/mammoth_tests.py +++ b/tests/mammoth_tests.py @@ -8,80 +8,70 @@ import shutil import os import tempman -from nose.tools import istest, assert_equal -from .testing import test_path +from .testing import assert_equal, generate_test_path import mammoth from mammoth import results -@istest -def docx_containing_one_paragraph_is_converted_to_single_p_element(): - with open(test_path("single-paragraph.docx"), "rb") as fileobj: +def test_docx_containing_one_paragraph_is_converted_to_single_p_element(): + with open(generate_test_path("single-paragraph.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("<p>Walking on imported air</p>", result.value) assert_equal([], result.messages) -@istest -def can_read_xml_files_with_utf8_bom(): - with open(test_path("utf8-bom.docx"), "rb") as fileobj: +def test_can_read_xml_files_with_utf8_bom(): + with open(generate_test_path("utf8-bom.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("<p>This XML has a byte order mark.</p>", result.value) assert_equal([], result.messages) -@istest -def empty_paragraphs_are_ignored_by_default(): - with open(test_path("empty.docx"), "rb") as fileobj: +def test_empty_paragraphs_are_ignored_by_default(): + with open(generate_test_path("empty.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("", result.value) assert_equal([], result.messages) -@istest -def empty_paragraphs_are_preserved_if_ignore_empty_paragraphs_is_false(): - with open(test_path("empty.docx"), "rb") as fileobj: +def test_empty_paragraphs_are_preserved_if_ignore_empty_paragraphs_is_false(): + with open(generate_test_path("empty.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, ignore_empty_paragraphs=False) assert_equal("<p></p>", result.value) assert_equal([], result.messages) -@istest -def embedded_style_map_is_used_if_present(): - with open(test_path("embedded-style-map.docx"), "rb") as fileobj: +def test_embedded_style_map_is_used_if_present(): + with open(generate_test_path("embedded-style-map.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("<h1>Walking on imported air</h1>", result.value) assert_equal([], result.messages) -@istest -def explicit_style_map_takes_precedence_over_embedded_style_map(): - with open(test_path("embedded-style-map.docx"), "rb") as fileobj: +def test_explicit_style_map_takes_precedence_over_embedded_style_map(): + with open(generate_test_path("embedded-style-map.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, style_map="p => p") assert_equal("<p>Walking on imported air</p>", result.value) assert_equal([], result.messages) -@istest -def explicit_style_map_is_combined_with_embedded_style_map(): - with open(test_path("embedded-style-map.docx"), "rb") as fileobj: +def test_explicit_style_map_is_combined_with_embedded_style_map(): + with open(generate_test_path("embedded-style-map.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, style_map="r => strong") assert_equal("<h1><strong>Walking on imported air</strong></h1>", result.value) assert_equal([], result.messages) -@istest -def embedded_style_maps_can_be_disabled(): - with open(test_path("embedded-style-map.docx"), "rb") as fileobj: +def test_embedded_style_maps_can_be_disabled(): + with open(generate_test_path("embedded-style-map.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, include_embedded_style_map=False) assert_equal("<p>Walking on imported air</p>", result.value) assert_equal([], result.messages) -@istest -def embedded_style_map_can_be_written_and_then_read(): +def test_embedded_style_map_can_be_written_and_then_read(): with _copy_of_test_data("single-paragraph.docx") as fileobj: mammoth.embed_style_map(fileobj, "p => h1") result = mammoth.convert_to_html(fileobj=fileobj, ignore_empty_paragraphs=False) @@ -89,68 +79,61 @@ def embedded_style_map_can_be_written_and_then_read(): assert_equal([], result.messages) -@istest -def embedded_style_map_can_be_retrieved(): +def test_embedded_style_map_can_be_retrieved(): with _copy_of_test_data("single-paragraph.docx") as fileobj: mammoth.embed_style_map(fileobj, "p => h1") assert_equal("p => h1", mammoth.read_embedded_style_map(fileobj)) -@istest -def warning_if_style_mapping_is_not_understood(): +def test_warning_if_style_mapping_is_not_understood(): style_map = """ !!!! p => h1""" - with open(test_path("single-paragraph.docx"), "rb") as fileobj: + with open(generate_test_path("single-paragraph.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, style_map=style_map) assert_equal("<h1>Walking on imported air</h1>", result.value) warning = "Did not understand this style mapping, so ignored it: !!!!" assert_equal([results.warning(warning)], result.messages) -@istest -def inline_images_referenced_by_path_relative_to_part_are_included_in_output(): - with open(test_path("tiny-picture.docx"), "rb") as fileobj: +def test_inline_images_referenced_by_path_relative_to_part_are_included_in_output(): + with open(generate_test_path("tiny-picture.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("""<p><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAAAAXNSR0IArs4c6QAAAAlwSFlzAAAOvgAADr4B6kKxwAAAABNJREFUKFNj/M+ADzDhlWUYqdIAQSwBE8U+X40AAAAASUVORK5CYII=" /></p>""", result.value) assert_equal([], result.messages) -@istest -def inline_images_referenced_by_path_relative_to_base_are_included_in_output(): - with open(test_path("tiny-picture-target-base-relative.docx"), "rb") as fileobj: +def test_inline_images_referenced_by_path_relative_to_base_are_included_in_output(): + with open(generate_test_path("tiny-picture-target-base-relative.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("""<p><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAAAAXNSR0IArs4c6QAAAAlwSFlzAAAOvgAADr4B6kKxwAAAABNJREFUKFNj/M+ADzDhlWUYqdIAQSwBE8U+X40AAAAASUVORK5CYII=" /></p>""", result.value) assert_equal([], result.messages) -@istest -def images_stored_outside_of_document_are_included_in_output(): - with open(test_path("external-picture.docx"), "rb") as fileobj: +def test_images_stored_outside_of_document_are_included_in_output(): + with open(generate_test_path("external-picture.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("""<p><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAAAAXNSR0IArs4c6QAAAAlwSFlzAAAOvgAADr4B6kKxwAAAABNJREFUKFNj/M+ADzDhlWUYqdIAQSwBE8U+X40AAAAASUVORK5CYII=" /></p>""", result.value) assert_equal([], result.messages) -@istest -def warn_if_images_stored_outside_of_document_are_specified_when_passing_fileobj_without_name(): +def test_warn_if_images_stored_outside_of_document_are_specified_when_passing_fileobj_without_name(): fileobj = io.BytesIO() - with open(test_path("external-picture.docx"), "rb") as source_fileobj: + with open(generate_test_path("external-picture.docx"), "rb") as source_fileobj: shutil.copyfileobj(source_fileobj, fileobj) - + result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("", result.value) assert_equal([results.warning("could not find external image 'tiny-picture.png', fileobj has no name")], result.messages) -@istest -def warn_if_images_stored_outside_of_document_are_not_found(): +def test_warn_if_images_stored_outside_of_document_are_not_found(): with tempman.create_temp_dir() as temp_dir: document_path = os.path.join(temp_dir.path, "document.docx") with open(document_path, "wb") as fileobj: - with open(test_path("external-picture.docx"), "rb") as source_fileobj: + with open(generate_test_path("external-picture.docx"), "rb") as source_fileobj: shutil.copyfileobj(source_fileobj, fileobj) - + with open(document_path, "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("", result.value) @@ -160,90 +143,83 @@ def warn_if_images_stored_outside_of_document_are_not_found(): assert_equal(1, len(result.messages)) -@istest -def image_conversion_can_be_customised(): +def test_image_conversion_can_be_customised(): @mammoth.images.img_element def convert_image(image): with image.open() as image_bytes: encoded_src = base64.b64encode(image_bytes.read()).decode("ascii") - + return { "src": encoded_src[:2] + "," + image.content_type } - - with open(test_path("tiny-picture.docx"), "rb") as fileobj: + + with open(generate_test_path("tiny-picture.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, convert_image=convert_image) assert_equal("""<p><img src="iV,image/png" /></p>""", result.value) assert_equal([], result.messages) - -@istest -def simple_list_is_converted_to_list_elements(): - with open(test_path("simple-list.docx"), "rb") as fileobj: + +def test_simple_list_is_converted_to_list_elements(): + with open(generate_test_path("simple-list.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal([], result.messages) assert_equal("<ul><li>Apple</li><li>Banana</li></ul>", result.value) -@istest -def word_tables_are_converted_to_html_tables(): +def test_word_tables_are_converted_to_html_tables(): expected_html = ("<p>Above</p>" + "<table>" + "<tr><td><p>Top left</p></td><td><p>Top right</p></td></tr>" + "<tr><td><p>Bottom left</p></td><td><p>Bottom right</p></td></tr>" + "</table>" + "<p>Below</p>") - - - with open(test_path("tables.docx"), "rb") as fileobj: + + + with open(generate_test_path("tables.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal([], result.messages) assert_equal(expected_html, result.value) -@istest -def footnotes_are_appended_to_text(): +def test_footnotes_are_appended_to_text(): # TODO: don't duplicate footnotes with multiple references expected_html = ('<p>Ouch' + '<sup><a href="#doc-42-footnote-1" id="doc-42-footnote-ref-1">[1]</a></sup>.' + '<sup><a href="#doc-42-footnote-2" id="doc-42-footnote-ref-2">[2]</a></sup></p>' + '<ol><li id="doc-42-footnote-1"><p> A tachyon walks into a bar. <a href="#doc-42-footnote-ref-1">↑</a></p></li>' + '<li id="doc-42-footnote-2"><p> Fin. <a href="#doc-42-footnote-ref-2">↑</a></p></li></ol>') - - with open(test_path("footnotes.docx"), "rb") as fileobj: + + with open(generate_test_path("footnotes.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, id_prefix="doc-42-") assert_equal([], result.messages) assert_equal(expected_html, result.value) -@istest -def endnotes_are_appended_to_text(): +def test_endnotes_are_appended_to_text(): expected_html = ('<p>Ouch' + '<sup><a href="#doc-42-endnote-2" id="doc-42-endnote-ref-2">[1]</a></sup>.' + '<sup><a href="#doc-42-endnote-3" id="doc-42-endnote-ref-3">[2]</a></sup></p>' + '<ol><li id="doc-42-endnote-2"><p> A tachyon walks into a bar. <a href="#doc-42-endnote-ref-2">↑</a></p></li>' + '<li id="doc-42-endnote-3"><p> Fin. <a href="#doc-42-endnote-ref-3">↑</a></p></li></ol>') - - with open(test_path("endnotes.docx"), "rb") as fileobj: + + with open(generate_test_path("endnotes.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, id_prefix="doc-42-") assert_equal([], result.messages) assert_equal(expected_html, result.value) -@istest -def relationships_are_handled_properly_in_footnotes(): +def test_relationships_are_handled_properly_in_footnotes(): expected_html = ( '<p><sup><a href="#doc-42-footnote-1" id="doc-42-footnote-ref-1">[1]</a></sup></p>' + '<ol><li id="doc-42-footnote-1"><p> <a href="http://www.example.com">Example</a> <a href="#doc-42-footnote-ref-1">↑</a></p></li></ol>') - - with open(test_path("footnote-hyperlink.docx"), "rb") as fileobj: + + with open(generate_test_path("footnote-hyperlink.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, id_prefix="doc-42-") assert_equal([], result.messages) assert_equal(expected_html, result.value) -@istest -def when_style_mapping_is_defined_for_comment_references_then_comments_are_included(): +def test_when_style_mapping_is_defined_for_comment_references_then_comments_are_included(): expected_html = ( '<p>Ouch' + '<sup><a href="#doc-42-comment-0" id="doc-42-comment-ref-0">[MW1]</a></sup>.' + @@ -251,89 +227,80 @@ def when_style_mapping_is_defined_for_comment_references_then_comments_are_inclu '<dl><dt id="doc-42-comment-0">Comment [MW1]</dt><dd><p>A tachyon walks into a bar. <a href="#doc-42-comment-ref-0">↑</a></p></dd>' + '<dt id="doc-42-comment-2">Comment [MW2]</dt><dd><p>Fin. <a href="#doc-42-comment-ref-2">↑</a></p></dd></dl>' ) - - with open(test_path("comments.docx"), "rb") as fileobj: + + with open(generate_test_path("comments.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, id_prefix="doc-42-", style_map="comment-reference => sup") assert_equal([], result.messages) assert_equal(expected_html, result.value) -@istest -def text_boxes_are_read(): - with open(test_path("text-box.docx"), "rb") as fileobj: +def test_text_boxes_are_read(): + with open(generate_test_path("text-box.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal('<p>Datum plane</p>', result.value) -@istest -def underline_is_ignored_by_default(): - with open(test_path("underline.docx"), "rb") as fileobj: +def test_underline_is_ignored_by_default(): + with open(generate_test_path("underline.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal('<p><strong>The Sunset Tree</strong></p>', result.value) -@istest -def underline_can_be_configured_with_style_mapping(): - with open(test_path("underline.docx"), "rb") as fileobj: +def test_underline_can_be_configured_with_style_mapping(): + with open(generate_test_path("underline.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, style_map="u => em") assert_equal('<p><strong>The <em>Sunset</em> Tree</strong></p>', result.value) -@istest -def strikethrough_is_converted_to_s_element_by_default(): - with open(test_path("strikethrough.docx"), "rb") as fileobj: +def test_strikethrough_is_converted_to_s_element_by_default(): + with open(generate_test_path("strikethrough.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj) assert_equal("<p><s>Today's Special: Salmon</s> Sold out</p>", result.value) -@istest -def strikethrough_conversion_can_be_configured_with_style_mapping(): - with open(test_path("strikethrough.docx"), "rb") as fileobj: +def test_strikethrough_conversion_can_be_configured_with_style_mapping(): + with open(generate_test_path("strikethrough.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, style_map="strike => del") assert_equal("<p><del>Today's Special: Salmon</del> Sold out</p>", result.value) -@istest -def transform_document_is_applied_to_document_before_conversion(): +def test_transform_document_is_applied_to_document_before_conversion(): def transform_document(document): document.children[0].style_id = "Heading1" return document - - with open(test_path("single-paragraph.docx"), "rb") as fileobj: + + with open(generate_test_path("single-paragraph.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, transform_document=transform_document) assert_equal("<h1>Walking on imported air</h1>", result.value) assert_equal([], result.messages) -@istest -def paragraph_transform_only_transforms_paragraphs(): +def test_paragraph_transform_only_transforms_paragraphs(): def transform_paragraph(paragraph): return paragraph.copy(style_id="Heading1") transform_document = mammoth.transforms.paragraph(transform_paragraph) - with open(test_path("single-paragraph.docx"), "rb") as fileobj: + with open(generate_test_path("single-paragraph.docx"), "rb") as fileobj: result = mammoth.convert_to_html(fileobj=fileobj, transform_document=transform_document) assert_equal("<h1>Walking on imported air</h1>", result.value) assert_equal([], result.messages) -@istest -def docx_containing_one_paragraph_can_be_converted_to_markdown(): - with open(test_path("single-paragraph.docx"), "rb") as fileobj: +def test_docx_containing_one_paragraph_can_be_converted_to_markdown(): + with open(generate_test_path("single-paragraph.docx"), "rb") as fileobj: result = mammoth.convert_to_markdown(fileobj=fileobj) assert_equal("Walking on imported air\n\n", result.value) assert_equal([], result.messages) -@istest -def can_extract_raw_text(): - with open(test_path("simple-list.docx"), "rb") as fileobj: +def test_can_extract_raw_text(): + with open(generate_test_path("simple-list.docx"), "rb") as fileobj: result = mammoth.extract_raw_text(fileobj=fileobj) assert_equal([], result.messages) assert_equal("Apple\n\nBanana\n\n", result.value) - + def _copy_of_test_data(path): destination = io.BytesIO() - with open(test_path(path), "rb") as source: + with open(generate_test_path(path), "rb") as source: shutil.copyfileobj(source, destination) return destination diff --git a/tests/options_tests.py b/tests/options_tests.py index 182678e..e3d09ef 100644 --- a/tests/options_tests.py +++ b/tests/options_tests.py @@ -1,16 +1,13 @@ -from nose.tools import istest, assert_equal - from mammoth.options import read_options, _default_style_map from mammoth.styles.parser import read_style_mapping +from .testing import assert_equal -@istest -def default_style_map_is_used_if_style_map_is_not_set(): +def test_default_style_map_is_used_if_style_map_is_not_set(): assert_equal(_default_style_map, read_options({}).value["style_map"]) -@istest -def custom_style_mappings_are_prepended_to_default_style_mappings(): +def test_custom_style_mappings_are_prepended_to_default_style_mappings(): style_map = read_options({ "style_map": "p.SectionTitle => h2" }).value["style_map"] @@ -18,8 +15,7 @@ def custom_style_mappings_are_prepended_to_default_style_mappings(): assert_equal(_default_style_map, style_map[1:]) -@istest -def default_style_mappings_are_ignored_if_include_default_style_map_is_false(): +def test_default_style_mappings_are_ignored_if_include_default_style_map_is_false(): style_map = read_options({ "style_map": "p.SectionTitle => h2", "include_default_style_map": False @@ -27,8 +23,7 @@ def default_style_mappings_are_ignored_if_include_default_style_map_is_false(): assert_equal([read_style_mapping("p.SectionTitle => h2").value], style_map) -@istest -def lines_starting_with_hash_in_custom_style_map_are_ignored(): +def test_lines_starting_with_hash_in_custom_style_map_are_ignored(): style_map = read_options({ "style_map": "#p.SectionTitle => h3\np.SectionTitle => h2", "include_default_style_map": False diff --git a/tests/raw_text_tests.py b/tests/raw_text_tests.py index 7dd44a0..bdb1395 100644 --- a/tests/raw_text_tests.py +++ b/tests/raw_text_tests.py @@ -1,11 +1,9 @@ -from nose.tools import istest, assert_equal - from mammoth.raw_text import extract_raw_text_from_element from mammoth import documents +from .testing import assert_equal -@istest -def text_element_is_converted_to_text_content(): +def test_text_element_is_converted_to_text_content(): element = documents.Text("Hello.") result = extract_raw_text_from_element(element) @@ -13,8 +11,7 @@ def text_element_is_converted_to_text_content(): assert_equal("Hello.", result) -@istest -def tab_element_is_converted_to_tab_character(): +def test_tab_element_is_converted_to_tab_character(): element = documents.tab() result = extract_raw_text_from_element(element) @@ -22,8 +19,7 @@ def tab_element_is_converted_to_tab_character(): assert_equal("\t", result) -@istest -def paragraphs_are_terminated_with_newlines(): +def test_paragraphs_are_terminated_with_newlines(): element = documents.paragraph( children=[ documents.Text("Hello "), @@ -36,8 +32,7 @@ def paragraphs_are_terminated_with_newlines(): assert_equal("Hello world.\n\n", result) -@istest -def children_are_recursively_converted_to_text(): +def test_children_are_recursively_converted_to_text(): element = documents.document([ documents.paragraph( [ @@ -53,8 +48,7 @@ def children_are_recursively_converted_to_text(): assert_equal("Hello world.\n\n", result) -@istest -def non_text_element_without_children_is_converted_to_empty_string(): +def test_non_text_element_without_children_is_converted_to_empty_string(): element = documents.line_break assert not hasattr(element, "children") diff --git a/tests/styles/document_matcher_tests.py b/tests/styles/document_matcher_tests.py index dccf4f1..f9034ce 100644 --- a/tests/styles/document_matcher_tests.py +++ b/tests/styles/document_matcher_tests.py @@ -1,17 +1,14 @@ -from nose.tools import istest, assert_equal - from mammoth import document_matchers +from ..testing import assert_equal -@istest -def equal_to_matcher_is_case_insensitive(): +def test_equal_to_matcher_is_case_insensitive(): matcher = document_matchers.equal_to("Heading 1") assert_equal(True, matcher.matches("heaDING 1")) assert_equal(False, matcher.matches("heaDING 2")) -@istest -def starts_with_matcher_matches_string_with_prefix(): +def test_starts_with_matcher_matches_string_with_prefix(): matcher = document_matchers.starts_with("Heading") assert_equal(True, matcher.matches("Heading")) assert_equal(True, matcher.matches("Heading 1")) @@ -20,7 +17,6 @@ def starts_with_matcher_matches_string_with_prefix(): assert_equal(False, matcher.matches("Header 2")) -@istest -def starts_with_matcher_is_case_insensitive(): +def test_starts_with_matcher_is_case_insensitive(): matcher = document_matchers.starts_with("Heading") assert_equal(True, matcher.matches("heaDING")) diff --git a/tests/styles/parser/document_matcher_parser_tests.py b/tests/styles/parser/document_matcher_parser_tests.py index 18233d2..1808571 100644 --- a/tests/styles/parser/document_matcher_parser_tests.py +++ b/tests/styles/parser/document_matcher_parser_tests.py @@ -1,200 +1,172 @@ -from nose.tools import istest, assert_equal - from mammoth import documents, document_matchers from mammoth.styles.parser.document_matcher_parser import parse_document_matcher from mammoth.styles.parser.errors import LineParseError from mammoth.styles.parser.tokeniser import tokenise from mammoth.styles.parser.token_iterator import TokenIterator -from ...testing import assert_raises +from ...testing import assert_equal, assert_raises -@istest -def unrecognised_document_element_raises_error(): +def test_unrecognised_document_element_raises_error(): error = assert_raises(LineParseError, lambda: read_document_matcher("x")) assert_equal("Unrecognised document element: x", str(error)) -@istest -def reads_plain_paragraph(): +def test_reads_plain_paragraph(): assert_equal( document_matchers.paragraph(), read_document_matcher("p") ) -@istest -def reads_paragraph_with_style_id(): +def test_reads_paragraph_with_style_id(): assert_equal( document_matchers.paragraph(style_id="Heading1"), read_document_matcher("p.Heading1") ) -@istest -def reads_paragraph_with_exact_style_name(): +def test_reads_paragraph_with_exact_style_name(): assert_equal( document_matchers.paragraph(style_name=document_matchers.equal_to("Heading 1")), read_document_matcher("p[style-name='Heading 1']") ) -@istest -def reads_paragraph_with_style_name_prefix(): +def test_reads_paragraph_with_style_name_prefix(): assert_equal( document_matchers.paragraph(style_name=document_matchers.starts_with("Heading")), read_document_matcher("p[style-name^='Heading']") ) -@istest -def unrecognised_string_matcher_raises_error(): +def test_unrecognised_string_matcher_raises_error(): error = assert_raises(LineParseError, lambda: read_document_matcher("p[style-name*='Heading']")) assert_equal("Unrecognised string matcher: *", str(error)) -@istest -def reads_paragraph_ordered_list(): +def test_reads_paragraph_ordered_list(): assert_equal( document_matchers.paragraph(numbering=documents.numbering_level(1, is_ordered=True)), read_document_matcher("p:ordered-list(2)") ) -@istest -def reads_paragraph_unordered_list(): +def test_reads_paragraph_unordered_list(): assert_equal( document_matchers.paragraph(numbering=documents.numbering_level(1, is_ordered=False)), read_document_matcher("p:unordered-list(2)") ) -@istest -def unrecognised_list_type_raises_error(): +def test_unrecognised_list_type_raises_error(): error = assert_raises(LineParseError, lambda: read_document_matcher("p:blah")) assert_equal("Unrecognised list type: blah", str(error)) -@istest -def reads_plain_run(): +def test_reads_plain_run(): assert_equal( document_matchers.run(), read_document_matcher("r") ) -@istest -def reads_run_with_style_id(): +def test_reads_run_with_style_id(): assert_equal( document_matchers.run(style_id="Emphasis"), read_document_matcher("r.Emphasis") ) -@istest -def reads_run_with_style_name(): +def test_reads_run_with_style_name(): assert_equal( document_matchers.run(style_name=document_matchers.equal_to("Emphasis")), read_document_matcher("r[style-name='Emphasis']") ) -@istest -def reads_plain_table(): +def test_reads_plain_table(): assert_equal( document_matchers.table(), read_document_matcher("table") ) -@istest -def reads_table_with_style_id(): +def test_reads_table_with_style_id(): assert_equal( document_matchers.table(style_id="TableNormal"), read_document_matcher("table.TableNormal") ) -@istest -def reads_table_with_style_name(): +def test_reads_table_with_style_name(): assert_equal( document_matchers.table(style_name=document_matchers.equal_to("Normal Table")), read_document_matcher("table[style-name='Normal Table']") ) -@istest -def reads_bold(): +def test_reads_bold(): assert_equal( document_matchers.bold, read_document_matcher("b") ) -@istest -def reads_italic(): +def test_reads_italic(): assert_equal( document_matchers.italic, read_document_matcher("i") ) -@istest -def reads_underline(): +def test_reads_underline(): assert_equal( document_matchers.underline, read_document_matcher("u") ) -@istest -def reads_strikethrough(): +def test_reads_strikethrough(): assert_equal( document_matchers.strikethrough, read_document_matcher("strike") ) -@istest -def reads_all_caps(): +def test_reads_all_caps(): assert_equal( document_matchers.all_caps, read_document_matcher("all-caps") ) -@istest -def reads_small_caps(): +def test_reads_small_caps(): assert_equal( document_matchers.small_caps, read_document_matcher("small-caps") ) -@istest -def reads_comment_reference(): +def test_reads_comment_reference(): assert_equal( document_matchers.comment_reference, read_document_matcher("comment-reference") ) -@istest -def reads_line_breaks(): +def test_reads_line_breaks(): assert_equal( document_matchers.line_break, read_document_matcher("br[type='line']"), ) -@istest -def reads_page_breaks(): +def test_reads_page_breaks(): assert_equal( document_matchers.page_break, read_document_matcher("br[type='page']"), ) -@istest -def reads_column_breaks(): +def test_reads_column_breaks(): assert_equal( document_matchers.column_break, read_document_matcher("br[type='column']"), ) -@istest -def unrecognised_break_type_raises_error(): +def test_unrecognised_break_type_raises_error(): error = assert_raises(LineParseError, lambda: read_document_matcher("br[type='unknownBreakType']")) assert_equal("Unrecognised break type: unknownBreakType", str(error)) diff --git a/tests/styles/parser/html_path_parser_tests.py b/tests/styles/parser/html_path_parser_tests.py index 1e34ea1..0c2ef3a 100644 --- a/tests/styles/parser/html_path_parser_tests.py +++ b/tests/styles/parser/html_path_parser_tests.py @@ -1,84 +1,73 @@ -from nose.tools import istest, assert_equal - from mammoth import html_paths from mammoth.styles.parser.html_path_parser import parse_html_path from mammoth.styles.parser.tokeniser import tokenise from mammoth.styles.parser.token_iterator import TokenIterator +from ...testing import assert_equal -@istest -def can_read_empty_path(): +def test_can_read_empty_path(): assert_equal( html_paths.empty, read_html_path("") ) -@istest -def can_read_single_element(): +def test_can_read_single_element(): assert_equal( html_paths.path([html_paths.element(["p"])]), read_html_path("p") ) -@istest -def can_read_choice_of_two_elements(): +def test_can_read_choice_of_two_elements(): assert_equal( html_paths.path([html_paths.element(["ul", "ol"])]), read_html_path("ul|ol") ) -@istest -def can_read_choice_of_three_elements(): +def test_can_read_choice_of_three_elements(): assert_equal( html_paths.path([html_paths.element(["ul", "ol", "p"])]), read_html_path("ul|ol|p") ) -@istest -def can_read_nested_elements(): +def test_can_read_nested_elements(): assert_equal( html_paths.path([html_paths.element(["ul"]), html_paths.element(["li"])]), read_html_path("ul > li") ) -@istest -def can_read_class_on_element(): +def test_can_read_class_on_element(): assert_equal( html_paths.path([html_paths.element(["p"], class_names=["tip"])]), read_html_path("p.tip") ) -@istest -def can_read_multiple_classes_on_element(): +def test_can_read_multiple_classes_on_element(): assert_equal( html_paths.path([html_paths.element(["p"], class_names=["tip", "help"])]), read_html_path("p.tip.help") ) -@istest -def can_read_when_element_must_be_fresh(): +def test_can_read_when_element_must_be_fresh(): assert_equal( html_paths.path([html_paths.element(["p"], fresh=True)]), read_html_path("p:fresh") ) -@istest -def can_read_separator_for_elements(): +def test_can_read_separator_for_elements(): assert_equal( html_paths.path([html_paths.element(["p"], separator="x")]), read_html_path("p:separator('x')") ) -@istest -def can_read_ignore_element(): +def test_can_read_ignore_element(): assert_equal( html_paths.ignore, read_html_path("!") diff --git a/tests/styles/parser/style_mapping_parser_tests.py b/tests/styles/parser/style_mapping_parser_tests.py index 7b5b299..f2b92c0 100644 --- a/tests/styles/parser/style_mapping_parser_tests.py +++ b/tests/styles/parser/style_mapping_parser_tests.py @@ -1,13 +1,11 @@ -from nose.tools import istest, assert_equal - from mammoth import html_paths, document_matchers, styles from mammoth.styles.parser.style_mapping_parser import parse_style_mapping from mammoth.styles.parser.tokeniser import tokenise from mammoth.styles.parser.token_iterator import TokenIterator +from ...testing import assert_equal -@istest -def document_matcher_is_mapped_to_html_path_using_fat_arrow(): +def test_document_matcher_is_mapped_to_html_path_using_fat_arrow(): assert_equal( styles.style(document_matchers.paragraph(), html_paths.path([html_paths.element(["h1"])])), read_style_mapping("p => h1") diff --git a/tests/styles/parser/token_parser_tests.py b/tests/styles/parser/token_parser_tests.py index 0e278c7..3192dc9 100644 --- a/tests/styles/parser/token_parser_tests.py +++ b/tests/styles/parser/token_parser_tests.py @@ -1,12 +1,10 @@ -from nose.tools import istest, assert_equal - from mammoth.styles.parser.tokeniser import Token, TokenType from mammoth.styles.parser.token_parser import decode_escape_sequences, parse_identifier, parse_string from mammoth.styles.parser.token_iterator import TokenIterator +from ...testing import assert_equal -@istest -def escape_sequences_in_identifiers_are_decoded(): +def test_escape_sequences_in_identifiers_are_decoded(): assert_equal( ":", parse_identifier(TokenIterator([ @@ -15,8 +13,7 @@ def escape_sequences_in_identifiers_are_decoded(): ) -@istest -def escape_sequences_in_strings_are_decoded(): +def test_escape_sequences_in_strings_are_decoded(): assert_equal( "\n", parse_string(TokenIterator([ @@ -25,26 +22,21 @@ def escape_sequences_in_strings_are_decoded(): ) -@istest -def line_feeds_are_decoded(): +def test_line_feeds_are_decoded(): assert_equal("\n", decode_escape_sequences(r"\n")) -@istest -def carriage_returns_are_decoded(): +def test_carriage_returns_are_decoded(): assert_equal("\r", decode_escape_sequences(r"\r")) -@istest -def tabs_are_decoded(): +def test_tabs_are_decoded(): assert_equal("\t", decode_escape_sequences(r"\t")) -@istest -def backslashes_are_decoded(): +def test_backslashes_are_decoded(): assert_equal("\\", decode_escape_sequences(r"\\")) -@istest -def colons_are_decoded(): +def test_colons_are_decoded(): assert_equal(":", decode_escape_sequences(r"\:")) diff --git a/tests/testing.py b/tests/testing.py index c5013dc..e75d630 100644 --- a/tests/testing.py +++ b/tests/testing.py @@ -1,18 +1,21 @@ import os -from nose.tools import nottest +from precisely import assert_that, equal_to -@nottest -def test_path(path): +def generate_test_path(path): this_dir = os.path.dirname(__file__) return os.path.join(this_dir, "test-data", path) +def assert_equal(expected, actual): + assert_that(actual, equal_to(expected)) + + def assert_raises(exception, func): try: func() assert False, "Expected " + exception.__name__ except exception as error: return error - + diff --git a/tests/transforms_tests.py b/tests/transforms_tests.py index d0604f8..94ce79a 100644 --- a/tests/transforms_tests.py +++ b/tests/transforms_tests.py @@ -1,61 +1,53 @@ import cobble -from nose.tools import assert_equal, istest from mammoth import documents, transforms from mammoth.transforms import get_descendants, get_descendants_of_type, _each_element +from .testing import assert_equal -@istest class ParagraphTests(object): - @istest - def paragraph_is_transformed(self): + def test_paragraph_is_transformed(self): paragraph = documents.paragraph(children=[]) result = transforms.paragraph(lambda _: documents.tab())(paragraph) assert_equal(documents.tab(), result) - - @istest - def non_paragraph_elements_are_not_transformed(self): + + def test_non_paragraph_elements_are_not_transformed(self): run = documents.run(children=[]) result = transforms.paragraph(lambda _: documents.tab())(run) assert_equal(documents.run(children=[]), result) -@istest class RunTests(object): - @istest - def run_is_transformed(self): + def test_run_is_transformed(self): run = documents.run(children=[]) result = transforms.run(lambda _: documents.tab())(run) assert_equal(documents.tab(), result) - - @istest - def non_paragraph_elements_are_not_transformed(self): + + def test_non_paragraph_elements_are_not_transformed(self): paragraph = documents.paragraph(children=[]) result = transforms.run(lambda _: documents.tab())(paragraph) assert_equal(documents.paragraph(children=[]), result) -@istest class EachElementTests(object): - @istest - def all_descendants_are_transformed(self): + def test_all_descendants_are_transformed(self): @cobble.data class Count(documents.HasChildren): count = cobble.field() - + root = Count(count=None, children=[ Count(count=None, children=[ Count(count=None, children=[]), ]), ]) - + current_count = [0] def set_count(node): current_count[0] += 1 return node.copy(count=current_count[0]) - + result = _each_element(set_count)(root) - + assert_equal(Count(count=3, children=[ Count(count=2, children=[ Count(count=1, children=[]), @@ -63,34 +55,27 @@ class EachElementTests(object): ]), result) -@istest class GetDescendantsTests(object): - @istest - def returns_nothing_if_element_type_has_no_children(self): + def test_returns_nothing_if_element_type_has_no_children(self): assert_equal([], get_descendants(documents.tab())) - - @istest - def returns_nothing_if_element_has_empty_children(self): + + def test_returns_nothing_if_element_has_empty_children(self): assert_equal([], get_descendants(documents.paragraph(children=[]))) - - @istest - def includes_children(self): + + def test_includes_children(self): children = [documents.text("child 1"), documents.text("child 2")] element = documents.paragraph(children=children) assert_equal(children, get_descendants(element)) - - @istest - def includes_indirect_descendants(self): + + def test_includes_indirect_descendants(self): grandchild = documents.text("grandchild") child = documents.run(children=[grandchild]) element = documents.paragraph(children=[child]) assert_equal([grandchild, child], get_descendants(element)) -@istest class GetDescendantsOfTypeTests(object): - @istest - def filters_descendants_to_type(self): + def test_filters_descendants_to_type(self): tab = documents.tab() run = documents.run(children=[]) element = documents.paragraph(children=[tab, run]) diff --git a/tests/writers/markdown_tests.py b/tests/writers/markdown_tests.py index 27d6d56..7083fef 100644 --- a/tests/writers/markdown_tests.py +++ b/tests/writers/markdown_tests.py @@ -1,19 +1,16 @@ from __future__ import unicode_literals -from nose.tools import istest, assert_equal - from mammoth.writers.markdown import MarkdownWriter +from ..testing import assert_equal -@istest -def special_markdown_characters_are_escaped(): +def test_special_markdown_characters_are_escaped(): writer = _create_writer() writer.text(r"\*") assert_equal(r"\\\*", writer.as_string()) -@istest -def unrecognised_elements_are_treated_as_normal_text(): +def test_unrecognised_elements_are_treated_as_normal_text(): writer = _create_writer() writer.start("blah"); writer.text("Hello"); @@ -21,8 +18,7 @@ def unrecognised_elements_are_treated_as_normal_text(): assert_equal("Hello", writer.as_string()) -@istest -def paragraphs_are_terminated_with_double_new_line(): +def test_paragraphs_are_terminated_with_double_new_line(): writer = _create_writer() writer.start("p"); writer.text("Hello"); @@ -30,8 +26,7 @@ def paragraphs_are_terminated_with_double_new_line(): assert_equal("Hello\n\n", writer.as_string()) -@istest -def h1_elements_are_converted_to_heading_with_leading_hash(): +def test_h1_elements_are_converted_to_heading_with_leading_hash(): writer = _create_writer() writer.start("h1"); writer.text("Hello"); @@ -39,8 +34,7 @@ def h1_elements_are_converted_to_heading_with_leading_hash(): assert_equal("# Hello\n\n", writer.as_string()) -@istest -def h6_elements_are_converted_to_heading_with_six_leading_hashes(): +def test_h6_elements_are_converted_to_heading_with_six_leading_hashes(): writer = _create_writer() writer.start("h6"); writer.text("Hello"); @@ -48,16 +42,14 @@ def h6_elements_are_converted_to_heading_with_six_leading_hashes(): assert_equal("###### Hello\n\n", writer.as_string()) -@istest -def br_is_written_as_two_spaces_followed_by_newline(): +def test_br_is_written_as_two_spaces_followed_by_newline(): writer = _create_writer() writer.text("Hello"); writer.self_closing("br"); assert_equal("Hello \n", writer.as_string()) -@istest -def strong_text_is_surrounded_by_two_underscores(): +def test_strong_text_is_surrounded_by_two_underscores(): writer = _create_writer() writer.text("Hello "); writer.start("strong"); @@ -66,8 +58,7 @@ def strong_text_is_surrounded_by_two_underscores(): assert_equal("Hello __World__", writer.as_string()) -@istest -def emphasised_text_is_surrounded_by_one_asterix(): +def test_emphasised_text_is_surrounded_by_one_asterix(): writer = _create_writer() writer.text("Hello "); writer.start("em"); @@ -76,72 +67,63 @@ def emphasised_text_is_surrounded_by_one_asterix(): assert_equal("Hello *World*", writer.as_string()) -@istest -def anchor_tags_are_written_as_hyperlinks(): +def test_anchor_tags_are_written_as_hyperlinks(): writer = _create_writer() writer.start("a", {"href": "http://example.com"}); writer.text("Hello"); writer.end("a"); assert_equal("[Hello](http://example.com)", writer.as_string()) - -@istest -def anchor_tags_without_href_attribute_are_treated_as_ordinary_text(): + +def test_anchor_tags_without_href_attribute_are_treated_as_ordinary_text(): writer = _create_writer() writer.start("a"); writer.text("Hello"); writer.end("a"); assert_equal("Hello", writer.as_string()) - -@istest -def elements_with_ids_have_anchor_tags_with_ids_appended_to_start_of_markdown_element(): + +def test_elements_with_ids_have_anchor_tags_with_ids_appended_to_start_of_markdown_element(): writer = _create_writer() writer.start("h1", {"id": "start"}) writer.text("Hello") writer.end("h1") assert_equal('# <a id="start"></a>Hello\n\n', writer.as_string()) - -@istest -def links_have_anchors_before_opening_square_bracket(): + +def test_links_have_anchors_before_opening_square_bracket(): writer = _create_writer() writer.start("a", {"href": "http://example.com", "id": "start"}) writer.text("Hello") writer.end("a") assert_equal('<a id="start"></a>[Hello](http://example.com)', writer.as_string()) - -@istest -def image_elements_are_written_as_markdown_images(): + +def test_image_elements_are_written_as_markdown_images(): writer = _create_writer() writer.self_closing("img", {"src": "http://example.com/image.jpg", "alt": "Alt Text"}) assert_equal("", writer.as_string()) - -@istest -def images_are_written_even_if_they_dont_have_alt_text(): + +def test_images_are_written_even_if_they_dont_have_alt_text(): writer = _create_writer() writer.self_closing("img", {"src": "http://example.com/image.jpg"}) assert_equal("", writer.as_string()) - -@istest -def images_are_written_even_if_they_dont_have_a_src_attribute(): + +def test_images_are_written_even_if_they_dont_have_a_src_attribute(): writer = _create_writer() writer.self_closing("img", {"alt": "Alt Text"}) assert_equal("![Alt Text]()", writer.as_string()) - -@istest -def image_elements_are_ignored_if_they_have_no_src_and_no_alt_text(): + +def test_image_elements_are_ignored_if_they_have_no_src_and_no_alt_text(): writer = _create_writer() writer.self_closing("img") assert_equal("", writer.as_string()) -@istest -def list_item_outside_of_list_is_treated_as_unordered_list(): +def test_list_item_outside_of_list_is_treated_as_unordered_list(): writer = _create_writer() writer.start("li") writer.text("Fruit") @@ -149,8 +131,7 @@ def list_item_outside_of_list_is_treated_as_unordered_list(): assert_equal("- Fruit\n", writer.as_string()) -@istest -def ol_element_is_written_as_ordered_list_with_sequential_numbering(): +def test_ol_element_is_written_as_ordered_list_with_sequential_numbering(): writer = _create_writer() writer.start("ol") writer.start("li") @@ -163,8 +144,7 @@ def ol_element_is_written_as_ordered_list_with_sequential_numbering(): assert_equal("1. Fruit\n2. Condiments\n\n", writer.as_string()) -@istest -def ul_element_is_written_as_unordered_list_using_hyphens_as_bullets(): +def test_ul_element_is_written_as_unordered_list_using_hyphens_as_bullets(): writer = _create_writer() writer.start("ul") writer.start("li") @@ -177,11 +157,10 @@ def ul_element_is_written_as_unordered_list_using_hyphens_as_bullets(): assert_equal("- Fruit\n- Condiments\n\n", writer.as_string()) -@istest -def numbering_is_separate_for_nested_list_and_parent_list(): +def test_numbering_is_separate_for_nested_list_and_parent_list(): writer = _create_writer() writer.start("ol") - + writer.start("li") writer.text("Fruit") writer.start("ol") @@ -193,13 +172,13 @@ def numbering_is_separate_for_nested_list_and_parent_list(): writer.end("li") writer.end("ol") writer.end("li") - + writer.start("li") writer.text("Condiments") writer.end("li") writer.end("ol") assert_equal("1. Fruit\n\t1. Apple\n\t2. Banana\n2. Condiments\n\n", writer.as_string()) - + def _create_writer(): diff --git a/tests/zips_tests.py b/tests/zips_tests.py index 8d1505f..b443bcd 100644 --- a/tests/zips_tests.py +++ b/tests/zips_tests.py @@ -1,36 +1,30 @@ -from nose.tools import istest, assert_equal - from mammoth import zips +from .testing import assert_equal -@istest -def split_path_splits_zip_paths_on_last_forward_slash(): +def test_split_path_splits_zip_paths_on_last_forward_slash(): assert_equal(("a", "b"), zips.split_path("a/b")) assert_equal(("a/b", "c"), zips.split_path("a/b/c")) assert_equal(("/a/b", "c"), zips.split_path("/a/b/c")) -@istest -def when_path_has_no_forward_slashes_then_split_path_returns_empty_dirname(): +def test_when_path_has_no_forward_slashes_then_split_path_returns_empty_dirname(): assert_equal(("", "name"), zips.split_path("name")) -@istest -def join_path_joins_arguments_with_forward_slashes(): +def test_join_path_joins_arguments_with_forward_slashes(): assert_equal("a/b", zips.join_path("a", "b")) assert_equal("a/b/c", zips.join_path("a/b", "c")) assert_equal("/a/b/c", zips.join_path("/a/b", "c")) -@istest -def empty_parts_are_ignored_when_joining_paths(): +def test_empty_parts_are_ignored_when_joining_paths(): assert_equal("a", zips.join_path("a", "")) assert_equal("b", zips.join_path("", "b")) assert_equal("a/b", zips.join_path("a", "", "b")) -@istest -def when_joining_paths_then_absolute_paths_ignore_earlier_paths(): +def test_when_joining_paths_then_absolute_paths_ignore_earlier_paths(): assert_equal("/b", zips.join_path("a", "/b")) assert_equal("/b/c", zips.join_path("a", "/b", "c")) assert_equal("/b", zips.join_path("/a", "/b")) |