Python Mock.side_effect方法代码示例

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_side_effect(self):
        mock = Mock()

        def effect(*args, **kwargs):
            raise SystemError('kablooie')

        mock.side_effect = effect
        self.assertRaises(SystemError, mock, 1, 2, fish=3)
        mock.assert_called_with(1, 2, fish=3)

        results = [1, 2, 3]
        def effect():
            return results.pop()
        mock.side_effect = effect

        self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
                          "side effect not used correctly")

        mock = Mock(side_effect=sentinel.SideEffect)
        self.assertEqual(mock.side_effect, sentinel.SideEffect,
                          "side effect in constructor not used")

        def side_effect():
            return DEFAULT
        mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
        self.assertEqual(mock(), sentinel.RETURN)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_install_pending_order(self):
        """Installation order of pending requests are respected"""
        done_callback = Mock()
        done_callback.side_effect = self.done_callback
        done_callback0 = Mock()
        done_callback0.side_effect = self.done_callback
        ordered_progress_callback = Mock()
        progress_callback = Mock()
        progress_callback.side_effect = ordered_progress_callback
        progress_callback0 = Mock()
        progress_callback0.side_effect = ordered_progress_callback
        self.handler.install_bucket(["testpackage"], progress_callback, done_callback)
        self.handler.install_bucket(["testpackage0"], progress_callback0, done_callback0)
        self.wait_for_callback(done_callback)
        self.wait_for_callback(done_callback0)

        self.assertEqual(self.done_callback.call_args_list,
                         [call(RequirementsHandler.RequirementsResult(bucket=['testpackage'], error=None)),
                          call(RequirementsHandler.RequirementsResult(bucket=['testpackage0'], error=None))])
        # we will get progress with 0, 1 (first bucket), 0, 1 (second bucket). So 4 progress signal status change
        current_status = RequirementsHandler.STATUS_DOWNLOADING
        current_status_change_count = 1
        calls = ordered_progress_callback.call_args_list
        for current_call in calls[1:]:
            if current_call[0][0]['step'] != current_status:
                current_status = current_call[0][0]['step']
                current_status_change_count += 1
        self.assertEqual(current_status_change_count, 4)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_mock_method(self):
        mock = Mock(side_effect=KeyError('foo'))
        values = {'a': 1, 'b': 2, 'c': 3}

        def side_effect(arg):
            return values[arg]

        mock.side_effect = side_effect
        print((mock('a'), mock('b'), mock('c')))

        mock.side_effect = [5, 4, 3, 2, 1]
        print((mock(), mock(), mock(), mock(), mock()))

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_reset_mock(self):
        parent = Mock()
        spec = ["something"]
        mock = Mock(name="child", parent=parent, spec=spec)
        mock(sentinel.Something, something=sentinel.SomethingElse)
        something = mock.something
        mock.something()
        mock.side_effect = sentinel.SideEffect
        return_value = mock.return_value
        return_value()

        mock.reset_mock()

        self.assertEqual(mock._mock_name, "child", "name incorrectly reset")
        self.assertEqual(mock._mock_parent, parent, "parent incorrectly reset")
        self.assertEqual(mock._mock_methods, spec, "methods incorrectly reset")

        self.assertFalse(mock.called, "called not reset")
        self.assertEqual(mock.call_count, 0, "call_count not reset")
        self.assertEqual(mock.call_args, None, "call_args not reset")
        self.assertEqual(mock.call_args_list, [], "call_args_list not reset")
        self.assertEqual(
            mock.method_calls, [], "method_calls not initialised correctly: %r != %r" % (mock.method_calls, [])
        )
        self.assertEqual(mock.mock_calls, [])

        self.assertEqual(mock.side_effect, sentinel.SideEffect, "side_effect incorrectly reset")
        self.assertEqual(mock.return_value, return_value, "return_value incorrectly reset")
        self.assertFalse(return_value.called, "return value mock not reset")
        self.assertEqual(mock._mock_children, {"something": something}, "children reset incorrectly")
        self.assertEqual(mock.something, something, "children incorrectly cleared")
        self.assertFalse(mock.something.called, "child not reset")

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
 def test_reset_mock(self):
     parent = Mock()
     spec = ['something']
     mock = Mock(name='child', parent=parent, spec=spec)
     mock(sentinel.Something, something=sentinel.SomethingElse)
     something = mock.something
     mock.something()
     mock.side_effect = sentinel.SideEffect
     return_value = mock.return_value
     return_value()
     mock.reset_mock()
     self.assertEqual(mock._mock_name, 'child', 'name incorrectly reset')
     self.assertEqual(mock._mock_parent, parent, 'parent incorrectly reset')
     self.assertEqual(mock._mock_methods, spec, 'methods incorrectly reset')
     self.assertFalse(mock.called, 'called not reset')
     self.assertEqual(mock.call_count, 0, 'call_count not reset')
     self.assertEqual(mock.call_args, None, 'call_args not reset')
     self.assertEqual(mock.call_args_list, [], 'call_args_list not reset')
     self.assertEqual(mock.method_calls, [], 'method_calls not initialised correctly: %r != %r' % (mock.method_calls, []))
     self.assertEqual(mock.mock_calls, [])
     self.assertEqual(mock.side_effect, sentinel.SideEffect, 'side_effect incorrectly reset')
     self.assertEqual(mock.return_value, return_value, 'return_value incorrectly reset')
     self.assertFalse(return_value.called, 'return value mock not reset')
     self.assertEqual(mock._mock_children, {'something': something}, 'children reset incorrectly')
     self.assertEqual(mock.something, something, 'children incorrectly cleared')
     self.assertFalse(mock.something.called, 'child not reset')

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
def test_depaginator_getitem_works():
    fetcher = Mock()
    fetcher.side_effect = [result]
    paginator = AutoDepaginator(fetcher)
    x = paginator[0]
    assert 'somekey' in x
    assert x['somekey'] == 'somecontent'
    assert paginator[1]['somekey'] == 'another content'

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
 def test_side_effect_setting_iterator(self):
     mock = Mock()
     mock.side_effect = iter([1, 2, 3])
     self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
     self.assertRaises(StopIteration, mock)
     side_effect = mock.side_effect
     self.assertIsInstance(side_effect, type(iter([])))
     mock.side_effect = ['a', 'b', 'c']
     self.assertEqual([mock(), mock(), mock()], ['a', 'b', 'c'])
     self.assertRaises(StopIteration, mock)
     side_effect = mock.side_effect
     self.assertIsInstance(side_effect, type(iter([])))
     this_iter = Iter()
     mock.side_effect = this_iter
     self.assertEqual([mock(), mock(), mock(), mock()], ['this', 'is', 'an', 'iter'])
     self.assertRaises(StopIteration, mock)
     self.assertIs(mock.side_effect, this_iter)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
