def test_that_checking_each_matches():
    "that(iterable).in_each('').equals('value')"

    class animal(object):
        def __init__(self, kind):
            self.attributes = {"class": "mammal", "kind": kind}

    animals = [animal("dog"), animal("cat"), animal("cow"), animal("cow"), animal("cow")]

    assert animals[0].attributes["kind"] != "cow"
    assert animals[1].attributes["kind"] != "cow"

    assert animals[2].attributes["kind"] == "cow"
    assert animals[3].attributes["kind"] == "cow"
    assert animals[4].attributes["kind"] == "cow"

    assert animals[0].attributes["class"] == "mammal"
    assert animals[1].attributes["class"] == "mammal"
    assert animals[2].attributes["class"] == "mammal"
    assert animals[3].attributes["class"] == "mammal"
    assert animals[4].attributes["class"] == "mammal"

    assert that(animals).in_each("attributes['class']").matches("mammal")
    assert that(animals).in_each("attributes['class']").matches(["mammal", "mammal", "mammal", "mammal", "mammal"])

    assert that(animals).in_each("attributes['kind']").matches(["dog", "cat", "cow", "cow", "cow"])

    try:
        assert that(animals).in_each("attributes['kind']").matches(["dog"])
        assert False, "should not reach here"
    except AssertionError as e:
        assert that(text_type(e)).equals(
            "%r has 5 items, but the matching list has 1: %r" % (["dog", "cat", "cow", "cow", "cow"], ["dog"])
        )

def test_that_something_iterable_matches_another():
    "that(something_iterable).matches(another_iterable)"

    KlassOne = type('KlassOne', (object,), {})
    KlassTwo = type('KlassTwo', (object,), {})
    one = [
        ("/1", KlassOne),
        ("/2", KlassTwo),
    ]

    two = [
        ("/1", KlassOne),
        ("/2", KlassTwo),
    ]

    assert that(one).matches(two)
    assert that(one).equals(two)

    def fail_1():
        assert that(range(1)).matches(xrange(2))

    class Fail2(object):
        def __init__(self):
            assert that(xrange(1)).matches(range(2))

    class Fail3(object):
        def __call__(self):
            assert that(xrange(1)).matches(range(2))

    assert that(fail_1).raises('X is a list and Y is a xrange instead')
    assert that(Fail2).raises('X is a xrange and Y is a list instead')
    assert that(Fail3()).raises('X is a xrange and Y is a list instead')

def test_that_something_iterable_matches_another():
    "that(something_iterable).matches(another_iterable)"

    # types must be unicode in py3, bute bytestrings in py2
    KlassOne = type("KlassOne" if PY3 else b"KlassOne", (object,), {})
    KlassTwo = type("KlassTwo" if PY3 else b"KlassTwo", (object,), {})
    one = [("/1", KlassOne), ("/2", KlassTwo)]

    two = [("/1", KlassOne), ("/2", KlassTwo)]

    assert that(one).matches(two)
    assert that(one).equals(two)

    def fail_1():
        assert that([1]).matches(xrange(2))

    class Fail2(object):
        def __init__(self):
            assert that(xrange(1)).matches([2])

    class Fail3(object):
        def __call__(self):
            assert that(xrange(1)).matches([2])

    xrange_name = xrange.__name__
    assert that(fail_1).raises("X is a list and Y is a {0} instead".format(xrange_name))
    assert that(Fail2).raises("X is a {0} and Y is a list instead".format(xrange_name))
    assert that(Fail3()).raises("X is a {0} and Y is a list instead".format(xrange_name))

def test_that_len_greater_than_should_raise_assertion_error():
    "that() len_greater_than(number) raise AssertionError"

    lst = list(range(1000))
    try:
        that(lst).len_greater_than(1000)
    except AssertionError as e:
        assert_equals(str(e), "the length of the list should be greater then %d, but is %d" % (1000, 1000))

def test_that_len_lower_than_or_equals_should_raise_assertion_error():
    "that() len_lower_than_or_equals(number) raise AssertionError"

    lst = list(range(1000))
    try:
        that(lst).len_lower_than_or_equals(100)
    except AssertionError as e:
        assert_equals(str(e), "the length of %r should be lower then or equals %d, but is %d" % (lst, 100, 1000))

def test_that_len_is():
    "that() len_is(number)"

    lst = range(1000)

    assert that(lst).len_is(1000)
    assert len(lst) == 1000
    assert that(lst).len_is(lst)

def test_that_is_a_matcher_should_absorb_callables_to_be_used_as_matcher():
    u"that.is_a_matcher should absorb callables to be used as matcher"
    @that.is_a_matcher
    def is_truthful(what):
        assert bool(what), '%s is so untrue' % (what)
        return 'foobar'

    assert that('friend').is_truthful()
    assert_equals(that('friend').is_truthful(), 'foobar')

