def test_create_test_module(self, problem: Problem, mocker: MockerFixture,
tmp_path: Path) -> None:
out = tmp_path / "test_problem.py"
mocker.patch(
"euler.scraper.Problem.test_module_path",
new=mocker.PropertyMock(return_value=out),
)
problem.create_test_module()
assert out.is_file()
async def test_deployment_progress(mocker: MockerFixture, gstate: GlobalState):
from gravel.controllers.nodes.conn import ConnMgr
from gravel.controllers.nodes.deployment import (
DeploymentErrorEnum,
NodeDeployment,
ProgressEnum,
)
fake_connmgr: ConnMgr = cast(ConnMgr, mocker.MagicMock())
deployment = NodeDeployment(gstate, fake_connmgr)
# no bootstrapper, nostage
assert deployment.progress == 0
# test actual progress
deployment.state.mark_bootstrap()
assert deployment.progress == 0 # no bootstrapper set
deployment._bootstrapper = mocker.MagicMock()
assert deployment._bootstrapper is not None
# we need to do creative mocking for a property that happens to be an
# attribute on a mock object itself.
# https://docs.python.org/3/library/unittest.mock.html#unittest.mock.PropertyMock
fake_progress = mocker.PropertyMock()
type(deployment._bootstrapper).progress = fake_progress # type: ignore
fake_progress.return_value = 0
# progress is set at NONE
assert deployment.progress == 0
deployment._progress = ProgressEnum.PREPARING
assert deployment.progress == 25
deployment._progress = ProgressEnum.PERFORMING
assert deployment._bootstrapper.progress == 0
assert deployment.progress == 25
fake_progress.return_value = 100
assert deployment._bootstrapper.progress == 100
assert deployment.progress == 80
deployment._progress = ProgressEnum.ASSIMILATING
assert deployment.progress == 90
deployment._progress = ProgressEnum.DONE
assert deployment.progress == 100
# deployed stage
deployment.state.mark_deployed()
assert deployment.progress == 100
# error state
deployment.state.mark_error(DeploymentErrorEnum.UNKNOWN_ERROR, "foobar")
assert deployment.progress == 0
def _setUp(self, request: Any, mocker: MockerFixture) -> None:
self.mock_fromfd = mocker.patch('socket.fromfd')
self.mock_selector = mocker.patch('selectors.DefaultSelector')
self.mock_sign_csr = mocker.patch('proxy.http.proxy.server.sign_csr')
self.mock_gen_csr = mocker.patch('proxy.http.proxy.server.gen_csr')
self.mock_gen_public_key = mocker.patch(
'proxy.http.proxy.server.gen_public_key', )
self.mock_server_conn = mocker.patch(
'proxy.http.proxy.server.TcpServerConnection', )
self.mock_ssl_context = mocker.patch('ssl.create_default_context')
self.mock_ssl_wrap = mocker.patch('ssl.wrap_socket')
self.mock_sign_csr.return_value = True
self.mock_gen_csr.return_value = True
self.mock_gen_public_key.return_value = True
self.fileno = 10
self._addr = ('127.0.0.1', 54382)
self.flags = FlagParser.initialize(
ca_cert_file='ca-cert.pem',
ca_key_file='ca-key.pem',
ca_signing_key_file='ca-signing-key.pem',
threaded=True,
)
self.plugin = mocker.MagicMock()
plugin = get_plugin_by_test_name(request.param)
self.flags.plugins = {
b'HttpProtocolHandlerPlugin': [HttpProxyPlugin],
b'HttpProxyBasePlugin': [plugin],
}
self._conn = mocker.MagicMock(spec=socket.socket)
self.mock_fromfd.return_value = self._conn
self.protocol_handler = HttpProtocolHandler(
HttpClientConnection(self._conn, self._addr),
flags=self.flags,
)
self.protocol_handler.initialize()
self.server = self.mock_server_conn.return_value
self.server_ssl_connection = mocker.MagicMock(spec=ssl.SSLSocket)
self.mock_ssl_context.return_value.wrap_socket.return_value = self.server_ssl_connection
self.client_ssl_connection = mocker.MagicMock(spec=ssl.SSLSocket)
self.mock_ssl_wrap.return_value = self.client_ssl_connection
def has_buffer() -> bool:
return cast(bool, self.server.queue.called)
def closed() -> bool:
return not self.server.connect.called
def mock_connection() -> Any:
if self.mock_ssl_context.return_value.wrap_socket.called:
return self.server_ssl_connection
return self._conn
# Do not mock the original wrap method
self.server.wrap.side_effect = \
lambda x, y, as_non_blocking: TcpServerConnection.wrap(
self.server, x, y, as_non_blocking=as_non_blocking,
)
self.server.has_buffer.side_effect = has_buffer
type(self.server).closed = mocker.PropertyMock(side_effect=closed)
type(self.server, ).connection = mocker.PropertyMock(
side_effect=mock_connection, )
self.mock_selector.return_value.select.side_effect = [
[(
selectors.SelectorKey(
fileobj=self._conn.fileno(),
fd=self._conn.fileno(),
events=selectors.EVENT_READ,
data=None,
),
selectors.EVENT_READ,
)],
[(
selectors.SelectorKey(
fileobj=self.client_ssl_connection.fileno(),
fd=self.client_ssl_connection.fileno(),
events=selectors.EVENT_READ,
data=None,
),
selectors.EVENT_READ,
)],
[(
selectors.SelectorKey(
fileobj=self.server_ssl_connection.fileno(),
fd=self.server_ssl_connection.fileno(),
events=selectors.EVENT_WRITE,
data=None,
),
selectors.EVENT_WRITE,
)],
[(
selectors.SelectorKey(
fileobj=self.server_ssl_connection.fileno(),
fd=self.server_ssl_connection.fileno(),
events=selectors.EVENT_READ,
data=None,
),
selectors.EVENT_READ,
)],
]
# Connect
def send(raw: bytes) -> int:
return len(raw)
self._conn.send.side_effect = send
self._conn.recv.return_value = build_http_request(
httpMethods.CONNECT,
b'uni.corn:443',
no_ua=True,
)