def test_depaginator_returns_results():
    fetcher = Mock()
    fetcher.side_effect = [result]
    paginator = iter(AutoDepaginator(fetcher))
    r0 = next(paginator)
    fetcher.assert_called_with()
    r1 = next(paginator)
    assert r0 == result['results'][0]
    assert r1 == result['results'][1]

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_side_effect_setting_iterator(self):
        mock = Mock()
        mock.side_effect = iter([1, 2, 3])
        self.assertEqual([mock(), mock(), mock()], [1, 2, 3])
        self.assertRaises(StopIteration, mock)
        side_effect = mock.side_effect
        self.assertIsInstance(side_effect, type(iter([])))

        mock.side_effect = ["a", "b", "c"]
        self.assertEqual([mock(), mock(), mock()], ["a", "b", "c"])
        self.assertRaises(StopIteration, mock)
        side_effect = mock.side_effect
        self.assertIsInstance(side_effect, type(iter([])))

        this_iter = Iter()
        mock.side_effect = this_iter
        self.assertEqual([mock(), mock(), mock(), mock()], ["this", "is", "an", "iter"])
        self.assertRaises(StopIteration, mock)
        self.assertIs(mock.side_effect, this_iter)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
def test_project_init_errors_2(project_file_1_fixture):
    op = Mock()
    op.side_effect = raiser(PermissionError)
    op.return_value = project_file_1_fixture
    with patch('srmlf.project.open', op, create=True):
        isfile = Mock()
        isfile.return_value = True
        with patch('os.path.isfile', isfile, create=True):
            with pytest.raises(project.ProjectFileUnreadableException):
                project.Project('test')

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_coercer_value_errors_are_ignored(self):
        s = MagicMock()
        s.cell_value.return_value = 'blah'

        c = Mock()
        c.side_effect = ValueError()

        self.assertEqual(safe_cell_str_value(s, 99, 99, c), 'blah')
        self.assertEqual(s.cell_value.call_count, 1)
        self.assertEqual(c.call_count, 1)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
def test_depaginator_works_with_non_paginating_results_and_warns():
    fetcher = Mock()
    fetcher.side_effect = [result['results']]
    fetcher.__name__ = 'test_fetcher'
    with patch('drf_depaginator.logger') as paginator_logger:
        paginator = iter(AutoDepaginator(fetcher))
        response = list(paginator)
        assert len(response) == 2
        assert response == result['results']
        assert any(str(call).startswith('call.warning') for call in paginator_logger.mock_calls), \
            'AutoDepaginator did not log warning about non-compliant API return'

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
 def test_alignstack_calls_filterfn(self):
     filterfn = Mock()
     filterfn.side_effect = lambda x: x
     im = test_image()
     up = _up(im)
     down = _down(im)
     alignstack([im, up, down],
                shiftfn=RegisterTranslation(),
                filterfn=filterfn)
     for i, t in enumerate([im, up, down]):
         self.assertIs(filterfn.call_args_list[i][0][0], t)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
    def test_install_pending_callback_not_mixed(self):
        """Callbacks are separated on pending requests"""
        done_callback = Mock()
        done_callback.side_effect = self.done_callback
        done_callback0 = Mock()
        done_callback0.side_effect = self.done_callback
        global_progress_callback = Mock()
        progress_callback = Mock()
        progress_callback.side_effect = global_progress_callback
        progress_callback0 = Mock()
        progress_callback0.side_effect = global_progress_callback
        self.handler.install_bucket(["testpackage"], progress_callback, done_callback)
        self.handler.install_bucket(["testpackage0"], progress_callback0, done_callback0)
        self.wait_for_callback(done_callback)
        self.wait_for_callback(done_callback0)

        self.assertTrue(progress_callback.call_count < global_progress_callback.call_count)
        self.assertTrue(progress_callback0.call_count < global_progress_callback.call_count)
        self.assertTrue(done_callback.call_count < self.done_callback.call_count)
        self.assertTrue(done_callback0.call_count < self.done_callback.call_count)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import side_effect [as 别名]
def test_depaginator_stops_iteration():
    fetcher = Mock()
    fetcher.side_effect = [result, {'next': None, 'count': 3, 'results': [{'somekey': 'yet another content'}]}]
    paginator = iter(AutoDepaginator(fetcher))
    next(paginator)
    next(paginator)
    fetcher.assert_called_once_with()
    next(paginator)
    fetcher.assert_called_with(limit=2, offset=2)
    with pytest.raises(StopIteration):
        next(paginator)