build: remove nose test framework

Author: danodonovan

tests/all_elements_tests.py

@@ -1,48 +1,33 @@
-from nose.tools import istest, assert_equal
 
 from precisely import all_elements, equal_to
 from precisely.results import matched, unmatched
 
 
-@istest
-def matches_when_all_items_in_iterable_match():
+def test_matches_when_all_items_in_iterable_match():
     matcher = all_elements(equal_to("apple"))
 
-    assert_equal(matched(), matcher.match(["apple", "apple"]))
+    assert matched() == matcher.match(["apple", "apple"])
 
 
-@istest
-def mismatches_when_actual_is_not_iterable():
+def test_mismatches_when_actual_is_not_iterable():
     matcher = all_elements(equal_to("apple"))
 
-    assert_equal(
-        unmatched("was not iterable\nwas 0"),
-        matcher.match(0)
-    )
+    assert unmatched("was not iterable\nwas 0") == matcher.match(0)
 
 
-@istest
-def mismatches_when_item_in_iterable_does_not_match():
+def test_mismatches_when_item_in_iterable_does_not_match():
     matcher = all_elements(equal_to("apple"))
 
-    assert_equal(
-        unmatched("element at index 1 mismatched: was 'orange'"),
-        matcher.match(["apple", "orange"])
-    )
+    assert unmatched("element at index 1 mismatched: was 'orange'") == matcher.match(["apple", "orange"])
 
 
-@istest
-def matches_when_iterable_is_empty():
+def test_matches_when_iterable_is_empty():
     matcher = all_elements(equal_to("apple"))
 
-    assert_equal(matched(), matcher.match([]))
+    assert matched() == matcher.match([])
 
 
-@istest
-def description_contains_descriptions_of_submatcher():
+def test_description_contains_descriptions_of_submatcher():
     matcher = all_elements(equal_to("apple"))
 
-    assert_equal(
-        "all elements of iterable match: 'apple'",
-        matcher.describe()
-    )
+    assert "all elements of iterable match: 'apple'" == matcher.describe()

tests/all_of_tests.py

@@ -1,45 +1,35 @@
 import collections
 
-from nose.tools import istest, assert_equal
 
 from precisely import all_of, has_attr, equal_to
 from precisely.results import matched, unmatched
 
 
 User = collections.namedtuple("User", ["username", "email_address"])
 
-@istest
-def matches_when_submatchers_all_match():
+def test_matches_when_submatchers_all_match():
     matcher = all_of(
         has_attr("username", equal_to("bob")),
         has_attr("email_address", equal_to("bob@example.com")),
     )
-    
-    assert_equal(matched(), matcher.match(User("bob", "bob@example.com")))
 
+    assert matched() == matcher.match(User("bob", "bob@example.com"))
 
-@istest
-def mismatches_when_submatcher_mismatches():
+
+def test_mismatches_when_submatcher_mismatches():
     matcher = all_of(
         has_attr("username", equal_to("bob")),
         has_attr("email_address", equal_to("bob@example.com")),
     )
-    
-    assert_equal(
-        unmatched("was missing attribute username"),
-        matcher.match("bobbity")
-    )
+
+    assert unmatched("was missing attribute username") == matcher.match("bobbity")
 
 
-@istest
-def description_contains_descriptions_of_submatchers():
+def test_description_contains_descriptions_of_submatchers():
     matcher = all_of(
         has_attr("username", equal_to("bob")),
         has_attr("email_address", equal_to("bob@example.com")),
     )
-    
-    assert_equal(
-        "all of:\n * object with attribute username: 'bob'\n * object with attribute email_address: 'bob@example.com'",
-        matcher.describe()
-    )
+
+    assert "all of:\n * object with attribute username: 'bob'\n * object with attribute email_address: 'bob@example.com'" == matcher.describe()
 

tests/any_of_tests.py

@@ -1,58 +1,44 @@
 import collections
 
-from nose.tools import istest, assert_equal
 
 from precisely import any_of, has_attr, equal_to
 from precisely.results import matched, unmatched
 
 
 User = collections.namedtuple("User", ["username", "email_address"])
 
-@istest
-def matches_when_submatchers_all_match():
+def test_matches_when_submatchers_all_match():
     matcher = any_of(
         has_attr("username", equal_to("bob")),
         has_attr("email_address", equal_to("bob@example.com")),
     )
-    
-    assert_equal(matched(), matcher.match(User("bob", "bob@example.com")))
 
+    assert matched() == matcher.match(User("bob", "bob@example.com"))
 
-@istest
-def matches_when_any_submatchers_match():
+
+def test_matches_when_any_submatchers_match():
     matcher = any_of(
         equal_to("bob"),
         equal_to("jim"),
     )
-    
-    assert_equal(
-        matched(),
-        matcher.match("bob"),
-    )
 
+    assert matched() == matcher.match("bob")
 
-@istest
-def mismatches_when_no_submatchers_match():
+
+def test_mismatches_when_no_submatchers_match():
     matcher = any_of(
         equal_to("bob"),
         equal_to("jim"),
     )
-    
-    assert_equal(
-        unmatched("did not match any of:\n * 'bob' [was 'alice']\n * 'jim' [was 'alice']"),
-        matcher.match("alice"),
-    )
 
