from unittest import TestCase

from testfixtures.mock import Mock, MagicMock, patch, DEFAULT

from testfixtures import wrap, compare, log_capture, LogCapture


class TestWrap(TestCase):

    def test_wrapping(self):

        m = Mock()

        @wrap(m.before, m.after)
        def test_function(r):
            m.test()
            return 'something'

        compare(m.method_calls, [])
        compare(test_function(), 'something')
        compare(m.method_calls, [
            ('before', (), {}),
            ('test', (), {}),
            ('after', (), {})
            ])

    def test_wrapping_only_before(self):

        before = Mock()

        @wrap(before)
        def test_function():
            return 'something'

        self.assertFalse(before.called)
        compare(test_function(), 'something')
        compare(before.call_count, 1)

    def test_wrapping_wants_return(self):

        m = Mock()
        m.before.return_value = 'something'

        @wrap(m.before, m.after)
        def test_function(r):
            m.test(r)
            return 'r:'+r

        compare(m.method_calls, [])
        compare(test_function(), 'r:something')
        compare(m.method_calls, [
            ('before', (), {}),
            ('test', ('something', ), {}),
            ('after', (), {})
            ])

    def test_wrapping_wants_arguments(self):

        # This only works in python 2.5+, for
        # earlier versions, you'll have to come
        # up with your own `partial` class...
        from functools import partial

        m = Mock()

        @wrap(partial(m.before, 1, x=2), partial(m.after, 3, y=4))
        def test_function(r):
            m.test()
            return 'something'

        compare(m.method_calls, [])
        compare(test_function(), 'something')
        compare(m.method_calls, [
            ('before', (1, ), {'x': 2}),
            ('test', (), {}),
            ('after', (3, ), {'y': 4})
            ])

    def test_multiple_wrappers(self):

        m = Mock()

        @wrap(m.before2, m.after2)
        @wrap(m.before1, m.after1)
        def test_function():
            m.test_function()
            return 'something'

        compare(m.method_calls, [])
        compare(test_function(), 'something')
        compare(m.method_calls, [
            ('before1', (), {}),
            ('before2', (), {}),
            ('test_function', (), {}),
            ('after2', (), {}),
            ('after1', (), {}),
            ])

    def test_multiple_wrappers_wants_return(self):

        m = Mock()
        m.before1.return_value = 1
        m.before2.return_value = 2

        @wrap(m.before2, m.after2)
        @wrap(m.before1, m.after1)
        def test_function(r1, r2):
            m.test_function(r1, r2)
            return 'something'

        compare(m.method_calls, [])
        compare(test_function(), 'something')
        compare(m.method_calls, [
            ('before1', (), {}),
            ('before2', (), {}),
            ('test_function', (1, 2), {}),
            ('after2', (), {}),
            ('after1', (), {}),
            ])

    def test_multiple_wrappers_only_want_first_return(self):

        m = Mock()
        m.before1.return_value = 1

        @wrap(m.before2, m.after2)
        @wrap(m.before1, m.after1)
        def test_function(r1):
            m.test_function(r1)
            return 'something'

        compare(m.method_calls, [])
        compare(test_function(), 'something')
        compare(m.method_calls, [
            ('before1', (), {}),
            ('before2', (), {}),
            ('test_function', (1, ), {}),
            ('after2', (), {}),
            ('after1', (), {}),
            ])

    def test_wrap_method(self):

        m = Mock()

        class T:
            @wrap(m.before, m.after)
            def method(self):
                m.method()

        T().method()

        compare(m.method_calls, [
            ('before', (), {}),
            ('method', (), {}),
            ('after', (), {})
            ])

    def test_wrap_method_wants_return(self):

        m = Mock()
        m.before.return_value = 'return'

        class T:
            @wrap(m.before, m.after)
            def method(self, r):
                m.method(r)

        T().method()

        compare(m.method_calls, [
            ('before', (), {}),
            ('method', ('return', ), {}),
            ('after', (), {})
            ])

    def test_wrapping_different_functions(self):

        m = Mock()

        @wrap(m.before1, m.after1)
        def test_function1():
            m.something1()
            return 'something1'

        @wrap(m.before2, m.after2)
        def test_function2():
            m.something2()
            return 'something2'

        compare(m.method_calls, [])
        compare(test_function1(), 'something1')
        compare(m.method_calls, [
            ('before1', (), {}),
            ('something1', (), {}),
            ('after1', (), {})
            ])
        compare(test_function2(), 'something2')
        compare(m.method_calls, [
            ('before1', (), {}),
            ('something1', (), {}),
            ('after1', (), {}),
            ('before2', (), {}),
            ('something2', (), {}),
            ('after2', (), {})
            ])

    def test_wrapping_local_vars(self):

        m = Mock()

        @wrap(m.before, m.after)
        def test_function():
            something = 1
            m.test()
            return 'something'

        compare(m.method_calls, [])
        compare(test_function(), 'something')
        compare(m.method_calls, [
            ('before', (), {}),
            ('test', (), {}),
            ('after', (), {})
            ])

    def test_wrapping__name__(self):

        m = Mock()

        @wrap(m.before, m.after)
        def test_function():
            pass  # pragma: no cover

        compare(test_function.__name__, 'test_function')

    def test_our_wrap_dealing_with_mock_patch(self):

        @patch.multiple('tests.sample1', X=DEFAULT)
        @log_capture()
        def patched(log, X):
            from tests.sample1 import X as imported_X
            assert isinstance(log, LogCapture)
            assert isinstance(X, MagicMock)
            assert imported_X is X

        patched()

    def test_patch_with_dict(self):
        @patch('tests.sample1.X', {'x': 1})
        @log_capture()
        def patched(log):
            assert isinstance(log, LogCapture)
            from tests.sample1 import X
            assert X == {'x': 1}

        patched()
