Example #1
0
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()
    def test_delete_security_rules(self):
        # Arrange
        self.network_security_group = MagicMock()
        network_client = MagicMock()
        private_ip_address = Mock()
        resource_group_name = "group_name"
        vm_name = "vm_name"
        security_group = NetworkSecurityGroup()
        security_group.name = "security_group_name"
        security_rule = Mock()
        security_rule.name = "rule_name"
        security_rule.destination_address_prefix = private_ip_address
        security_rules = [security_rule]
        security_group.security_rules = security_rules
        self.security_group_service.get_network_security_group = MagicMock()
        self.security_group_service.get_network_security_group.return_value = security_group
        self.network_service.get_private_ip = Mock(
            return_value=private_ip_address)

        contex_enter_mock = Mock()
        locker = Mock()
        locker.__enter__ = contex_enter_mock
        locker.__exit__ = Mock()

        # Act
        self.security_group_service.delete_security_rules(
            network_client, resource_group_name, vm_name, locker, Mock())

        # Verify
        network_client.security_rules.delete.assert_called_once_with(
            resource_group_name=resource_group_name,
            network_security_group_name=security_group.name,
            security_rule_name=security_rule.name)
        contex_enter_mock.assert_called_once()
    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()
    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'
    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
 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')
Example #7
0
def test_using_context_logger_works():
    instance = TestContextClass()
    context_func = Mock(return_value={'some': 'context'})
    wrapped = context_logger(context_func, instance.function, instance)

    wrapped()
    context_func.assert_called_once()
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
Example #9
0
 def test_auto_find_correlation(self, mock_start_async: mock.Mock):
     self.presenter.notify(PresNotification.AUTO_FIND_COR_CORRELATE)
     mock_start_async.assert_called_once()
     mock_first_call = mock_start_async.call_args[0]
     self.assertEqual(self.presenter.view, mock_first_call[0])
     self.assertEqual(self.presenter.model.auto_find_correlation, mock_first_call[1])
     self.view.set_correlate_buttons_enabled.assert_called_once_with(False)
Example #10
0
async def test_initial_plotting_call(
    mock_endpoint: EndpointConfig,
    monkeypatch: MonkeyPatch,
    trackers: List[Text],
    expected_trackers: List[Text],
    mock_file_importer: TrainingDataImporter,
):
    get_training_trackers = Mock(return_value=trackers)
    monkeypatch.setattr(
        interactive, "_get_training_trackers", asyncio.coroutine(get_training_trackers)
    )

    monkeypatch.setattr(interactive.utils, "is_limit_reached", lambda _, __: True)

    plot_trackers = Mock()
    monkeypatch.setattr(interactive, "_plot_trackers", asyncio.coroutine(plot_trackers))

    url = f"{mock_endpoint.url}/domain"
    with aioresponses() as mocked:
        mocked.get(url, payload={})

        await interactive.record_messages(mock_endpoint, mock_file_importer)

    get_training_trackers.assert_called_once()
    plot_trackers.assert_called_once_with(
        expected_trackers, interactive.DEFAULT_STORY_GRAPH_FILE, mock_endpoint
    )
Example #11
0
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()
Example #12
0
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()
Example #13
0
 def test_add_cleanup_with_known_layer(self):
     my_cleanup = Mock(spec=cleanup_func)
     context = Context(runner=Mock())
     with scoped_context_layer(context, layer="scenario"):
         context.add_cleanup(my_cleanup, layer="scenario")
         my_cleanup.assert_not_called()
     # CALLS-HERE: context._pop()
     my_cleanup.assert_called_once()
Example #14
0
    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()
Example #15
0
    def test_executing_custom_action(self, action_lookup_mock):
        """Used to test executing custom action when hook setting is set to true."""
        action_mock = Mock()
        action_lookup_mock.return_value = action_mock

        action_handler(self.trigger_event, self.configuration)

        action_mock.assert_called_once()
Example #16
0
    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()
