Use pytest instead of nose

1 files changed, 27 insertions, 55 deletions

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))