Python Mock.assert_called_once方法代码示例

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
def test_listener_removal_on_emit():
    """Test that a listener removed during an emit is called inside the current
    emit cycle.
    """

    call_me = Mock()
    ee = BaseEventEmitter()

    def should_remove():
        ee.remove_listener('remove', call_me)

    ee.on('remove', should_remove)
    ee.on('remove', call_me)

    ee.emit('remove')

    call_me.assert_called_once()

    call_me.reset_mock()

    # Also test with the listeners added in the opposite order
    ee = BaseEventEmitter()
    ee.on('remove', call_me)
    ee.on('remove', should_remove)

    ee.emit('remove')

    call_me.assert_called_once()

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test_update(self, include_prerelease, is_started, start_interval, enabled, interval, start_called, stop_called):
        checker = NewVersionChecker(False)

        def start_side_effect(i):
            checker.interval = i

        start_mock = Mock(side_effect=start_side_effect)
        stop_mock = Mock()
        is_started_mock = Mock(return_value=is_started)

        checker.interval = start_interval
        checker.start = start_mock
        checker.stop = stop_mock
        checker.is_started = is_started_mock

        checker.update(include_prerelease, enabled, interval)

        self.assertEqual(checker.interval, interval)
        self.assertEqual(checker.include_prereleases, include_prerelease)
        if start_called:
            start_mock.assert_called_once_with(interval)
        else:
            start_mock.assert_not_called()

        if stop_called:
            stop_mock.assert_called_once()
        else:
            stop_mock.assert_not_called()

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test_actualizar(self):
        '''
        Prueba el metodo actualizar.
        '''
        # preparo datos
        self.actualizador.version_actual = 'a'
        self.actualizador.version_disponible = 'b'

        mock_descargar = Mock()
        mock_descargar.return_value = [
            {
                'nombre': 'foo',
                'descripcion': 'bar'
            },
            {
                'nombre': 'bar',
                'descripcion': 'bar'
            },
        ]
        self.actualizador.descargar_actualizacion = mock_descargar

        mock_aplicar = Mock()
        mock_aplicar.return_value = True
        self.actualizador.aplicar_actualizacion = mock_aplicar
        # llamo metodo a probar
        self.actualizador.actualizar()
        # verifico que todo este bien
        mock_descargar.assert_called_once()
        mock_aplicar.assert_called()
        assert mock_aplicar.call_count == 2
        assert self.actualizador.version_actual == 'b'

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
def test_facet_configuration_with_existing_facet_callable(isolated_app):
    facet_mock = Mock()
    facet_mock.return_value = {
        'aggs': {
            'jessica-jones': {
                'terms': {
                    'field': 'defenders',
                    'size': 20,
                },
            },
        },
    }
    config = {
        'RECORDS_REST_FACETS': {
            'defenders': facet_mock
        },
    }
    expected = {
        'aggs': {
            'jessica-jones': {
                'terms': {
                    'field': 'defenders',
                    'size': 20
                }
            }
        }
    }
    with isolated_app.test_request_context('?facet_name=defenders'):
        with patch.dict(isolated_app.config, config):
            result = get_facet_configuration('records-hep')
            facet_mock.assert_called_once()
            assert expected == result

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
def test_ensure_supervisor_started(tmpdir, monkeypatch):
    m = Mock()
    monkeypatch.setattr(subprocess, "check_call", m)
    tmpdir.join("supervisord.pid").write("123123")
    supconfig = tmpdir.join("etc", "supervisord.conf")
    ensure_supervisor_started(tmpdir, supconfig)
    m.assert_called_once()

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
def test_devpictl(tmpdir, monkeypatch):
    m = Mock()
    monkeypatch.setattr(subprocess, "call", m)
    tmpdir.join("supervisord.pid").write(os.getpid())
    tmpdir.ensure("etc", "supervisord.conf")
    devpictl(str(tmpdir.join("bin", "devpi-ctl")))
    m.assert_called_once()

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test_handler_passed_to_gio(self, monkeypatch):
        """Test if handler is correctly passed to Gio"""

        monkeypatch.setattr(
            Gio.DBusConnection, 'new_for_address_sync',
            Mock(return_value=Gio.DBusConnection()))

        signal_subscribe_mock = Mock()
        monkeypatch.setattr(
            Gio.DBusConnection, 'signal_subscribe',
            signal_subscribe_mock)

        conn = Connection()
        conn.connect_dbus()
        test_cb = lambda: None
        conn.signal_subscribe(test_cb)

        # test that Gio's signal_subscribe method is called once
        # and passed the callback as-is
        signal_subscribe_mock.assert_called_once()

        # pylint does not recognize Mock.call_args as sequence and won't
        # allow us to unpack it. Disabling the warning because we know what
        # we're doing here

        # pylint: disable=unpacking-non-sequence
        args, _ = signal_subscribe_mock.call_args
        assert args[6] == test_cb

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
 def test_transmit_delete_item(self):
     queue_item = self.get_queue_item()
     find_one = Mock(return_value={'item_id': '1', 'state': 'killed'})
     get_subscriber_reference = Mock(return_value={
         'item_id': '1',
         'subscriber_id': 'foo bar',
         'reference_id': 'foo',
         'extra': {
             'data': {
                 'revision': 'test'
             }
         }
     })
     insert_update_reference = Mock()
     mocked_service = MagicMock()
     mocked_service.return_value = MockedResourceService(
         find_one=find_one,
         get_subscriber_reference=get_subscriber_reference,
         insert_update_reference=insert_update_reference
     )
     with patch('aap.publish.transmitters.http_push_apple_news.get_resource_service', mocked_service):
         with HTTMock(self.delete_item_response):
             self.http_push._push_item(queue_item)
             find_one.assert_called_once()
             find_one.assert_called_with(req=None,
                                         item_id=queue_item.get('item_id'),
                                         _current_version=queue_item.get('item_version'))
             get_subscriber_reference.assert_called_once()
             get_subscriber_reference.assert_called_with('1', 'foo bar')

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test__del__1(self):
        self.ftp.connected = Mock(return_value=True)
        m_disconnect = Mock()
        self.ftp.disconnect = m_disconnect

        del(self.ftp)

        m_disconnect.assert_called_once()

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

        self.patient._fetch = fetch_mock

        self.patient._flip_switch('MyService', 'ServiceType', 'action')

        fetch_mock.assert_called_once()
        fetch_mock.assert_called_with('http://host:6080/arcgis/admin/services/MyService.ServiceType/action')

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

        self.patient._flip_switch = flip_switch_mock

        self.patient.turn_off('MyService', 'ServiceType')

        flip_switch_mock.assert_called_once()
        flip_switch_mock.assert_called_with('MyService', 'ServiceType', 'stop')

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test_areyousure_no(self):
        yes = Mock()
        no = Mock()

        yes_func, no_func = self.sut.areyousure(yes, no)
        no_func()

        no.assert_called_once()
        self.widget.escape.assert_called_once()
        yes.assert_not_called()

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
 def test_signal_sent(self):
     handler = Mock()
     form_submited.connect(handler)
     self.post(self.ok_data, expect_code=200)
     handler.assert_called_once()
     args, kwargs = handler.call_args
     self.assertIn('message', kwargs)
     self.assertIsInstance(kwargs['message'], Message)
     self.assertIn('request', kwargs)
     self.assertIsInstance(kwargs['request'], HttpRequest)

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test_should_update_ruleset(self):
        out = StringIO()
        err = StringIO()
        update_mock = Mock()
        with patch('rules.models.Ruleset.update', update_mock):
            call_command('refreshprobes', '-u', 'probe1', stdout=out, stderr=err)

        update_mock.assert_called_once()
        self.assertIn('Update complete', out.getvalue())
        self.assertEqual('', err.getvalue())

# 需要导入模块: from mock import Mock [as 别名]
# 或者: from mock.Mock import assert_called_once [as 别名]
    def test_should_build_rules(self):
        out = StringIO()
        err = StringIO()
        build_mock = Mock()
        with patch('probes.models.Probes.build_rules', build_mock):
            call_command('refreshprobes', '-b', 'probe1', stdout=out, stderr=err)

        build_mock.assert_called_once()
        self.assertIn('Build complete', out.getvalue())
        self.assertEqual('', err.getvalue())