Exemplo n.º 1
0
    async def test_invoke(
        self,
        session,
        subject,
        tap,
        target,
        tap_process,
        target_process,
        plugin_invoker_factory,
    ):
        tap_invoker = plugin_invoker_factory(tap,
                                             config_dir=subject.tap_config_dir,
                                             prepare_with_session=session)
        target_invoker = plugin_invoker_factory(
            target,
            config_dir=subject.target_config_dir,
            prepare_with_session=session)

        invoke_async = CoroutineMock(side_effect=(tap_process, target_process))

        # fmt: off
        with mock.patch.object(SingerRunner, "bookmark", new=CoroutineMock()), \
          mock.patch.object(PluginInvoker, "invoke_async", new=invoke_async) as invoke_async:
            # async method
            await subject.invoke(tap_invoker, target_invoker)

            # correct bins are called
            assert invoke_async.awaited_with(tap_invoker)
            assert invoke_async.awaited_with(target_invoker)

            tap_process.wait.assert_awaited()
            target_process.wait.assert_awaited()
Exemplo n.º 2
0
    async def test_invoke(
        self,
        session,
        subject,
        tap_config_dir,
        target_config_dir,
        tap,
        target,
        tap_process,
        target_process,
        plugin_invoker_factory,
    ):
        tap_invoker = plugin_invoker_factory(tap, config_dir=tap_config_dir)
        target_invoker = plugin_invoker_factory(target,
                                                config_dir=target_config_dir)
        with tap_invoker.prepared(session), target_invoker.prepared(session):
            invoke_async = CoroutineMock(side_effect=(tap_process,
                                                      target_process))
            with mock.patch.object(PluginInvoker,
                                   "invoke_async",
                                   new=invoke_async) as invoke_async:
                # async method
                await subject.invoke(tap_invoker, target_invoker, session)

                # correct bins are called
                assert invoke_async.awaited_with(tap_invoker)
                assert invoke_async.awaited_with(target_invoker)

                tap_process.wait.assert_awaited()
                target_process.wait.assert_awaited()