Beispiel #1
0
async def test_rpc_client_arg_as_bytes(loop, unused_tcp_port):
    reg = RpcRegistry()
    some_data = os.urandom(100)

    @reg.method()
    def compare_bytes(b_data: bytes) -> bool:
        return some_data == b_data

    class TestRpcClientBytesArg(JsonRpcHttpClient):
        def compare_bytes(
            self,
            b_data: bytes,
            timeout: Optional[float] = None,
        ) -> Awaitable[bool]:
            return self.exec(
                "compare_bytes",
                {'b_data': b_data},
                timeout=timeout,
            )

    async with runapp(unused_tcp_port,
                      JsonRpcHttpHandler(reg,
                                         JsonRpcHttpHandlerConfig())) as app:
        clt = TestRpcClientBytesArg(
            JsonRpcHttpClientConfig(url='http://%s:%s/' %
                                    (app.cfg.srv.host, app.cfg.srv.port)))
        app.add('clt_ba', clt)
        await clt.prepare()
        await clt.start()
        result = await clt.compare_bytes(some_data)
        assert result is True
Beispiel #2
0
 def __init__(self, cfg: Cfg):
     super().__init__(cfg)
     self.add('srv', Server(cfg.srv, handler))
     self.add(
         'clt',
         JsonRpcHttpClient(
             JsonRpcHttpClientConfig(url='http://%s:%s/' %
                                     (cfg.srv.host, cfg.srv.port))),
     )
Beispiel #3
0
async def test_rpc_client_info_field_missed_argument(loop, unused_tcp_port):
    reg = RpcRegistry()

    @reg.method()
    def sum(a: int, b: int = 3) -> int:
        return a + b

    def AField(default: Any) -> Any:
        return FieldInfo(
            default,
            description="A Field",
        )

    def BField(default: Any) -> Any:
        return FieldInfo(
            default,
            description="B Field",
        )

    class TestRpcClientInfoField(JsonRpcHttpClient):
        def sum(
            self,
            a: int = AField(...),
            b: Optional[int] = BField(5),
            timeout: Optional[float] = None,
        ) -> Awaitable[int]:
            return self.exec(
                "sum",
                {
                    'a': a,
                    'b': b
                },
                timeout=timeout,
            )

    async with runapp(unused_tcp_port,
                      JsonRpcHttpHandler(reg,
                                         JsonRpcHttpHandlerConfig())) as app:
        clt = TestRpcClientInfoField(
            JsonRpcHttpClientConfig(url='http://%s:%s/' %
                                    (app.cfg.srv.host, app.cfg.srv.port)))
        app.add('clt_if', clt)
        await clt.prepare()
        await clt.start()
        with pytest.raises(InvalidArguments):
            await clt.sum()
Beispiel #4
0
async def test_rpc_client_model_with_bytes(loop, unused_tcp_port):
    reg = RpcRegistry()
    some_data = os.urandom(100)

    class SomeModel(BaseModel):
        some_int: int
        some_bytes: bytes

    @reg.method()
    def compare_model_bytes(model: SomeModel) -> bool:
        return some_data == model.some_bytes

    class TestRpcClientBytesArg(JsonRpcHttpClient):
        def compare_model_bytes(
            self,
            model: SomeModel,
            timeout: Optional[float] = None,
        ) -> Awaitable[bool]:
            return self.exec(
                "compare_model_bytes",
                {'model': model},
                timeout=timeout,
            )

    async with runapp(
        unused_tcp_port, JsonRpcHttpHandler(reg, JsonRpcHttpHandlerConfig())
    ) as app:
        clt = TestRpcClientBytesArg(
            JsonRpcHttpClientConfig(
                url='http://%s:%s/' % (app.cfg.srv.host, app.cfg.srv.port)
            )
        )
        app.add('clt_ba', clt)
        await clt.prepare()
        await clt.start()
        result = await clt.compare_model_bytes(
            SomeModel(some_int=5, some_bytes=some_data)
        )
        assert result is True