+    assert unmatched("did not match any of:\n * 'bob' [was 'alice']\n * 'jim' [was 'alice']") == matcher.match("alice")
 
-@istest
-def description_contains_descriptions_of_submatchers():
+
+def test_description_contains_descriptions_of_submatchers():
     matcher = any_of(
         has_attr("username", equal_to("bob")),
         has_attr("email_address", equal_to("bob@example.com")),
     )
-    
-    assert_equal(
-        "any of:\n * object with attribute username: 'bob'\n * object with attribute email_address: 'bob@example.com'",
-        matcher.describe()
-    )
+
+    assert "any of:\n * object with attribute username: 'bob'\n * object with attribute email_address: 'bob@example.com'" == matcher.describe()
 

tests/anything_tests.py

@@ -1,17 +1,14 @@
-from nose.tools import istest, assert_equal
 
 from precisely import anything
 from precisely.results import matched
 
 
-@istest
-def matches_anything():
-    assert_equal(matched(), anything.match(4))
-    assert_equal(matched(), anything.match(None))
-    assert_equal(matched(), anything.match("Hello"))
+def test_matches_anything():
+    assert matched() == anything.match(4)
+    assert matched() == anything.match(None)
+    assert matched() == anything.match("Hello")
 
 
-@istest
-def description_is_anything():
-    assert_equal("anything", anything.describe())
+def test_description_is_anything():
+    assert "anything" == anything.describe()
 

tests/assert_that_tests.py

@@ -1,17 +1,14 @@
-from nose.tools import istest, assert_equal
 
 from precisely import assert_that, equal_to
 
 
-@istest
-def assert_that_does_nothing_if_matcher_matches():
+def test_assert_that_does_nothing_if_matcher_matches():
     assert_that(1, equal_to(1))
 
 
-@istest
-def assert_that_raises_assertion_error_if_match_fails():
+def test_assert_that_raises_assertion_error_if_match_fails():
     try:
         assert_that(1, equal_to(2))
         assert False, "Expected AssertionError"
     except AssertionError as error:
-        assert_equal("\nExpected:\n  2\nbut:\n  was 1", str(error))
+        assert "\nExpected:\n  2\nbut:\n  was 1" == str(error)

tests/close_to_tests.py

@@ -1,24 +1,21 @@
 import functools
 
-from nose.tools import istest, assert_equal
 
 from precisely import close_to, is_sequence
 from precisely.results import matched, unmatched
 
 
-@istest
-def close_to_matches_when_actual_is_close_to_value_plus_delta():
+def test_close_to_matches_when_actual_is_close_to_value_plus_delta():
     matcher = close_to(42, 1)
-    assert_equal(matched(), matcher.match(43))
-    assert_equal(matched(), matcher.match(42.5))
-    assert_equal(matched(), matcher.match(42))
-    assert_equal(matched(), matcher.match(41.5))
-    assert_equal(matched(), matcher.match(41))
-    assert_equal(unmatched("was 40 (2 away from 42)"), matcher.match(40))
+    assert matched() == matcher.match(43)
+    assert matched() == matcher.match(42.5)
+    assert matched() == matcher.match(42)
+    assert matched() == matcher.match(41.5)
+    assert matched() == matcher.match(41)
+    assert unmatched("was 40 (2 away from 42)") == matcher.match(40)
 
 
-@istest
-def close_to_matches_any_types_supporting_comparison_and_addition_and_subtraction():
+def test_close_to_matches_any_types_supporting_comparison_and_addition_and_subtraction():
     class Instant(object):
         def __init__(self, seconds_since_epoch):
             self.seconds_since_epoch = seconds_since_epoch
@@ -56,21 +53,19 @@ def __repr__(self):
             return "Interval({})".format(self.seconds)
 
     matcher = close_to(Instant(42), Interval(1))
-    assert_equal(matched(), matcher.match(Instant(43)))
-    assert_equal(matched(), matcher.match(Instant(42.5)))
-    assert_equal(matched(), matcher.match(Instant(42)))
-    assert_equal(matched(), matcher.match(Instant(41.5)))
-    assert_equal(matched(), matcher.match(Instant(41)))
-    assert_equal(unmatched("was Instant(40) (Interval(2) away from Instant(42))"), matcher.match(Instant(40)))
+    assert matched() == matcher.match(Instant(43))
+    assert matched() == matcher.match(Instant(42.5))
+    assert matched() == matcher.match(Instant(42))
+    assert matched() == matcher.match(Instant(41.5))
+    assert matched() == matcher.match(Instant(41))
+    assert unmatched("was Instant(40) (Interval(2) away from Instant(42))") == matcher.match(Instant(40))
 
 
-@istest
-def close_to_description_describes_value():
+def test_close_to_description_describes_value():
     matcher = close_to(42, 1)
-    assert_equal("close to 42 +/- 1", matcher.describe())
+    assert "close to 42 +/- 1" == matcher.describe()
 
 
-@istest
-def close_to_can_be_used_in_composite_matcher():
+def test_close_to_can_be_used_in_composite_matcher():
     matcher = is_sequence("a", "b", close_to(42, 1))
-    assert_equal(matched(), matcher.match(("a", "b", 42)))
+    assert matched() == matcher.match(("a", "b", 42))