Example #17
0
def test_blank_old_version():
    function = Mock()

    first = VersionUpgrade(old_version="<0.10.1", upgrade=function)

    with patch("kolibri.core.upgrade.get_upgrades", return_value=[first]):
        run_upgrades("", "1.1.2")
        function.assert_called_once()
Example #18
0
def test_initialize_telemetry_prints_info(monkeypatch: MonkeyPatch):
    # Mock actual training
    mock = Mock()
    monkeypatch.setattr(telemetry, "print_telemetry_reporting_info", mock)

    telemetry.initialize_telemetry()

    mock.assert_called_once()
Example #19
0
 def test_precheck(self, mock_globals, mock_isfunction):
     """Test precheck returns correct method"""
     mock_isfunction.return_value = True
     mock_precheck_method = Mock(name='mock precheck method')
     mock_precheck_method.return_value = True
     mock_globals.return_value = {"precheck_ami_id": mock_precheck_method}
     self.assertTrue(ef_version.precheck(self))
     mock_precheck_method.assert_called_once()
    def test_register_active_filter(self, filter_reg_mock: mock.Mock):
        reg_fun_mock = mock.Mock()
        filter_reg_mock.return_value = reg_fun_mock
        self.view.filterSelector.currentIndex.return_value = 0
        self.presenter.do_register_active_filter()

        reg_fun_mock.assert_called_once()
        filter_reg_mock.assert_called_once()
Example #21
0
    def testCallCallback(self):
        f = Mock()

        self.client.callbacks.test = f
        self.assertIn("test", self.client._callback_handler._callbacks)

        self.client.callbacks.test()

        f.assert_called_once()
Example #22
0
def test_not_filter_dev_version():
    unfiltered_mock = Mock()

    not_filtered = VersionUpgrade(old_version="<1.1.1",
                                  upgrade=unfiltered_mock)
    with patch("kolibri.core.upgrade.get_upgrades",
               return_value=[not_filtered]):
        run_upgrades("1.1.1.dev0", "1.1.2")
        unfiltered_mock.assert_called_once()
Example #23
0
    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')
 def test_cleanup_func_is_called_when_context_frame_is_popped(self):
     my_cleanup = Mock(spec=cleanup_func)
     context = Context(runner=Mock())
     with scoped_context_layer(context):  # CALLS-HERE: context._push()
         context.add_cleanup(my_cleanup)
         # -- ENSURE: Not called before context._pop()
         my_cleanup.assert_not_called()
     # CALLS-HERE: context._pop()
     my_cleanup.assert_called_once()
Example #25
0
class TestDirectoryWatch(fixture.SubManFixture):
    def setUp(self):
        super(TestDirectoryWatch, self).setUp()
        self.mock_cb1 = Mock(return_value=None)
        self.mock_cb2 = Mock(return_value=None)
        self.tmp_file1 = tempfile.NamedTemporaryFile(
            prefix="directory_watcher_test_")
        self.tmp_file2 = tempfile.NamedTemporaryFile(
            prefix="directory_watcher_test_")
        self.testpath1 = self.tmp_file1.name
        self.testpath2 = self.tmp_file2.name
        subprocess.call("touch %s" % self.testpath1, shell=True)
        subprocess.call("touch %s" % self.testpath2, shell=True)
        self.dw1 = file_monitor.DirectoryWatch(self.testpath1, [],
                                               is_glob=True)
        self.dw2 = file_monitor.DirectoryWatch(self.testpath2, [],
                                               is_glob=False)
        self.dw3 = file_monitor.DirectoryWatch(self.testpath2,
                                               [self.mock_cb1, self.mock_cb2],
                                               is_glob=False)

    def tearDown(self):
        self.tmp_file1.close()
        self.tmp_file2.close()

    def test_notify(self):
        self.dw3.notify()
        self.mock_cb1.assert_called_once()
        self.mock_cb2.assert_called_once()

    @patch("pyinotify.Event")
    def test_paths_match(self, mock_event):
        mock_event.path = self.testpath2
        mock_event.pathname = self.testpath2
        self.assertTrue(
            self.dw3.paths_match(mock_event.path, mock_event.pathname))
        mock_event.pathname = "%s.swp" % self.testpath2
        self.assertFalse(
            self.dw3.paths_match(mock_event.path, mock_event.pathname))
        mock_event.pathname = self.testpath2
        mock_event.path = self.testpath1
        self.assertTrue(
            self.dw3.paths_match(mock_event.path, mock_event.pathname))
        mock_event.pathname = self.testpath1
        self.assertFalse(
            self.dw3.paths_match(mock_event.path, mock_event.pathname))

    @patch("pyinotify.Event")
    def test_file_modified(self, mock_event):
        mock_event.mask = 1
        self.assertFalse(self.dw3.is_file_modified(mock_event.mask))
        mock_event.mask = self.dw3.IN_MODIFY
        self.assertTrue(self.dw3.is_file_modified(mock_event.mask))
        mock_event.mask = self.dw3.IN_DELETE
        self.assertTrue(self.dw3.is_file_modified(mock_event.mask))
        mock_event.mask = self.dw3.IN_MOVED_TO
        self.assertTrue(self.dw3.is_file_modified(mock_event.mask))
