async def start_driver(self):
if self._fut_stop is not None:
await self._fut_stop
self._fut_stop = None
self._fut_running = Future()
if self._fut_start:
await self._fut_start
return
self._fut_start = ensure_future(self._internal_start_driver())
await self._fut_start
async def test_redis_error_recovery(job_processor):
reset_redis = asynctest.CoroutineMock()
job_processor.reset_callback = reset_redis
job = JobRequest('polyswarmd-addr', 'guid', 0, 'uri', ArtifactType.FILE.value, 1, None, 'side', int(time.time()))
future = Future()
job_processor.stop()
job_processor.redis.close()
await job_processor.redis.wait_closed()
await job_processor.register_jobs('guid', 'test_redis_error_recovery', [job], future)
await job_processor.fetch_results()
reset_redis.assert_called()
def wait_for_alert(self,
success_type,
success_getter=None,
fail_type=None,
fail_getter=None):
future = Future()
if success_type:
self.futures[success_type].append(
(future, future.set_result, success_getter))
if fail_type:
self.futures[fail_type].append(
(future, future.set_exception, fail_getter))
return future
def _consume(self):
self.waiter = Future()
def process(_):
while len(self.receive_queue):
data = self.receive_queue.popleft()
if self.transport:
self._dataReceived(data)
else:
print("WebSocketAdapterProtocol._consume: no transport")
self._consume()
self.waiter.add_done_callback(process)
def on_verify_request(self, peer, attribute_hash):
"""
Return the measurement of an attribute for a certain peer.
"""
metadata = self.identity_overlay.get_attestation_by_hash(
attribute_hash)
if not metadata:
return succeed(None)
attribute_name = json.loads(metadata.serialized_json_dict)["name"]
future = Future()
self.verify_requests[(b64encode(peer.mid).decode(),
attribute_name)] = future
return future
def create_skill_handler_for_testing(
self, adapter) -> SkillHandlerInstanceForTests:
mock_bot = Mock()
mock_bot.on_turn = MagicMock(return_value=Future())
mock_bot.on_turn.return_value.set_result(Mock())
return SkillHandlerInstanceForTests(
adapter,
mock_bot,
self._test_id_factory,
Mock(),
AuthenticationConfiguration(),
)
def call(nvim: Nvim, fn: Callable[[], T]) -> Awaitable[T]:
fut: Future = Future()
def cont() -> None:
try:
ret = fn()
except Exception as e:
fut.set_exception(e)
else:
fut.set_result(ret)
nvim.async_call(cont)
return fut
def connect(self, address: tuple) -> None:
future = Future()
try:
self.socket.connect(address)
except BlockingIOError:
pass
def _handle_connect():
self.io_loop.remove_writer(self.socket)
future.set_result(None)
self.io_loop.add_writer(self.socket, _handle_connect)
return future
def callback_run(self, custom_process=False):
host = getenv('IP', '0.0.0.0')
port = int(getenv('PORT', 8000))
self.logger.info("Started to process messages")
try:
server_generator, handler, app = self.loop.run_until_complete(
self.init_app(host, port, self.loop))
server = self.loop.run_until_complete(server_generator)
except OSError:
self.logger.error("Address already in use: " + str(host) + ":" +
str(port))
return
self.main_task = Future()
if custom_process:
return self.main_task
print("======== Running on http://{}:{} ========\n"
" (Press CTRL+C to quit)".format(
*server.sockets[0].getsockname()))
def stop_server():
server.close()
if not self.loop.is_running():
return
self.loop.run_until_complete(server.wait_closed())
self.loop.run_until_complete(app.shutdown())
self.loop.run_until_complete(handler.shutdown(10))
self.loop.run_until_complete(app.cleanup())
try:
self.loop.run_until_complete(self.main_task)
except KeyboardInterrupt:
self.stop()
stop_server()
self.loop.close()
except asyncio.CancelledError:
pass
finally:
stop_server()
self.logger.info("Stopped to process messages")
async def test_async_alive_terminates(mocker):
mock_start_process = mocker.patch('watchgod.main._start_process')
mock_start_process.return_value = FakeProcess()
mock_kill = mocker.patch('watchgod.main.os.kill')
f = Future()
f.set_result(1)
c = mocker.MagicMock(return_value=f)
reloads = await arun_process('/x/y/async', object(), watcher_cls=FakeWatcher, callback=c, debounce=5, min_sleep=1)
assert reloads == 1
assert mock_start_process.call_count == 2
assert mock_kill.call_count == 1
assert c.call_count == 1
c.assert_called_with({'x'})
def mock_get_sender(name: str):
"""
Mocked sender factory that returns mock senders!
"""
sender = mock.Mock()
sender.name = name
for action in ("open", "close", "send_raw"):
func = Future()
func.set_result(None)
getattr(sender, action).return_value = func
return sender
def crawl_chain(self, peer, latest_block_num=0):
"""
Crawl the whole chain of a specific peer.
:param latest_block_num: The latest block number of the peer in question, if available.
"""
if self.request_cache.has("chaincrawl", ChainCrawlCache.get_number_for(peer)):
self.logger.debug("Skipping crawl of peer %s, another crawl is pending", peer)
return succeed(None)
crawl_future = Future()
cache = ChainCrawlCache(self, peer, crawl_future, known_chain_length=latest_block_num)
self.request_cache.add(cache)
get_event_loop().call_soon_threadsafe(ensure_future, self.send_next_partial_chain_crawl_request(cache))
return crawl_future
async def app_list(self) -> Optional[List[Dict[str, Any]]]:
_LOGGING.debug("Get app list (not available on all TVs)")
# See https://github.com/xchwarze/samsung-tv-ws-api/issues/23
app_list_future: Future[Dict[str, Any]] = Future()
self._app_list_futures.add(app_list_future)
await self.send_command(remote.ChannelEmitCommand.get_installed_app())
try:
async with async_timeout.timeout(self.timeout):
response = await app_list_future
except AsyncioTimeoutError as err:
_LOGGING.debug("Failed to get app list: %s", err)
return None
return parse_installed_app(response)
def mock_future(self, method, return_value):
"""
Mock 协程/Future对象
:param method: 需要被 mock 的方法
:param return_value: 期望的返回值
:return:
"""
_patcher = mock.patch(method)
ft = Future()
ft.set_result(return_value)
self._patcher.append(_patcher)
mocker = _patcher.start()
mocker.return_value = ft
return mocker
def test_remove_user_from_db_calls_db_remove_user(self):
self.bot.part_channels = MagicMock(return_value=Future())
self.bot.part_channels.return_value.set_result('')
cog = AdminCog(self.bot)
test_twitch_username = '******'
self.loop.run_until_complete(
cog.remove_user_from_db._callback(cog, self.ctx,
test_twitch_username))
self.bot.users_db.remove_user.assert_called_once_with(
twitch_username='******')
async def in_terminal(
render_cli_done: bool = False) -> AsyncGenerator[None, None]:
"""
Context manager that suspends the current application and runs the body in
the terminal.
"""
app = get_app_or_none()
if app is None or not app._is_running:
yield
return
# When a previous `run_in_terminal` call was in progress. Wait for that
# to finish, before starting this one. Chain to previous call.
previous_run_in_terminal_f = app._running_in_terminal_f
new_run_in_terminal_f: Future[None] = Future()
app._running_in_terminal_f = new_run_in_terminal_f
# Wait for the previous `run_in_terminal` to finish.
if previous_run_in_terminal_f is not None:
await previous_run_in_terminal_f
# Wait for all CPRs to arrive. We don't want to detach the input until
# all cursor position responses have been arrived. Otherwise, the tty
# will echo its input and can show stuff like ^[[39;1R.
if app.input.responds_to_cpr:
await app.renderer.wait_for_cpr_responses()
# Draw interface in 'done' state, or erase.
if render_cli_done:
app._redraw(render_as_done=True)
else:
app.renderer.erase()
# Disable rendering.
app._running_in_terminal = True
# Detach input.
try:
with app.input.detach():
with app.input.cooked_mode():
yield
finally:
# Redraw interface again.
try:
app._running_in_terminal = False
app.renderer.reset()
app._request_absolute_cursor_position()
app._redraw()
finally:
new_run_in_terminal_f.set_result(None)
async def test_ignored_error_logging(self):
request = MagicMock()
response = MagicMock(status_code=404)
response_wrapper = Future()
response_wrapper.set_result(response)
logger = MagicMock()
middleware = under_test.StructlogRequestMiddleware(
MagicMock(), logger=logger, ignored_status_codes={404})
response = await middleware.dispatch(request,
lambda _: response_wrapper)
assert logger.log.call_count == 2
async def send_data(self, destination_node_id: int, command: List[int]):
self.ack[destination_node_id] = Future()
self.network_controller.send_message_in_current_network(
destination_node_id, 'APPLICATION_COMMAND', {'command': command})
try:
await asyncio.wait_for(self.ack[destination_node_id],
timeout=self.TIMEOUT_SECONDS)
yield TransmitStatus.OK
except asyncio.TimeoutError:
yield TransmitStatus.NO_ACK
finally:
del self.ack[destination_node_id]
def invoke_func(*args, **kwargs):
result_future = Future()
def done_cb(fut):
with suppress(CancelledError):
handle = fut.result()
if not fut.cancelled() and not result_future.done(
) and handle == download.handle and handle.is_valid():
result_future.set_result(func(*args, **kwargs))
download = args[0]
handle_future = download.get_handle()
handle_future.add_done_callback(done_cb)
return result_future
async def test_rabbit_progress_connection(loop, client, progress_channel,
fake_progress_message, mocker):
mock = mocker.patch(
'simcore_service_webserver.computation_subscribe.sio.emit',
return_value=Future())
mock.return_value.set_result("")
for i in range(1000):
await progress_channel.publish(aio_pika.Message(
body=json.dumps(fake_progress_message).encode(),
content_type="text/json"),
routing_key="")
mock.assert_called_with("progress", data=json.dumps(fake_progress_message))
async def _(state: str, request: Request, wait: bool = False) -> JSONDict:
while True:
try:
return core.lock(state)
except core.NotAllowed as e:
raise HTTPException(400, e.args[0])
except core.NotFound:
if not wait:
raise HTTPException(404, f"{state} is not found")
future = Future()
waitings[state].append((future, request))
if await future == "disconnected":
return {} # this request has gone, return any has no meaning
continue
def test_toggle_test_for_user_calls_db_toggle_setting(self):
self.bot.part_channels = MagicMock(return_value=Future())
self.bot.part_channels.return_value.set_result('')
cog = AdminCog(self.bot)
test_twitch_username = '******'
self.loop.run_until_complete(
cog.toggle_test_for_user._callback(cog, self.ctx,
test_twitch_username))
self.bot.users_db.toggle_setting.assert_called_once_with(
'test', 'test_twitch_username')
def read_bytes(self, num_bytes):
assert self._read_future is None, "Already reading"
if self._closed:
raise StreamClosedError(IOError('Already Closed'))
future = self._read_future = Future()
self._read_bytes = num_bytes
if self._read_buffer_size >= self._read_bytes:
future, self._read_future = self._read_future, None
self._read_buffer, data = bytearray(), self._read_buffer
self._read_buffer_size = 0
self._read_bytes = 0
future.set_result(data)
return future
async def test_run_coroutine_job(asyncio_scheduler, asyncio_executor, exception):
from asyncio import Future, sleep
future = Future()
job = asyncio_scheduler.add_job(waiter, 'interval', seconds=1, args=[sleep, exception])
asyncio_executor._run_job_success = lambda job_id, events: future.set_result(events)
asyncio_executor._run_job_error = lambda job_id, exc, tb: future.set_exception(exc)
asyncio_executor.submit_job(job, [datetime.now(utc)])
events = await future
assert len(events) == 1
if exception:
assert str(events[0].exception) == 'dummy error'
else:
assert events[0].retval is True
async def test_start_and_end_requests_logged(self):
request = MagicMock()
response = MagicMock(status_code=200)
response_wrapper = Future()
response_wrapper.set_result(response)
logger = MagicMock()
middleware = under_test.StructlogRequestMiddleware(MagicMock(),
logger=logger)
response = await middleware.dispatch(request,
lambda _: response_wrapper)
assert logger.log.call_count == 2
async def generic_test_all(mocker, fake, service_class):
expected = [fake(1), fake(2)]
repository = mocker.Mock()
f = Future()
f.set_result(expected)
repository.all = mocker.MagicMock(return_value=f)
service = service_class(repository)
result = await service.all(1, 100)
assert result == expected
repository.all.assert_called_once_with(1, 100)
repository.all.reset_data()
result = await service.all(None, None)
assert result == expected
repository.all.assert_called_with(0, 100)
def test_close(mocker):
# arrange
consumer = get_consumer(callback=simple_callback)
consumer._closed = asyncio.Future()
connection = mocker.patch.object(consumer, '_connection', autospec=True)
connection.closed = Future()
# act
consumer.close()
# assert
assert consumer._closed.done()
assert isinstance(consumer._closed.exception(), ConsumerCloseException)
def test_transmit_handles_failure():
"""
Test transmit failures don't kill the interface handling.
"""
my_port = UnreliableDummyKISS()
my_frame_1 = AX25UnnumberedInformationFrame(destination='VK4BWI-4',
source='VK4MSL',
pid=0xf0,
payload=b'testing 1')
my_frame_2 = AX25UnnumberedInformationFrame(destination='VK4BWI-4',
source='VK4MSL',
pid=0xf0,
payload=b'testing 2')
transmit_future = Future()
my_interface = AX25Interface(my_port, cts_delay=0.250)
# Override clear to send expiry
my_interface._cts_expiry = 0
def _on_transmit(interface, frame, **kwargs):
try:
eq_(len(kwargs), 0, msg='Too many arguments')
assert_is(interface, my_interface, msg='Wrong interface')
eq_(bytes(frame), bytes(my_frame_2), msg='Wrong frame')
transmit_future.set_result(None)
except Exception as e:
transmit_future.set_exception(e)
def _on_timeout():
transmit_future.set_exception(AssertionError('Timed out'))
# The time before transmission
time_before = time.monotonic()
# Set a timeout
get_event_loop().call_later(2.0, _on_timeout)
# Send the messages
my_interface.transmit(my_frame_1, _on_transmit) # This will fail
my_interface.transmit(my_frame_2, _on_transmit) # This will work
yield from transmit_future
eq_(len(my_port.sent), 1)
(send_time, sent_frame) = my_port.sent.pop(0)
eq_(bytes(sent_frame), bytes(my_frame_2))
assert_less((time.monotonic() - send_time), 0.05)
assert_greater_equal((send_time - time_before), 0.25)
async def test_request_response_error(self):
message = b'something went wrong'
response_future = Future()
response_future.set_result((404, message))
self.make_request_mock.return_value = response_future
with self.assertRaises(TTransportException) as e:
await self.transport.request(FContext(),
bytearray([0, 0, 0, 3, 1, 2, 3]))
self.assertEqual(
str(e.exception),
'request errored with code {0} and message {1}'.format(
404, str(message)))
def test_notify_with_non_recognized_connections(self):
data = {
"name":
"test",
"condition":
V1StatusCondition(type=V1Statuses.FAILED, status=True).to_dict(),
"connections": ["test1", "test2"],
}
with patch("polyaxon.agents.spawners.async_spawner.AsyncK8SManager"
) as manager_mock:
manager_mock.return_value.setup.return_value = Future()
manager_mock.return_value.setup.return_value.set_result(None)
response = self.client.post(self.base_url, json=data)
assert response.status_code == 200