def test_that_len_greater_than():
    "that() len_greater_than(number)"

    lst = range(1000)
    lst2 = range(100)

    assert that(lst).len_greater_than(100)
    assert len(lst) == 1000
    assert that(lst).len_greater_than(lst2)

def test_that_len_lower_than():
    "that() len_lower_than(number)"

    lst = list(range(100))
    lst2 = list(range(1000))

    assert that(lst).len_lower_than(101)
    assert len(lst) == 100
    assert that(lst).len_lower_than(lst2)

def test_get_argv_options_integration(context):
    u"Nose should parse sys.argv and figure out whether to run as integration"
    sys.argv = ['./manage.py', 'test', '--integration']
    runner = Nose()

    opts = runner.get_argv_options()
    assert that(opts['is_unit']).equals(False)
    assert that(opts['is_functional']).equals(False)
    assert that(opts['is_integration']).equals(True)

def test_get_argv_options_simple(context):
    u"Nose should parse sys.argv"
    sys.argv = ['./manage.py', 'test']
    runner = Nose()

    opts = runner.get_argv_options()
    assert that(opts['is_unit']).equals(False)
    assert that(opts['is_functional']).equals(False)
    assert that(opts['is_integration']).equals(False)

 def mock_get_paths_for(names, appending):
     k = expected_kinds.pop(0)
     assert that(names).is_a(list)
     assert that(appending).is_a(list)
     assert that(names).equals(['john', 'doe'])
     assert that(appending).equals(['tests', k])
     return [
         '/apps/john/tests/%s' % k,
         '/apps/doe/tests/%s' % k,
     ]

def test_that_is_a_matcher_should_absorb_callables_to_be_used_as_matcher():
    "that.is_a_matcher should absorb callables to be used as matcher"

    @that.is_a_matcher
    def is_truthful(what):
        assert bool(what), "%s is so untrue" % (what)
        return "foobar"

    assert that("friend").is_truthful()
    assert_equals(that("friend").is_truthful(), "foobar")

def test_that_len_greater_than_or_equals_should_raise_assertion_error():
    "that() len_greater_than_or_equals(number) raise AssertionError"

    lst = range(1000)
    try:
        that(lst).len_greater_than_or_equals(1001)
    except AssertionError, e:
        assert_equals(
            str(e),
            'the length of %r should be greater then or equals %d, but is %d' \
            % (lst, 1001, 1000))

def test_that_len_lower_than_or_equals():
    "that() len_lower_than_or_equals(number)"

    lst = list(range(1000))
    lst2 = list(range(1001))

    assert that(lst).len_lower_than_or_equals(1001)
    assert that(lst).len_lower_than_or_equals(1000)
    assert len(lst) == 1000
    assert that(lst).len_lower_than_or_equals(lst2)
    assert that(lst).len_lower_than_or_equals(lst)

def test_that_len_lower_than_should_raise_assertion_error():
    "that() len_lower_than(number) raise AssertionError"

    lst = range(1000)
    try:
        that(lst).len_lower_than(1000)
    except AssertionError, e:
        assert_equals(
            str(e),
            'the length of %r should be lower then %d, but is %d' % \
            (lst, 1000, 1000))

def test_that_at_key_equals():
    "that().at(object).equals(object)"

    class Class:
        name = "some class"

    Object = Class()
    dictionary = {"name": "John"}

    assert that(Class).at("name").equals("some class")
    assert that(Object).at("name").equals("some class")
    assert that(dictionary).at("name").equals("John")

def test_that_at_key_equals():
    "that().at(object).equals(object)"

    class Class:
        name = "some class"
    Object = Class()
    dictionary = {
        'name': 'John',
    }

    assert that(Class).at("name").equals('some class')
    assert that(Object).at("name").equals('some class')
    assert that(dictionary).at("name").equals('John')

def test_raises_with_string():
    "that(callable).raises('message') should compare the message"

    def it_fails():
        assert False, 'should fail with this exception'

    try:
        that(it_fails).raises('wrong msg')
        raise RuntimeError('should not reach here')
    except AssertionError as e:
        assert that(text_type(e)).contains('''EXPECTED:
wrong msg

GOT:
should fail with this exception''')

    def the_providers_are_working(Then):
        Then.the_context_has_variables()
        assert hasattr(Then, 'var1')
        assert hasattr(Then, 'foobar')
        assert hasattr(Then, '__sure_providers_of__')

        providers = Then.__sure_providers_of__
        action = Then.the_context_has_variables.__name__

        providers_of_var1 = [p.__name__ for p in providers['var1']]
        assert that(providers_of_var1).contains(action)

        providers_of_foobar = [p.__name__ for p in providers['foobar']]
        assert that(providers_of_foobar).contains(action)

        return True