Example #26
0
    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')
Example #27
0
    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')
Example #28
0
    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')
Example #29
0
 def test_auth_called(self, mock_service_account: mock.Mock,
                      mock_gspread_oauth: mock.Mock) -> None:
     """It calls the gspread oauth and service_account methods."""
     mock_gspread_oauth.return_value = mock.MagicMock()
     mock_service_account.return_value = mock.MagicMock()
     connect("oauth")
     mock_gspread_oauth.assert_called_once()
     connect("service_account")
     mock_service_account.assert_called_once()
Example #30
0
    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())
Example #31
0
    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()
Example #32
0
    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())
Example #33
0
    def test_has_port_binding_extension_01(self):
        fake_extensions = [{'name': neutron_api.PORTBINDING_EXT}]
        client_list_ext_mock = Mock(
                                return_value={'extensions': fake_extensions})

        with patch.object(self.neutron_api.client, 'list_extensions',
                          client_list_ext_mock):
            result = self.neutron_api._has_port_binding_extension()
            client_list_ext_mock.assert_called_once()
            self.assertTrue(result)
Example #34
0
 def test_add_cleanup_with_known_deeper_layer3(self):
     my_cleanup = Mock(spec=cleanup_func)
     context = Context(runner=Mock())
     with scoped_context_layer(context, layer="testrun"):
         with scoped_context_layer(context, layer="feature"):
             with scoped_context_layer(context, layer="scenario"):
                 context.add_cleanup(my_cleanup, layer="feature")
             my_cleanup.assert_not_called()
         my_cleanup.assert_called_once()  # LEFT: layer="feature"
     my_cleanup.assert_called_once()
Example #35
0
 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)
    def test_when_subscribe_raise_exception_then_exception_is_handled(self):
        callback = Mock()
        callback.side_effect = Exception()
        handler = Mock()
        self.callback_collector._pubsub.set_exception_handler(handler)
        source_callback = self.callback_collector.new_source()
        self.callback_collector.subscribe(callback)

        source_callback()
        handler.assert_called_once()
Example #37
0
    def test_ensure_start(self):
        _execute_mock = Mock()
        _execute_mock.side_effect = [(True, None)]

        self.patient._execute = _execute_mock

        self.patient.ensure('start')

        _execute_mock.assert_called_once()
        _execute_mock.assert_called_with(self.patient.switch_url + 'start')
