def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() # self.loop.set_debug(False) self.app = self.get_app(self.loop) self.client = TestClient(self.app, ) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.first_headers = { 'Authorization': self.first_token, 'Content-Type': 'application/json', } self.second_headers = { 'Authorization': self.second_token, 'Content-Type': 'application/json', } self.loop.run_until_complete(self.install_chat())
def test_checkVersion(): if os.path.exists("tests/tmp.db"): os.remove("tests/tmp.db") # Remove existing db bumper.db = "tests/tmp.db" # Set db location for testing loop = asyncio.get_event_loop() client = TestClient(TestServer(app), loop=loop) loop.run_until_complete(client.start_server()) root = "http://{}".format(confserver.address) async def test_handle_checkVersion(): resp = await client.get( "/1/private/us/en/dev_1234/ios/1/0/0/common/checkVersion") assert resp.status == 200 text = await resp.text() jsonresp = json.loads(text) if jsonresp: assert jsonresp["code"] == bumper.RETURN_API_SUCCESS else: assert jsonresp # Test loop.run_until_complete(test_handle_checkVersion()) loop.run_until_complete( client.close()) # Close test server after all tests are done
async def test_parallel_connection( self, client: TestClient, client_name: str, namespace_prefix: str, current_registry: prometheus_client.CollectorRegistry, ): results = await asyncio.gather(client.get("/200"), client.get("/200")) await asyncio.gather(*(r.json() for r in results)) current_frozen_registry: List[prometheus_client.Metric] = list( current_registry.collect()) assert_metric_exists( current_frozen_registry, f"{namespace_prefix}aiohttp_client_connection_create_seconds", f"{namespace_prefix}aiohttp_client_connection_create_seconds_bucket", labels={ "client_name": client_name, }, ) assert_metric_value( current_frozen_registry, f"{namespace_prefix}aiohttp_client_connection_reuseconn", f"{namespace_prefix}aiohttp_client_connection_reuseconn_total", 1.0, labels={ "client_name": client_name, }, )
def test_postLookup(): if os.path.exists("tests/tmp.db"): os.remove("tests/tmp.db") # Remove existing db bumper.db = "tests/tmp.db" # Set db location for testing loop = asyncio.get_event_loop() client = TestClient(TestServer(app), loop=loop) loop.run_until_complete(client.start_server()) root = "http://{}".format(confserver.address) async def test_handle_lookup(postbody=None): resp = await client.post("/lookup.do", json=postbody) assert resp.status == 200 text = await resp.text() jsonresp = json.loads(text) if jsonresp: assert jsonresp["result"] == "ok" else: assert jsonresp # Test FindBest postbody = {"todo": "FindBest", "service": "EcoMsgNew"} # Test loop.run_until_complete(test_handle_lookup(postbody)) # Test EcoUpdate postbody = {"todo": "FindBest", "service": "EcoUpdate"} # Test loop.run_until_complete(test_handle_lookup(postbody)) loop.run_until_complete( client.close()) # Close test server after all tests are done
def test_logout(): if os.path.exists("tests/tmp.db"): os.remove("tests/tmp.db") # Remove existing db bumper.db = "tests/tmp.db" # Set db location for testing loop = asyncio.get_event_loop() client = TestClient(TestServer(app), loop=loop) loop.run_until_complete(client.start_server()) root = "http://{}".format(confserver.address) async def test_handle_logout(token=None): resp = await client.get( "/1/private/us/en/dev_1234/ios/1/0/0/user/logout?accessToken={}". format(token)) assert resp.status == 200 text = await resp.text() jsonresp = json.loads(text) if jsonresp: assert jsonresp["code"] == bumper.RETURN_API_SUCCESS else: assert jsonresp # Add a token to user and test bumper.user_add("testuser") bumper.user_add_device("testuser", "dev_1234") bumper.user_add_token("testuser", "token_1234") # Test loop.run_until_complete(test_handle_logout(token="token_1234")) loop.run_until_complete( client.close()) # Close test server after all tests are done
async def setUp(self) -> None: self.mc_server = mock.MagicMock() self.mc_server.sensors = SensorSet() self.mc_server.orig_sensors = SensorSet() self.mc_server.sensors.add( Sensor(str, 'products', '', default='["product1", "product2"]', initial_status=Sensor.Status.NOMINAL)) self.mc_server.sensors.add( Sensor(str, 'gui-urls', '', default=json.dumps(ROOT_GUI_URLS), initial_status=Sensor.Status.NOMINAL)) self.mc_server.orig_sensors.add( Sensor(str, 'product1.gui-urls', '', default=json.dumps(PRODUCT1_GUI_URLS), initial_status=Sensor.Status.NOMINAL)) self.mc_server.orig_sensors.add( Sensor(str, 'product2.cal.1.gui-urls', '', default=json.dumps(PRODUCT2_CAL_GUI_URLS), initial_status=Sensor.Status.NOMINAL)) self.mc_server.orig_sensors.add( Sensor(str, 'product2.ingest.1.gui-urls', '', default=json.dumps(PRODUCT2_CAL_GUI_URLS), initial_status=Sensor.Status.UNKNOWN)) for sensor in self.mc_server.orig_sensors.values(): if self.haproxy_bind is not None and sensor.name.endswith( '.gui-urls'): new_value = web.rewrite_gui_urls(EXTERNAL_URL, sensor) new_sensor = Sensor(sensor.stype, sensor.name, sensor.description, sensor.units) new_sensor.set_value(new_value, timestamp=sensor.timestamp, status=sensor.status) self.mc_server.sensors.add(new_sensor) else: self.mc_server.sensors.add(sensor) self.app = web.make_app(self.mc_server, self.haproxy_bind) self.server = TestServer(self.app) self.client = TestClient(self.server) await self.client.start_server() self.addCleanup(self.client.close) self.mc_server.add_interface_changed_callback.assert_called_once() self.dirty_set = self.mc_server.add_interface_changed_callback.mock_calls[ 0][1][0] self.dirty_set() await self.advance(1)
def _create_from_app_factory(app_factory, *args, **kwargs): nonlocal test_client, rpc_client app = app_factory(loop, *args, **kwargs) test_client = TestClient(TestServer(app), loop=loop) yield from test_client.start_server() rpc_client = ServerProxy('', loop=loop, client=test_client) return rpc_client
def client(event_loop, app, cookie_jar): from aiohttp.test_utils import TestServer, TestClient _server = TestServer(app, loop=event_loop) _client = TestClient(_server, loop=event_loop, cookie_jar=cookie_jar) event_loop.run_until_complete(_client.start_server()) yield _client event_loop.run_until_complete(_client.close())
def test_test_client_close_is_idempotent(): """ a test client, called multiple times, should not attempt to close the loop again. """ with loop_context() as loop: app = _create_example_app(loop) client = TestClient(app) client.close() client.close()
def test_test_client_close_is_idempotent(): """ a test client, called multiple times, should not attempt to close the loop again. """ loop = setup_test_loop() app = _create_example_app(loop) client = TestClient(app) client.close() teardown_test_loop(loop) client.close()
async def connect(self): self._loop = asyncio.get_running_loop() client = TestClient(self._server) async with client.ws_connect('/') as websocket: try: self._websocket = websocket self._connected_event.set_result(True) async for request in websocket: self._messages_queue.append(request) self._message_event.set_result(True) except asyncio.CancelledError: await self.stop()
async def test_route_asgi(loop, client: test_utils.TestClient): async with client.get("/asgi") as response: response.raise_for_status() body = await response.json() assert body == {'message': 'Hello World', 'root_path': ''} async with client.get("/not-found") as response: with pytest.raises(aiohttp.ClientError) as err: response.raise_for_status() assert err.value.status == 404
def run(self): try: backend = Backend(graph_path=str(TEST_GRAPH_PATH)) with backend: with loop_context() as loop: app = make_app(backend=backend, debug=True) client = TestClient(TestServer(app), loop=loop) loop.run_until_complete(client.start_server()) url = client.make_url("/graph/") self.q.put(url) loop.run_forever() except Exception as e: self.q.put(e)
async def go(__param, *, server_kwargs=None, **kwargs): # type: ignore if isinstance(__param, Application): server_kwargs = server_kwargs or {} server = TestServer(__param, **server_kwargs) client = TestClient(server, **kwargs) elif isinstance(__param, BaseTestServer): client = TestClient(__param, **kwargs) else: raise ValueError("Unknown argument type: %r" % type(__param)) await client.start_server() clients.append(client) return client
def test_server_with_create_test_teardown(): with loop_context() as loop: app = _create_example_app(loop) client = TestClient(app) @asyncio.coroutine def test_get_route(): resp = yield from client.request("GET", "/") assert resp.status == 200 text = yield from resp.text() assert "Hello, world" in text loop.run_until_complete(test_get_route()) client.close()
def test_checkLogin(): if os.path.exists("tests/tmp.db"): os.remove("tests/tmp.db") # Remove existing db bumper.db = "tests/tmp.db" # Set db location for testing loop = asyncio.get_event_loop() client = TestClient(TestServer(app), loop=loop) loop.run_until_complete(client.start_server()) root = "http://{}".format(confserver.address) async def test_handle_checkLogin(token=None): resp = await client.get( "/1/private/us/en/dev_1234/ios/1/0/0/user/checkLogin?accessToken={}" .format(token)) assert resp.status == 200 text = await resp.text() jsonresp = json.loads(text) if jsonresp: assert jsonresp["code"] == bumper.RETURN_API_SUCCESS assert "accessToken" in jsonresp["data"] if not token: assert jsonresp["data"]["accessToken"] != "token_1234" else: assert jsonresp["data"]["accessToken"] == "token_1234" assert "uid" in jsonresp["data"] assert "username" in jsonresp["data"] else: assert jsonresp # Test loop.run_until_complete(test_handle_checkLogin()) # Add a user to db and test with existing users bumper.user_add("testuser") # Test loop.run_until_complete(test_handle_checkLogin()) # Remove dev from tmpuser bumper.user_remove_device("tmpuser", "dev_1234") # Add a token to user and test bumper.user_add("testuser") bumper.user_add_device("testuser", "dev_1234") bumper.user_add_token("testuser", "token_1234") # Test loop.run_until_complete(test_handle_checkLogin(token="token_1234")) loop.run_until_complete( client.close()) # Close test server after all tests are done
def test_grade_api(app): with loop_context() as loop: with TestClient(app, loop=loop) as client: async def get_headers(): nonlocal client auth_header = { 'Authorization': 'Basic %s' % base64.b64encode(b'2014210761:2014210761').decode() } async with aiohttp.ClientSession( headers=auth_header) as session: async with session.get( 'http://info_login_service:8080/api/info/login/' ) as resp: assert resp.status == 200 json_data = await resp.json() auth_header.update(json_data.get('cookie')) cookie_header = auth_header cookie_header['Sid'] = json_data.get('sid') return cookie_header async def _test_grade_get_api(): nonlocal client cookie_header = await get_headers() resp = await client.get('/api/grade/?xnm=2014&xqm=3', headers=cookie_header) assert resp.status == 200 print(".... grade get api [OK]") loop.run_until_complete(_test_grade_get_api())
async def _test_client(config): from aiohttp.test_utils import TestServer, TestClient db = Gino() app = web.Application(middlewares=[db]) app['config'] = dict(gino=config) db.init_app(app) class User(db.Model): __tablename__ = 'gino_users' id = db.Column(db.BigInteger(), primary_key=True) nickname = db.Column('name', db.Unicode(), default='noname') routes = web.RouteTableDef() @routes.get('/') async def root(request): return web.Response(text='Hello, world!') @routes.get('/users/{uid}') async def get_user(request): uid = int(request.match_info['uid']) method = request.query.get('method') q = User.query.where(User.id == uid) if method == '1': return web.json_response((await q.gino.first_or_404()).to_dict()) elif method == '2': return web.json_response( (await request['connection'].first_or_404(q)).to_dict()) elif method == '3': return web.json_response((await db.bind.first_or_404(q)).to_dict()) elif method == '4': return web.json_response( (await request.app['db'].first_or_404(q)).to_dict()) else: return web.json_response((await User.get_or_404(uid)).to_dict()) @routes.post('/users') async def add_user(request): form = await request.post() u = await User.create(nickname=form.get('name')) await u.query.gino.first_or_404() await db.first_or_404(u.query) await db.bind.first_or_404(u.query) await request['connection'].first_or_404(u.query) return web.json_response(u.to_dict()) app.router.add_routes(routes) e = await gino.create_engine(PG_URL) try: try: await db.gino.create_all(e) async with TestClient(TestServer(app)) as rv: await yield_(rv) finally: await db.gino.drop_all(e) finally: await e.close()
def test_info_login_api(app): with loop_context() as loop: with TestClient(app, loop=loop) as client: async def _test_info_login_api(): auth_header1 = { 'Authorization': 'Basic %s' % base64.b64encode(b'2014210761:2014210761').decode() } auth_header2 = { 'Authorization': 'Basic %s' % base64.b64encode(b'2014210761:fuckccnu').decode() } auth_header3 = {} resp = await client.get('/api/info/login/', headers=auth_header1) assert resp.status == 200 resp = await client.get('/api/info/login/', headers=auth_header2) assert resp.status == 403 resp = await client.get('/api/info/login/', headers=auth_header3) assert resp.status == 401 print('... test info login api [ok]') loop.run_until_complete(_test_info_login_api())
async def setUp(self): usecase_context.initialize() api_context.initialize() self.openchat = OpenChat() self.app = await self.openchat.create_app() self.client = TestClient(TestServer(self.app), loop=self.loop) await self.client.start_server()
async def aiohttp_faraday_client(self): app = web.Application() app.router.add_get(self.wrap_route("/_api/v3/info"), get_info(self)) app.router.add_post( self.wrap_route("/_api/v3/agent_registration"), get_agent_registration(self), ) app.router.add_post( self.wrap_route("/_api/v3/agent_websocket_token"), get_agent_websocket_token(self), ) for workspace in self.workspaces: app.router.add_post( self.wrap_route(f"/_api/v3/ws/{workspace}/bulk_create"), get_bulk_create(self), ) app.router.add_post( self.wrap_route("/_api/v3/ws/error500/bulk_create"), get_bulk_create(self)) app.router.add_post( self.wrap_route("/_api/v3/ws/error429/bulk_create"), get_bulk_create(self)) app.router.add_get(self.wrap_route("/websockets"), get_ws_handler(self)) server = TestServer(app) server_params = {} if self.is_ssl: ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH) ssl_context.load_cert_chain(self.ssl_cert_path / "ok.crt", self.ssl_cert_path / "ok.key") server_params["ssl"] = ssl_context await server.start_server(**server_params) client = TestClient(server, raise_for_status=True) return client
def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() # self.loop.set_debug(False) self.app = self.get_app( self.loop ) self.client = TestClient( self.app, ) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.first_headers = { 'Authorization': self.first_token, 'Content-Type': 'application/json', } self.second_headers = { 'Authorization': self.second_token, 'Content-Type': 'application/json', } self.loop.run_until_complete(self.install_chat())
async def test_resolves_handler_parameters(self): expected_user_name = "Some User Name" class User: def __init__(self, name): self.name = name def insert_user_into_type_registry(handler): async def _wrapper(request: web.Request): request["types_registry"].set(User(name=expected_user_name)) return await call_http_handler(request, handler) return _wrapper @self.app.route(["/"], type=RouteTypes.HTTP, methods=["GET"]) @insert_user_into_type_registry async def handler(user: User): return web.json_response({"name": user.name}) with mock.patch.dict(os.environ, ASYNCWORKER_HTTP_PORT="9999"): settings_mock = Settings() with mock.patch( "asyncworker.signals.handlers.http.settings", settings_mock ): await self.signal_handler.startup(self.app) async with TestClient( TestServer(self.app[RouteTypes.HTTP]["app"]), loop=asyncio.get_event_loop(), ) as client: resp = await client.get("/") self.assertEqual(200, resp.status) resp_data = await resp.json() self.assertEqual({"name": expected_user_name}, resp_data) await self.signal_handler.shutdown(self.app)
async def test_resolves_handler_parameters_when_receiving_request(self): def my_decorator(handler): async def _wrapper(request: web.Request): return await call_http_handler(request, handler) return _wrapper @self.app.route(["/"], type=RouteTypes.HTTP, methods=["GET"]) @my_decorator async def handler(request: web.Request): return web.json_response({"num": request.query["num"]}) with mock.patch.dict(os.environ, ASYNCWORKER_HTTP_PORT="9999"): settings_mock = Settings() with mock.patch( "asyncworker.signals.handlers.http.settings", settings_mock ): await self.signal_handler.startup(self.app) async with TestClient( TestServer(self.app[RouteTypes.HTTP]["app"]), loop=asyncio.get_event_loop(), ) as client: resp = await client.get("/", params={"num": 42}) self.assertEqual(200, resp.status) resp_data = await resp.json() self.assertEqual({"num": "42"}, resp_data) await self.signal_handler.shutdown(self.app)
async def go( __param: Application | BaseTestServer, *args: Any, server_kwargs: dict[str, Any] | None = None, **kwargs: Any, ) -> TestClient: if isinstance(__param, Callable) and not isinstance( # type: ignore[arg-type] __param, (Application, BaseTestServer) ): __param = __param(loop, *args, **kwargs) kwargs = {} else: assert not args, "args should be empty" if isinstance(__param, Application): server_kwargs = server_kwargs or {} server = TestServer(__param, loop=loop, **server_kwargs) client = CoalescingClient(server, loop=loop, **kwargs) elif isinstance(__param, BaseTestServer): client = TestClient(__param, loop=loop, **kwargs) else: raise ValueError("Unknown argument type: %r" % type(__param)) await client.start_server() clients.append(client) return client
async def go(__param, *args, server_kwargs=None, **kwargs): server_kwargs = server_kwargs or {} server = TestServer(__param, loop=loop, **server_kwargs) client = TestClient(server, loop=loop, **kwargs) await client.start_server() clients.append(client) return client
async def test_simple(compressor, client: test_utils.TestClient): headers = {hdrs.ACCEPT_ENCODING: compressor} async with client.get("/data", headers=headers) as response: response.raise_for_status() body = await response.json() assert compressor in response.headers[hdrs.CONTENT_ENCODING] assert isinstance(body, dict)
async def go(app): server = TestServer(app, loop=loop) client = TestClient(server, loop=loop) await client.start_server() clients.append(client) return client
async def load_cookie(client: TestClient, redis: aioredis.commands.Redis) -> Any: cookies = client.session.cookie_jar.filter_cookies(client.make_url('/')) key = cookies['AIOHTTP_SESSION'] with await redis as conn: encoded = await conn.get('AIOHTTP_SESSION_' + key.value) s = encoded.decode('utf-8') value = json.loads(s) return value
def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() self.app = self.get_app(self.loop) self.client = TestClient(self.app) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.headers = { 'Authorization': self.token, 'Content-Type': 'application/json' }
def clients_context_num(routine, num=2, patch_nyms=nyms): with patch('websockets_server.core.server.nyms', patch_nyms): with loop_context() as loopext: app = HXApplication() server = TestServer(app) clients = [] for i in range(num): client = TestClient(server, loop=loopext) if i == 0: loopext.run_until_complete(client.start_server()) clients.append(client) try: loopext.run_until_complete(routine(app, *clients)) finally: loopext.run_until_complete(clients[0]._server.close()) for client in clients: loopext.run_until_complete(client.close())
async def close_client_but_not_server(cli: TestClient): # pylint: disable=protected-access if not cli._closed: for resp in cli._responses: resp.close() for ws in cli._websockets: await ws.close() await cli._session.close() cli._closed = True
def test_getAuthCode(): if os.path.exists("tests/tmp.db"): os.remove("tests/tmp.db") # Remove existing db bumper.db = "tests/tmp.db" # Set db location for testing loop = asyncio.get_event_loop() client = TestClient(TestServer(app), loop=loop) loop.run_until_complete(client.start_server()) root = "http://{}".format(confserver.address) async def test_handle_getAuthCode(uid=None, token=None): resp = await client.get( "/1/private/us/en/dev_1234/ios/1/0/0/user/getAuthCode?uid={}&accessToken={}" .format(uid, token)) assert resp.status == 200 text = await resp.text() jsonresp = json.loads(text) if jsonresp: if token: assert jsonresp["code"] == bumper.RETURN_API_SUCCESS assert "authCode" in jsonresp["data"] assert "ecovacsUid" in jsonresp["data"] else: assert jsonresp["code"] == bumper.ERR_TOKEN_INVALID else: assert jsonresp # Test without user or token loop.run_until_complete(test_handle_getAuthCode()) # Add a token to user and test bumper.user_add("testuser") bumper.user_add_device("testuser", "dev_1234") bumper.user_add_token("testuser", "token_1234") # Test loop.run_until_complete( test_handle_getAuthCode(uid="testuser", token="token_1234")) # The above should have added an authcode to token, try again to test with existing authcode # Test loop.run_until_complete( test_handle_getAuthCode(uid="testuser", token="token_1234")) loop.run_until_complete( client.close()) # Close test server after all tests are done
def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() self.app = self.get_app( self.loop ) self.client = TestClient( self.app ) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.headers = { 'Authorization': self.token, 'Content-Type': 'application/json' }
class TestChatApi(AioHTTPTestCase): data = {} headers = {} token = None client_in_request = None def get_app(self, loop): server = app( loop=loop ) server['db'] = self.database( loop=loop ) return server def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() self.app = self.get_app( self.loop ) self.client = TestClient( self.app ) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.headers = { 'Authorization': self.token, 'Content-Type': 'application/json' } def load_data(self): with open('fixtures.json') as data: self.data = json.load(data) def install_client(self): data = json.dumps(self.data) request = yield from self.client.post( path="/client/create/", data=data ) yield from request.json() def auth_client(self): data = json.dumps(self.data) request = yield from self.client.post( path="/client/auth/", data=data ) auth_data = yield from request.json() self.token = auth_data.get('token') @unittest_run_loop async def test_create_chat_without_token(self): request = await self.client.post( path='/chat/create/', ) result = await request.json() assert result.get('status') is False @unittest_run_loop async def test_receive_chat_list(self): request = await self.client.get( path='/chat/list/', headers=self.headers ) result = await request.json() assert result.get('status') is True @unittest_run_loop async def test_create_and_delete_chat(self): create_chat_request = await self.client.post( path='/chat/create/', headers=self.headers ) chat_info = await create_chat_request.json() assert chat_info.get('status') is True data = { 'id': chat_info.get('chat') } delete_chat_request = await self.client.post( path='/chat/delete/', headers=self.headers, data=json.dumps(data) ) result = await delete_chat_request.json() assert result.get('status') is True @unittest_run_loop async def test_delete_chat_with_not_correct_pk(self): data = json.dumps({ 'id': '57652fa9f4e00b15bcd17f7d' }) request = await self.client.post( path='/chat/delete/', headers=self.headers, data=data ) result = await request.json() assert result.get('status') is False
class TestChatApi(AioHTTPTestCase): data = {} headers = {} first_headers = None second_headers = None first_token = None second_token = None first_client = {} second_client = {} client_in_request = None def get_app(self, loop): server = app( loop=loop ) server['db'] = self.database( loop=loop ) return server def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() self.app = self.get_app( self.loop ) self.client = TestClient( self.app, ) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.first_headers = { 'Authorization': self.first_token, 'Content-Type': 'application/json', } self.second_headers = { 'Authorization': self.second_token, 'Content-Type': 'application/json', } self.loop.run_until_complete(self.install_chat()) def load_data(self): with open('ws_chat_fixtures.json') as data: self.data = json.load(data) def install_client(self): # Grab data for create users first_client = self.data.get('clients').get('first') second_client = self.data.get('clients').get('second') # Create request for create first client first_client_auth_request = yield from self.client.post( path="/client/create/", data=json.dumps(first_client) ) # Create request for create second client second_client_auth_request = yield from self.client.post( path="/client/create/", data=json.dumps(second_client) ) yield def auth_client(self): first_client = self.data.get('clients').get('first') second_client = self.data.get('clients').get('second') # auth and get token for first client first_client_request = yield from self.client.post( path="/client/auth/", data=json.dumps(first_client) ) self.first_client = yield from first_client_request.json() self.first_token = self.first_client.get('token') # auth and get token for second client second_client_request = yield from self.client.post( path="/client/auth/", data=json.dumps(second_client) ) self.second_client = yield from second_client_request.json() self.second_token = self.second_client.get('token') def install_chat(self): request = yield from self.client.post( path='/chat/create/', headers=self.first_headers ) result = yield from request.json() os.environ['TEST_CHAT_PK'] = result.get('chat') def delete_test_chat(self): chat = os.environ['TEST_CHAT_PK'] data = json.dumps({ 'id': chat }) request = yield from self.client.post( path='/chat/delete/', headers=self.first_headers, data=data ) result = yield from request.json() def tearDown(self): self.delete_test_chat() super(TestChatApi, self).tearDown() @property def chat_path(self): chat = os.environ['TEST_CHAT_PK'] path = "/chat/ws/{}/".format(chat) return path def message(self, content, sender, receiver=None): if receiver: msg = '{"msg" : "%s", "sender": "%s", "receiver": "%s"}' % ( content, sender, receiver ) else: msg = '{"msg" : "%s", "sender": "%s"}' % ( content, sender ) return msg @unittest_run_loop async def test_open_ws_connect(self): print("========================") print("test_open_ws_connect") request = await self.client.ws_connect( path=self.chat_path, headers=self.first_headers ) assert request.closed is False request.send_str('{"msg": "Hello world"}') await request.close() assert request.closed is True @unittest_run_loop async def test_chat_btw_users(self): print("========================") print("test_chat_btw_users") first_client = await self.client.ws_connect( path=self.chat_path, headers=self.first_headers ) second_client = await self.client.ws_connect( path=self.chat_path, headers=self.second_headers ) messages_for_first_client = [] messages_for_second_client = [] count_messages = 20 for period in range(count_messages): gen_message = ''.join( random.choice(string.ascii_uppercase + string.digits) for _ in range(random.choice([4, 10]))).lower() if len(messages_for_first_client) <= 10: messages_for_first_client.append(gen_message) else: messages_for_second_client.append(gen_message) def message(content, sender): msg = '{"msg": "%s", "sender" : "%s", "send_at": "%s"}' % (content, sender, datetime.datetime.now()) return msg receive_by_first_client = [] receive_by_second_client = [] def first_sender(client): for msg in messages_for_first_client: first_client.send_str(message(msg, client.get('client_id'))) def second_sender(client): for msg in messages_for_first_client: second_client.send_str(message(msg, client.get('client_id'))) first_sender(self.first_client) second_sender(self.second_client) async def messages_first_client(): while len(receive_by_first_client) != count_messages: msg = await first_client.receive() receive_by_first_client.append(msg) async def messages_second_client(): while len(receive_by_second_client) != count_messages: msg = await second_client.receive() receive_by_second_client.append(msg) await messages_first_client() await messages_second_client() print(receive_by_first_client) print(receive_by_second_client) await first_client.close() await second_client.close() assert first_client.closed is True assert second_client.closed is True @unittest_run_loop async def test_send_private_message(self): first_client = await self.client.ws_connect( path=self.chat_path, headers=self.first_headers ) second_client = await self.client.ws_connect( path=self.chat_path, headers=self.second_headers ) # отправка публичного сообщения first_client.send_str(self.message("Hello second client", self.first_client.get('client_id'))) second_client.send_str(self.message("Hello first client", self.second_client.get('client_id'))) # отправка приватного сообщения first_client.send_str( self.message( content="Hello second client from private message", sender=self.first_client.get('client_id'), receiver=self.second_client.get('client_id') ) ) receive_by_first_client = [] receive_by_second_client = [] async def messages_first_client(): while len(receive_by_first_client) != 2: msg = await first_client.receive() receive_by_first_client.append(msg) async def messages_second_client(): while len(receive_by_second_client) != 3: msg = await second_client.receive() receive_by_second_client.append(msg) await messages_first_client() await messages_second_client() print(receive_by_first_client) print(receive_by_second_client) await first_client.close() await second_client.close() assert first_client.closed is True assert second_client.closed is True @unittest_run_loop async def test_get_list_of_client_in_chat(self): print("========================") print("test_get_list_of_client_in_chat") path = "/chat/byId/{}/".format(os.environ['TEST_CHAT_PK']) request = await self.client.get( path=path, headers=self.first_headers ) result = await request.json() assert result.get('status') is True
class TestChatApi(AioHTTPTestCase): data = {} headers = {} first_headers = None second_headers = None first_token = None second_token = None first_client = {} second_client = {} client_in_request = None def get_app(self, loop): server = app( loop=loop ) server['db'] = self.database( loop=loop ) return server def setUp(self): self.load_data() self.database = DB() self.loop = asyncio.new_event_loop() # self.loop.set_debug(False) self.app = self.get_app( self.loop ) self.client = TestClient( self.app, ) self.loop.run_until_complete(self.install_client()) self.loop.run_until_complete(self.auth_client()) self.first_headers = { 'Authorization': self.first_token, 'Content-Type': 'application/json', } self.second_headers = { 'Authorization': self.second_token, 'Content-Type': 'application/json', } self.loop.run_until_complete(self.install_chat()) def load_data(self): with open('ws_chat_fixtures.json') as data: self.data = json.load(data) def install_client(self): # Grab data for create users first_client = self.data.get('clients').get('first') second_client = self.data.get('clients').get('second') # Create request for create first client first_client_auth_request = yield from self.client.post( path="/client/create/", data=json.dumps(first_client) ) # Create request for create second client second_client_auth_request = yield from self.client.post( path="/client/create/", data=json.dumps(second_client) ) yield def auth_client(self): first_client = self.data.get('clients').get('first') second_client = self.data.get('clients').get('second') # auth and get token for first client first_client_request = yield from self.client.post( path="/client/auth/", data=json.dumps(first_client) ) self.first_client = yield from first_client_request.json() self.first_token = self.first_client.get('token') # auth and get token for second client second_client_request = yield from self.client.post( path="/client/auth/", data=json.dumps(second_client) ) self.second_client = yield from second_client_request.json() self.second_token = self.second_client.get('token') def install_chat(self): request = yield from self.client.post( path='/chat/create/', headers=self.first_headers ) result = yield from request.json() os.environ['TEST_CHAT_PK'] = result.get('chat') def delete_test_chat(self): chat = os.environ['TEST_CHAT_PK'] data = json.dumps({ 'id': chat }) request = yield from self.client.post( path='/chat/delete/', headers=self.first_headers, data=data ) result = yield from request.json() def tearDown(self): self.delete_test_chat() super(TestChatApi, self).tearDown() @property def chat_path(self): chat = os.environ['TEST_CHAT_PK'] path = "/chat/ws/{}/{}/".format(chat, self.first_client.get('client_id')) return path @property def second_path(self): chat = os.environ['TEST_CHAT_PK'] path = "/chat/ws/{}/{}/".format(chat, self.second_client.get('client_id')) return path @unittest_run_loop async def test_open_ws_connect(self): print("========================") print("test_open_ws_connect") request = await self.client.ws_connect( path=self.chat_path, headers=self.first_headers ) assert request.closed is False msg = await request.receive() print(msg) request.send_str(data='{"msg": "Hello"}')
def test_client(loop, app): client = TestClient(app) yield client client.close()