py$(PYV): remove tox env folder $(@D)/.tox/py$(PYV) py$(PYV): commands[0]> python -m nose -vv --with-coverage --cover-package=sure tests.issues.test_issue_104.test_issue_104 ... ok Correctly handle {} characters in matcher string ... ok Test for unicode error when comparing bytes ... ok Test for GitHub Issue #139 ... ok tests.issues.test_issue_148.test_should_compare_dict_with_non_orderable_key_types ... ok tests.issues.test_issue_148.test_should_compare_dict_with_enum_keys ... ok Allow monkey-patching of methods already implemented by sure. ... ok tests.issues.test_issue_48.test_issue_48 ... ok this, it, these and those are all synonyms ... ok this(4).should.equal(2 + 2) ... ok this(1).should.be.within(0, 2) ... ok this(True).should.be.ok ... ok this(False).should.be.false ... ok this(None).should.be.none ... ok this(None).should.be.none ... ok this(function).should.be.callable ... ok this(iterable).should.be.empty ... ok this(iterable).should.have.length_of(N) ... ok this(X).should.be.greater_than(Y) ... ok this(X).should.be.greater_than_or_equal_to(Y) ... ok this(X).should.be.lower_than(Y) ... ok this(X).should.be.lower_than_or_equal_to(Y) ... ok this(X).should.be(X) when X is a reference to the same object ... ok this(instance).should.have.property(property_name) ... ok this(instance).should.have.property(property_name).being or .with_value should allow chain up ... ok this(dictionary).should.have.key(key_name) ... ok this(dictionary).should.have.key(key_name).being or .with_value should allow chain up ... ok this(' aa ... ok test usage of repr() inside expect(complex1).to.equal(complex2) ... ok test usage of repr() inside expect(complex1).to.equal(complex2) ... ok expect('some string').to.match(r'\w{4} \w{6}') matches regex ... ok expect('some string').to.contain('tri') ... ok tests.test_assertion_builder.test_catching_exceptions ... ok tests.test_assertion_builder.test_catching_exceptions_with_params ... ok tests.test_assertion_builder.test_success_with_params ... ok tests.test_assertion_builder.test_success_with_params_exception ... ok tests.test_assertion_builder.test_throw_matching_regex ... ok 'something'.should_not.be.different('SOMETHING'.lower()) ... ok .equal() Should convert mock._CallList instances to lists ... ok .equal(what, epsilon=XXX) should check for equality with an epsilon for float values ... ok .equal() with dict containing tuples as keys should work ... ok .equal(OrderedDict) should check if two ordered dicts are the same ... ok tests.test_assertion_builder.test_equals_anything ... ok tests.test_assertion_builder.test_equals_crosstype ... ok test extending sure with a custom assertion. ... ok test extending sure with a custom chain method. ... ok test extending sure with a custom chain property. ... ok Test ensure simple assertion ... ok Test that ensure only captures AssertionErrors ... ok sure.with_context() runs setup before the function itself ... ok sure.that_with_context() when no context is given it fails ... ok sure.that_with_context() in a failing test ... ok sure.with_context() runs teardown before the function itself ... ok that() is_a(object) ... ok that() equals(string) ... ok that() differs(object) ... ok that() has(object) ... ok that().at(object).equals(object) ... ok that() len_is(number) ... ok that() len_greater_than(number) ... ok that() len_greater_than(number) raise AssertionError ... ok that() len_greater_than_or_equals(number) ... ok that() len_greater_than_or_equals(number) raise AssertionError ... ok that() len_lower_than(number) ... ok that() len_lower_than(number) raise AssertionError ... ok that() len_lower_than_or_equals(number) ... ok that() len_lower_than_or_equals(number) raise AssertionError ... ok that(iterable).the_attribute('name').equals('value') ... ok that(iterable, within_range=(1, 2)).the_attribute('name').equals('value') ... ok that(iterable).every_one_is('value') ... ok that(iterable).in_each('').equals('value') ... ok that(callable, with_args=[arg1], and_kwargs={'arg2': 'value'}).raises(SomeException) ... ok that('String\n with BREAKLINE').looks_like('string with breakline') ... ok that(callable(RuntimeError)).raises(TypeError) ... ok that(callable, with_args=['foo']).raises(FooError) ... ok that(callable).doesnt_raise(FooError) and does_not_raise ... ok that('foobar').contains('foo') ... ok that('foobar').does_not_contain('123'), .doesnt_contain ... ok that('foobar').contains(None) ... ok that(None).contains('bungalow') ... ok that(some_iterable).is_empty and that(something).are_empty ... ok that(something_not_iterable).is_empty and that(something_not_iterable).are_empty raises ... ok that(something_iterable).matches(another_iterable) ... ok within(five=miliseconds) will pass ... ok within(five=miliseconds) will fail ... ok tests.test_old_api.test_word_to_number ... ok tests.test_old_api.test_word_to_number_fail ... ok testing microseconds convertion ... ok testing miliseconds convertion ... ok testing seconds convertion ... ok testing minutes convertion ... ok within(five=miliseconds) gives utc parameter ... ok that.is_a_matcher should absorb callables to be used as matcher ... ok sure.with_context() accepts a list of callbacks for setup ... ok sure.with_context() runs teardown before the function itself ... ok @scenario aliases @that_with_context for setup and teardown ... ok the actions always returns the context ... ok the actions should be able to declare the variables they provide ... ok it fails when an action doesn't fulfill its agreements ... ok it fails when an action depends on some attribute that is not provided by any other previous action ... ok it fails when an action depends on some attribute that is being provided by other actions ... ok that(dict(name='foobar')).contains('name') ... ok that(['foobar', '123']).contains('foobar') ... ok that(set(['foobar', '123']).contains('foobar') ... ok that(('foobar', '123')).contains('foobar') ... ok VariablesBag() provides a meaningful error when attr does not exist ... ok the actions should be able to declare the variables they provide ... ok that() deep_equals(dict) succeeding on level 1 ... ok that() deep_equals(dict) failing on level 1 ... ok that(list) deep_equals(list) succeeding on level 1 ... ok that(list) deep_equals(list) failing on level 1 ... ok that(list) deep_equals(list) failing by length (len(X) > len(Y)) ... ok that(list) deep_equals(list) failing by length (len(Y) > len(X)) ... ok that(X) deep_equals(Y) fails when Y is missing a key that X has ... ok that(X) deep_equals(Y) fails with basic vc complex type ... ok that(X) deep_equals(Y) fails with complex vc basic type ... ok that(tuple) deep_equals(tuple) succeeding on level 1 ... ok that(tuple) deep_equals(tuple) failing on level 1 ... ok that(tuple) deep_equals(tuple) failing by length (len(X) > len(Y)) ... ok that(tuple) deep_equals(tuple) failing by length (len(Y) > len(X)) ... ok that() deep_equals(dict) falling back to generic comparator ... ok that() deep_equals(dict) with generic comparator failing ... ok that() deep_equals(dict) with generic comparator failing ... ok that() deep_equals(dict) succeeding on level 2 ... ok that() deep_equals(dict) succeeding on level 2 ... ok that() deep_equals(dict) failing on level 2 ... ok that() deep_equals(dict) failing on level 3 ... ok that() deep_equals(dict) failing on level 3 when missing a key ... ok that() deep_equals(dict) failing on level 3 when has an extra key ... ok that() deep_equals(dict) failing on level 3 when has an extra key ... ok that(list) deep_equals(list) failing by length (len(X) > len(Y)) ... ok that(list) deep_equals(list) failing by length (len(Y) > len(X)) ... ok @sure.work_in_progress should set an internal flag into `sure` ... ok that() equals(string) when it's supposed to fail ... ok that(callable).raises('message') should compare the message ... ok tests.test_old_api.test_deep_equals_weird ... ok safe_repr should display a simple list ... ok safe_repr should return a sorted repr ... ok dicts nested inside values should also get sorted ... ok dicts with unicode should work properly ... ok Name Stmts Miss Branch BrPart Cover ------------------------------------------------------ sure/__init__.py 628 57 178 16 89% sure/cli.py 9 6 0 0 33% sure/compat.py 71 22 30 4 68% sure/core.py 161 6 54 4 95% sure/deprecated.py 4 0 0 0 100% sure/magic.py 22 2 6 2 79% sure/old.py 263 21 96 9 89% sure/registry.py 2 0 0 0 100% sure/stubs.py 6 5 4 0 10% sure/terminal.py 29 10 16 5 58% sure/version.py 1 0 0 0 100% ------------------------------------------------------ TOTAL 1196 129 384 40 87% ---------------------------------------------------------------------- Ran 140 tests OK 0.09 5000 6998.22 5000 0.11 5000 py$(PYV): OK congratulations :)