Example #38
0
    def test_from_image_member_deps(self, assembly_metadata_config: Mock):
        finder = BuildFinder(MagicMock())

        finder._get_builds = MagicMock(return_value=[
            {
                "id": 1,
                "build_id": 1,
                "name": "fake1",
                "nvr": "fake1-1.2.3-1.el8"
            },
            {
                "id": 2,
                "build_id": 2,
                "name": "fake2",
                "nvr": "fake2-1.2.3-1.el8"
            },
            {
                "id": 3,
                "build_id": 3,
                "name": "fake3",
                "nvr": "fake3-1.2.3-1.el8"
            },
        ])
        assembly_metadata_config.return_value = Model({
            "dependencies": {
                "rpms": [
                    {
                        "el8": "fake1-1.2.3-1.el8"
                    },
                    {
                        "el8": "fake2-1.2.3-1.el8"
                    },
                    {
                        "el8": "fake3-1.2.3-1.el8"
                    },
                    {
                        "el7": "fake2-1.2.3-1.el7"
                    },
                    {
                        "el7": "fake2-1.2.3-1.el7"
                    },
                ]
            }
        })
        image_meta = Model({
            "distgit_key": "fake-image",
        })
        actual = finder.from_image_member_deps(8, "art1", Model(), image_meta,
                                               {})
        self.assertEqual(
            [b["nvr"] for b in actual.values()],
            ["fake1-1.2.3-1.el8", "fake2-1.2.3-1.el8", "fake3-1.2.3-1.el8"])
        finder._get_builds.assert_called_once_with(
            ["fake1-1.2.3-1.el8", "fake2-1.2.3-1.el8", "fake3-1.2.3-1.el8"])
        assembly_metadata_config.assert_called_once()
Example #39
0
    def test_GIVEN_ioc_driver_with_engineering_correction_WHEN_update_mode_THEN_readback_updated_fired(self):
        mock_axis = create_mock_axis("mock", 0, 1)
        driver = IocDriver(Component("comp", PositionAndAngle(0, 0, 0)), ChangeAxis.POSITION, mock_axis, engineering_correction=self.mode_selection_correction)
        mock_axis.trigger_rbv_change()
        driver.set_observe_mode_change_on(self.mock_beamline)
        mock_listener = Mock()
        driver.add_listener(CorrectionUpdate, mock_listener)

        self.mock_beamline.trigger_listeners(ActiveModeUpdate(self.mode1))

        mock_listener.assert_called_once()
Example #40
0
 def test_wait_loop_2(self, time_mock, test_fix):
     """
     Message starts with Timeout expired
     expect func() to be called.
     func returns with osd.1 is safe to destroy
     """
     test_fix = test_fix()
     test_func = Mock(return_value="osd.1 is safe to destroy")
     ret = test_fix._wait_loop(test_func, 'Timeout expired')
     test_func.assert_called_once()
     assert ret is True
Example #41
0
 def test_wait_loop_1(self, time_mock, test_fix):
     """
     Message starts with Timeout expired
     expect func() to be called.
     func returns unexpected return output bogus
     """
     test_fix = test_fix()
     test_func = Mock(return_value="Unexpected return")
     ret = test_fix._wait_loop(test_func, 'Timeout expired')
     test_func.assert_called_once()
     assert ret is None  # it breaks (as in continue/break)
Example #42
0
    def test_get_all_network(self):
        fake_networks = [{'fake network': 'fake network info'}]
        client_list_networks_mock = Mock(
                                     return_value={'networks': fake_networks})

        with patch.object(self.neutron_api.client, 'list_networks',
                          client_list_networks_mock):

            networks = self.neutron_api.get_all_networks()
            client_list_networks_mock.assert_called_once()
            self.assertEqual(networks, fake_networks)
Example #43
0
def test_calls_off_when_device_is_found(get_device_mock):
    power_cmd = PowerCommand('Test Device', 'off')
    device_mock = Mock(name='Test Device')
    device_off_method = Mock()

    get_device_mock.return_value = device_mock
    device_mock.off = device_off_method

    power_cmd.execute()

    device_off_method.assert_called_once()
