__version__ = "$Revision: 9168 $"

from utext import DefaultSuite, TestCase, test
from utext.asserts import *

__all__ = ["AssertTest", "AllTests"]


class _DummyObject(object):

    def __init__(self, value="x"):
        self._value = value

    def __cmp__(self, other):
        return cmp(self._value, other._value)


class AssertTest(TestCase):

    def _assert_assertion_raised(self, func, *args):
        assert_raises(AssertionError, func, *args)

    def _test_assertion_fails(self, cb):
        try:
            cb()
        except AssertionError, exc:
            return exc
        else:
            raise AssertionError("AssertionError not raised")

    def _test_assert_raises_fails(self, exc_cls):
        def cb():
            assert_raises(exc_cls, lambda: None)
        return self._test_assertion_fails(cb)

    @test
    def fail(self):
        assert_raises(AssertionError, fail)

    @test
    def fail__with_message(self):
        MSG = "foo"
        def cb():
            fail(MSG)
        exc = self._test_assertion_fails(cb)
        assert_equals(MSG, str(exc))

    @test
    def assert_not_equals__success(self):
        assert_not_equals("abc", "def")

    @test
    def assert_not_equals__fail(self):
        self._assert_assertion_raised(assert_not_equals, "abc", "abc")

    @test
    def assert_same__same__success(self):
        x = _DummyObject()
        assert_same(x, x)

    @test
    def assert_same__not_same__fail(self):
        x = _DummyObject("x")
        y = _DummyObject("y")
        self._assert_assertion_raised(assert_same, x, y)

    @test
    def assert_same__equal_but_not_same__fail(self):
        x = _DummyObject("x")
        y = _DummyObject("x")
        self._assert_assertion_raised(assert_same, x, y)

    @test
    def assert_not_same__not_same__success(self):
        x = _DummyObject()
        y = _DummyObject()
        assert_not_same(x, y)

    @test
    def assert_not_same__same__fail(self):
        x = _DummyObject("x")
        self._assert_assertion_raised(assert_not_same, x, x)

    @test
    def assert_raises__success(self):
        def raise_key_error():
            raise KeyError()
        assert_raises(KeyError, raise_key_error)

    @test
    def assert_raises__success_with_assertion_error(self):
        def raise_assertion_error():
            raise AssertionError()
        assert_raises(AssertionError, raise_assertion_error)

    @test
    def assert_raises__fail(self):
        self._test_assert_raises_fails(KeyError)

    @test
    def assert_raises__fail_with_assertion_error(self):
        self._test_assert_raises_fails(AssertionError)

    @test
    def assert_raises__args(self):
        def raise_key_error(arg1, arg2):
            raise KeyError()
        assert_raises(KeyError, raise_key_error, "foo", "bar")

    @test
    def assert_raises__kwargs(self):
        def raise_key_error(arg1, arg2):
            raise KeyError()
        assert_raises(KeyError, raise_key_error, arg2="foo", arg1="bar")

    @test
    def assert_raises__fail_error_message(self):
        exc = self._test_assert_raises_fails(KeyError)
        assert_equals("KeyError not raised", str(exc))

    @test
    def assert_none__success(self):
        assert_none(None)

    @test
    def assert_none__fail(self):
        self._assert_assertion_raised(assert_none, "foo")

    @test
    def assert_not_none__success(self):
        assert_not_none("foo")

    @test
    def assert_not_none__fail(self):
        self._assert_assertion_raised(assert_not_none, None)

    @test
    def assert_contains__exact_match__success(self):
        assert_contains("foo", "foo")

    @test
    def assert_contains__contained_in__success(self):
        assert_contains("foo", "abcfooxyz")

    @test
    def assert_contains__no_match__fail(self):
        self._assert_assertion_raised(assert_contains, "foo", "bar")


class AllTests(DefaultSuite):

    tests = [AssertTest]