def test_existing_cache_with_unrelated_data(self):
        section = Section('test-section')
        filedict = {}

        # Start with some unrelated cache values. Those are ignored as they are
        # never hit during a cache lookup.
        cache = {CustomTasksBear: {b'123456': [100, 101, 102]}}

        task_args = -1, -2, -3
        bear = CustomTasksBear(section, filedict, tasks=[task_args])

        with unittest.mock.patch.object(bear, 'analyze',
                                        wraps=bear.analyze) as mock:
            # First time we have a cache miss.
            results = self.execute_run({bear}, cache)
            mock.assert_called_once_with(*task_args)
            self.assertEqual(results, list(task_args))
            self.assertEqual(len(cache), 1)
            self.assertIn(CustomTasksBear, cache)

            cache_values = next(iter(cache.values()))
            self.assertEqual(len(cache_values), 2)
            # The unrelated data is left untouched.
            self.assertIn(b'123456', cache_values)
            self.assertEqual(cache_values[b'123456'], [100, 101, 102])

 def test_reject_ignores_rejected_price_lists(self, mock):
     self.price_list.reject(self.user)
     admin.reject(None, self.request_mock, SubmittedPriceList.objects.all())
     mock.assert_called_once_with(
         self.request_mock,
         messages.INFO,
         '0 price list(s) have been rejected.'
     )

 def test_retire_ignores_retired_price_lists(self, mock):
     admin.retire(None, self.request_mock,
                  SubmittedPriceList.objects.all())
     mock.assert_called_once_with(
         self.request_mock,
         messages.INFO,
         '0 price list(s) have been retired and removed from CALC.'
     )

    def test_with_sourcing(self, commands, config_stub, patch_editor):
        assert config_stub.val.content.javascript.enabled
        mock = patch_editor('c.content.javascript.enabled = False')

        commands.config_edit()

        mock.assert_called_once_with(unittest.mock.ANY)
        assert not config_stub.val.content.javascript.enabled

 def test_approve_ignores_approved_price_lists(self, mock):
     self.price_list.approve(self.user)
     admin.approve(None, self.request_mock,
                   SubmittedPriceList.objects.all())
     mock.assert_called_once_with(
         self.request_mock,
         messages.INFO,
         '0 price list(s) have been approved and added to CALC.'
     )

    def test_unicast_removes_for_true_result(self):
        mock = unittest.mock.Mock()
        mock.return_value = True
        obj = object()

        nh = TagDispatcher()
        nh.add_callback("tag", mock)
        nh.unicast("tag", obj)
        with self.assertRaises(KeyError):
            nh.unicast("tag", obj)

        mock.assert_called_once_with(obj)

    def test_cache(self):
        section = Section('test-section')
        filedict = {}

        cache = {}

        task_args = 10, 11, 12
        bear = CustomTasksBear(section, filedict, tasks=[task_args])

        with unittest.mock.patch.object(bear, 'analyze',
                                        wraps=bear.analyze) as mock:
            # First time we have a cache miss.
            results = self.execute_run({bear}, cache)
            mock.assert_called_once_with(*task_args)
            self.assertEqual(results, list(task_args))
            self.assertEqual(len(cache), 1)
            self.assertEqual(next(iter(cache.keys())), CustomTasksBear)
            self.assertEqual(len(next(iter(cache.values()))), 1)

            # All following times we have a cache hit (we don't modify the
            # cache in between).
            for i in range(3):
                mock.reset_mock()

                results = self.execute_run({bear}, cache)
                self.assertFalse(mock.called)
                self.assertEqual(results, list(task_args))
                self.assertEqual(len(cache), 1)
                self.assertIn(CustomTasksBear, cache)
                self.assertEqual(len(next(iter(cache.values()))), 1)

        task_args = 500, 11, 12
        bear = CustomTasksBear(section, filedict, tasks=[task_args])
        with unittest.mock.patch.object(bear, 'analyze',
                                        wraps=bear.analyze) as mock:
            # Invocation with different args should add another cache entry,
            # and invoke analyze() again because those weren't cached before.
            results = self.execute_run({bear}, cache)
            mock.assert_called_once_with(*task_args)
            self.assertEqual(results, list(task_args))
            self.assertEqual(len(cache), 1)
            self.assertIn(CustomTasksBear, cache)
            self.assertEqual(len(next(iter(cache.values()))), 2)

            mock.reset_mock()

            results = self.execute_run({bear}, cache)
            self.assertFalse(mock.called)
            self.assertEqual(results, list(task_args))
            self.assertEqual(len(cache), 1)
            self.assertIn(CustomTasksBear, cache)
            self.assertEqual(len(next(iter(cache.values()))), 2)

 def test_assert_called_once_with(self):
     mock = Mock()
     mock()
     mock.assert_called_once_with()
     mock()
     self.assertRaises(AssertionError, mock.assert_called_once_with)
     mock.reset_mock()
     self.assertRaises(AssertionError, mock.assert_called_once_with)
     mock('foo', 'bar', baz=2)
     mock.assert_called_once_with('foo', 'bar', baz=2)
     mock.reset_mock()
     mock('foo', 'bar', baz=2)
     self.assertRaises(AssertionError, lambda : mock.assert_called_once_with('bob', 'bar', baz=2))

    def test_connect_async(self):
        signal = AdHocSignal()

        mock = unittest.mock.MagicMock()
        fun = functools.partial(mock)

        signal.connect(fun, AdHocSignal.ASYNC_WITH_LOOP(None))
        signal.fire()

        mock.assert_not_called()

        run_coroutine(asyncio.sleep(0))

        mock.assert_called_once_with()

    def test_assert_called_once_with(self):
        mock = Mock()
        mock()

        # Will raise an exception if it fails
        mock.assert_called_once_with()

        mock()
        self.assertRaises(AssertionError, mock.assert_called_once_with)

        mock.reset_mock()
        self.assertRaises(AssertionError, mock.assert_called_once_with)

        mock("foo", "bar", baz=2)
        mock.assert_called_once_with("foo", "bar", baz=2)

        mock.reset_mock()
        mock("foo", "bar", baz=2)
        self.assertRaises(AssertionError, lambda: mock.assert_called_once_with("bob", "bar", baz=2))

    def test_no_cache(self):
        # Two runs without using the cache shall always run analyze() again.
        section = Section('test-section')
        filedict = {}

        task_args = 3, 4, 5
        bear = CustomTasksBear(section, filedict, tasks=[task_args])

        with unittest.mock.patch.object(bear, 'analyze',
                                        wraps=bear.analyze) as mock:
            # By default, omitting the cache parameter shall mean "no cache".
            results = self.execute_run({bear})
            mock.assert_called_once_with(*task_args)
            self.assertEqual(results, list(task_args))

            mock.reset_mock()

            results = self.execute_run({bear})
            mock.assert_called_once_with(*task_args)
            self.assertEqual(results, list(task_args))

            mock.reset_mock()

            # Passing None for cache shall disable it too explicitly.
            results = self.execute_run({bear}, None)
            mock.assert_called_once_with(*task_args)
            self.assertEqual(results, list(task_args))

    def test_assert_called_once_with_function_spec(self):
        def f(a, b, c, d=None):
            pass

        mock = Mock(spec=f)

        mock(1, b=2, c=3)
        mock.assert_called_once_with(1, 2, 3)
        mock.assert_called_once_with(a=1, b=2, c=3)
        self.assertRaises(AssertionError, mock.assert_called_once_with, 1, b=3, c=2)
        # Expected call doesn't match the spec's signature
        with self.assertRaises(AssertionError) as cm:
            mock.assert_called_once_with(e=8)
        self.assertIsInstance(cm.exception.__cause__, TypeError)
        # Mock called more than once => always fails
        mock(4, 5, 6)
        self.assertRaises(AssertionError, mock.assert_called_once_with, 1, 2, 3)
        self.assertRaises(AssertionError, mock.assert_called_once_with, 4, 5, 6)

 def test_no_source(self, commands, mocker):
     mock = mocker.patch('qutebrowser.config.configcommands.editor.'
                         'ExternalEditor._start_editor', autospec=True)
     commands.config_edit(no_source=True)
     mock.assert_called_once_with(unittest.mock.ANY)

    def test_perform_system_call(self, mock):
        cmd = 'universal'

        perform_system_command(cmd)

        mock.assert_called_once_with(cmd)

oo.func1 = MagicMock()

print(oo.func1("POKEMON !!").split() + 33)
print(oo.func2())

# Il est possible d'avoir un historique de ce qui a été utilisé avec les mocks.
print(oo.func1.mock_calls)

# Il est possible de vérifier si un appel a bien été fait :
oo.func1.assert_called_with("POKEMON !!")
# oo.func1.assert_called_with("Mario !") Provoquera une erreur.

# Patch
# permet de modifier le comportement de ce qui existe pour les tests.
from unittest.mock import patch
"""
with patch.object(builtins, "open", mock_open(read_data="wololo") as mock:
#with patch('__main__.open', mock_open(read_data='wololo'), create=True) as mock:
    with open('zefile') as h:
        result = h.read()

mock.assert_called_once_with('zefile')
assert result == 'wololo'
""" ### Ne fonctionne pas

# Il est possible de patcher un bout de module :
@patch('os.listdir')
def ah(mock):
    import os
    print(os.listdir('.'))
    # l'objet mock initial est aussi passé en param automatiquement