Example #44
0
def test_continuous_integration__custom_config__from_argv(monkeypatch):
    with in_temp_dir():
        write_config("custom/path/to/jasmine.yml")
        fake_standalone = Mock()
        cmd = Command(fake_standalone, FakeCI)
        cmd.run(['ci', '-c', 'custom/path/to/jasmine.yml'])

        fake_standalone.assert_called_once()
        standalone_construction_kwargs = fake_standalone.call_args[1]
        called_with_config = standalone_construction_kwargs['jasmine_config'].yaml_file
        assert called_with_config.endswith("custom/path/to/jasmine.yml")
Example #45
0
    def test_should_call_build_image_command_through_CLI(
        self,
        read_project_mock: mock.Mock,
        build_image_mock: mock.Mock,
    ):
        # when
        cli(['build-image'])

        # then
        read_project_mock.assert_called_once()
        build_image_mock.assert_any_call(read_project_mock.return_value)
Example #46
0
 def test_lazy_prop_called_once(self):
     """
     Ensures that the lazy property is called only once, but returns the same value.
     """
     mock = Mock(return_value=100)
     prop = UsesLazyProp(mock)
     val1 = prop.lazy_prop
     val2 = prop.lazy_prop
     self.assertEqual(val1, 100)
     self.assertEqual(val1, val2)
     mock.assert_called_once()
Example #47
0
 def test_lazy_prop_called_once(self):
     """
     Ensures that the lazy property is called only once, but returns the same value.
     """
     mock = Mock(return_value=100)
     prop = UsesLazyProp(mock)
     val1 = prop.lazy_prop
     val2 = prop.lazy_prop
     self.assertEqual(val1, 100)
     self.assertEqual(val1, val2)
     mock.assert_called_once()
Example #48
0
    def test_parse_form(self):
        on_field = Mock()
        on_file = Mock()

        parse_form({"Content-Type": "application/octet-stream"}, BytesIO(b"123456789012345"), on_field, on_file)

        on_file.assert_called_once()

        # Assert that the first argument of the call (a File object) has size
        # 15 - i.e. all data is written.
        self.assertEqual(on_file.call_args[0][0].size, 15)
    def test_fire_with_context():
        event_manager = EventManager()

        def test_listener(bot=None):
            bot()

        event_manager.add_listener('test', test_listener, priority=-100)

        bot = Mock()
        event_manager.fire_with_context('test', bot)

        bot.assert_called_once()
Example #50
0
def test_dict_hook():
    function_mock = Mock(return_value=None)
    hook = Hook("b", handler=function_mock)

    assert Schema({hook: str, Optional("b"): object}).validate({"b": "bye"}) == {"b": "bye"}
    function_mock.assert_called_once()

    assert Schema({hook: int, Optional("b"): object}).validate({"b": "bye"}) == {"b": "bye"}
    function_mock.assert_called_once()

    assert Schema({hook: str, "b": object}).validate({"b": "bye"}) == {"b": "bye"}
    assert function_mock.call_count == 2
    def test_idle(self):
        imap_client = yield from self.login_user('user', 'pass', select=True, lib=imaplib2.IMAP4)
        idle_callback = Mock()
        self.loop.run_in_executor(None, functools.partial(imap_client.idle, callback=idle_callback))
        yield from asyncio.wait_for(self.imapserver.get_connection('user').wait(imapserver.IDLE), 1)

        self.loop.run_in_executor(None, functools.partial(self.imapserver.receive,
                                                          Mail.create(to=['user'], mail_from='me', subject='hello')))

        yield from asyncio.wait_for(self.imapserver.get_connection('user').wait(imapserver.SELECTED), 1)
        time.sleep(0.1) # eurk hate sleeps but I don't know how to wait for the lib to receive end of IDLE
        idle_callback.assert_called_once()
Example #52
0
 def test_run_remember_command_whenSaveDir_shouldWriteLastCommand(
         self, process_mock: Mock, load_mock: Mock) -> None:
     with mock.patch('remember.command_store_lib.open',
                     mock.mock_open()) as write_mock:
         remember_main.run_remember_command("test", 'test_hist', ['grep'],
                                            False, False, False, 10)
         load_mock.assert_called_once()
         process_mock.assert_called_once()
         write_mock.assert_called_once_with(
             os.path.join('test', DEFAULT_LAST_SAVE_FILE_NAME), 'w')
         handle = write_mock()
         handle.write.assert_called_with('grep foo\n')
 def test_two_factor_check_without_feature_flag(self):
     mock_fn_to_call = Mock(return_value="Function was called!")
     mock_fn_to_call.__name__ = 'test_name' if six.PY3 else b'test_name'
     request = self.request
     api_key = None
     view_func = 'dummy_view_func'
     two_factor_check_fn = two_factor_check(view_func, api_key)
     function_getting_checked_with_auth = two_factor_check_fn(mock_fn_to_call)
     with mock.patch('corehq.apps.domain.decorators._ensure_request_couch_user',
                     return_value=request.couch_user):
         response = function_getting_checked_with_auth(request, self.domain.name)
         self.assertEqual(response, 'Function was called!')
         mock_fn_to_call.assert_called_once()
Example #54
0
def test_executor_once():
    """Test that ExecutorEventEmitters also emit events for once.
    """
    with ExecutorEventEmitter() as ee:
        should_call = Mock()

        @ee.once('event')
        def event_handler():
            should_call(True)

        ee.emit('event')
        sleep(0.1)

        should_call.assert_called_once()
Example #55
0
def test_standalone__custom_config__when_environment_variable_set(monkeypatch):
    with in_temp_dir():
        write_config("custom/path/to/jasmine.yml")
        env_vars = {'JASMINE_CONFIG_PATH': "custom/path/to/jasmine.yml"}
        monkeypatch.setattr(os, 'environ', env_vars)
        fake_standalone = Mock()

        cmd = Command(fake_standalone, FakeCI)
        cmd.run(['server'])

        fake_standalone.assert_called_once()
        standalone_construction_kwargs = fake_standalone.call_args[1]
        called_with_config = standalone_construction_kwargs['jasmine_config'].yaml_file
        assert called_with_config.endswith("custom/path/to/jasmine.yml")
Example #56
0
def test_new_listener_event():
    """The 'new_listener' event fires whenever a new listerner is added."""

    call_me = Mock()
    ee = BaseEventEmitter()

    ee.on('new_listener', call_me)

    # Should fire new_listener event
    @ee.on('event')
    def event_handler(data):
        pass

    call_me.assert_called_once()
Example #57
0
def test_emit_sync(cls):
    """Basic synchronous emission works"""

    call_me = Mock()
    ee = cls()

    @ee.on('event')
    def event_handler(data, **kwargs):
        call_me()
        assert data == 'emitter is emitted!'

    # Making sure data is passed propers
    ee.emit('event', 'emitter is emitted!', error=False)

    call_me.assert_called_once()
Example #58
0
    def test_fetch_requests_token_when_expired(self, request, sleep):
        post_response_mock = Mock()
        post_response_mock.raise_for_status = Mock(return_value=False)
        post_response_mock.json = Mock(return_value={'token': 'token1', 'expires': '123'})
        request.post = Mock(return_value=post_response_mock)

        request_token_mock = Mock()
        return_false_for_status_mock = Mock(return_value=(True, None))

        self.patient._request_token = request_token_mock
        self.patient._return_false_for_status = return_false_for_status_mock

        self.patient._fetch('url')

        request_token_mock.assert_called_once()
Example #59
0
    def test_cleanup(self, mock_get_database):
        self.backend.mongodb_taskmeta_collection = MONGODB_COLLECTION

        mock_database = MagicMock(spec=['__getitem__', '__setitem__'])
        mock_collection = Mock()

        mock_get_database.return_value = mock_database
        mock_database.__getitem__.return_value = mock_collection

        self.backend.cleanup()

        mock_get_database.assert_called_once_with()
        mock_database.__getitem__.assert_called_once_with(
            MONGODB_COLLECTION)
        mock_collection.assert_called_once()