def client( loop, app_cfg, aiohttp_client, postgres_db, monkeypatch_setenv_from_app_config: Callable, ): # fixture: minimal client with catalog-subsystem enabled and # only pertinent modules # # - Mocks calls to actual API monkeypatch_setenv_from_app_config(app_cfg) app = create_safe_application(app_cfg) assert setup_settings(app) # patch all setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) # needed for login_utils fixtures assert setup_catalog(app) setup_products(app) yield loop.run_until_complete( aiohttp_client(app, server_kwargs={"port": app_cfg["main"]["port"]}))
def client( event_loop, aiohttp_client, app_cfg, postgres_db, monkeypatch_setenv_from_app_config: Callable, ): cfg = deepcopy(app_cfg) port = cfg["main"]["port"] assert cfg["rest"]["version"] == API_VERSION monkeypatch_setenv_from_app_config(cfg) # fake config app = create_safe_application(cfg) assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) setup_users(app) setup_groups(app) client = event_loop.run_until_complete( aiohttp_client(app, server_kwargs={ "port": port, "host": "localhost" })) return client
def client( loop: asyncio.AbstractEventLoop, aiohttp_client: Callable, app_cfg: Dict[str, Any], postgres_db: sa.engine.Engine, mock_orphaned_services, redis_client: Redis, monkeypatch_setenv_from_app_config: Callable, ) -> TestClient: cfg = deepcopy(app_cfg) assert cfg["rest"]["version"] == API_VTAG assert cfg["rest"]["enabled"] cfg["projects"]["enabled"] = True cfg["director"]["enabled"] = True # sets TTL of a resource after logout cfg["resource_manager"][ "resource_deletion_timeout_seconds"] = SERVICE_DELETION_DELAY monkeypatch_setenv_from_app_config(cfg) app = create_safe_application(cfg) # activates only security+restAPI sub-modules assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) setup_users(app) setup_socketio(app) setup_projects(app) setup_director(app) setup_director_v2(app) assert setup_resource_manager(app) assert is_setup_completed("simcore_service_webserver.resource_manager", app) # NOTE: garbage_collector is disabled and instead explicitly called using # garbage_collector_core.collect_garbage assert not is_setup_completed( "simcore_service_webserver.garbage_collector", app) return loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": cfg["main"]["port"], "host": cfg["main"]["host"] }, ))
def app_settings(mock_webserver_service_environment) -> ApplicationSettings: app = web.Application() # init and validation happens here settings = setup_settings(app) print("app settings:\n", settings.json(indent=1)) assert APP_SETTINGS_KEY in app assert app[APP_SETTINGS_KEY] == settings return settings
def client( event_loop: asyncio.AbstractEventLoop, aiohttp_client: Callable, app_config: Dict, postgres_with_template_db: aiopg.sa.engine.Engine, mock_orphaned_services: mock.Mock, monkeypatch_setenv_from_app_config: Callable, ): # test config & env vars ---------------------- cfg = deepcopy(app_config) assert cfg["rest"]["version"] == API_VERSION assert cfg["rest"]["enabled"] cfg["projects"]["enabled"] = True cfg["director"]["enabled"] = True cfg["exporter"]["enabled"] = True monkeypatch_setenv_from_app_config(cfg) # app setup ---------------------------------- app = create_safe_application(cfg) # activates only security+restAPI sub-modules assert setup_settings(app) assert get_exporter_settings(app) is not None, "Should capture defaults" setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) setup_users(app) setup_socketio(app) setup_projects(app) setup_director(app) setup_director_v2(app) setup_exporter(app) # <---- under test setup_storage(app) setup_products(app) setup_catalog(app) setup_scicrunch(app) assert setup_resource_manager(app) setup_garbage_collector(app) yield event_loop.run_until_complete( aiohttp_client( app, server_kwargs={"port": cfg["main"]["port"], "host": cfg["main"]["host"]}, ) )
def client( loop, aiohttp_client, app_config, postgres_with_template_db, mock_orphaned_services, monkeypatch_setenv_from_app_config: Callable, ): cfg = deepcopy(app_config) assert cfg["rest"]["version"] == API_VERSION assert cfg["rest"]["enabled"] cfg["projects"]["enabled"] = True cfg["director"]["enabled"] = True cfg["resource_manager"].update({ "garbage_collection_interval_seconds": GARBAGE_COLLECTOR_INTERVAL, # increase speed of garbage collection "resource_deletion_timeout_seconds": SERVICE_DELETION_DELAY, # reduce deletion delay }) monkeypatch_setenv_from_app_config(cfg) app = create_safe_application(cfg) # activates only security+restAPI sub-modules assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) setup_users(app) setup_socketio(app) setup_projects(app) setup_director(app) setup_director_v2(app) assert setup_resource_manager(app) setup_garbage_collector(app) yield loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": cfg["main"]["port"], "host": cfg["main"]["host"] }, ))
def client( event_loop, aiohttp_client, app_cfg, postgres_db, mocked_director_v2_api, mock_orphaned_services, redis_client, monkeypatch_setenv_from_app_config: Callable, ): # config app cfg = deepcopy(app_cfg) port = cfg["main"]["port"] cfg["projects"]["enabled"] = True cfg["director"]["enabled"] = True cfg["resource_manager"][ "garbage_collection_interval_seconds" ] = DEFAULT_GARBAGE_COLLECTOR_INTERVAL_SECONDS # increase speed of garbage collection cfg["resource_manager"][ "resource_deletion_timeout_seconds" ] = DEFAULT_GARBAGE_COLLECTOR_DELETION_TIMEOUT_SECONDS # reduce deletion delay monkeypatch_setenv_from_app_config(cfg) app = create_safe_application(cfg) # setup app assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) # needed for login_utils fixtures setup_resource_manager(app) setup_garbage_collector(app) setup_socketio(app) setup_director(app) setup_director_v2(app) setup_tags(app) assert setup_projects(app) setup_products(app) # server and client yield event_loop.run_until_complete( aiohttp_client(app, server_kwargs={"port": port, "host": "localhost"}) )
def client( event_loop: asyncio.AbstractEventLoop, postgres_session: sa.orm.session.Session, rabbit_service: RabbitSettings, redis_settings: RedisSettings, simcore_services_ready: None, aiohttp_client: Callable, app_config: Dict[str, Any], ## waits until swarm with *_services are up mocker: MockerFixture, monkeypatch_setenv_from_app_config: Callable, ) -> TestClient: cfg = deepcopy(app_config) assert cfg["rest"]["version"] == API_VTAG cfg["storage"]["enabled"] = False cfg["main"]["testing"] = True # fake config monkeypatch_setenv_from_app_config(cfg) app = create_safe_application(app_config) assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_diagnostics(app) setup_login(app) setup_users(app) setup_socketio(app) setup_projects(app) setup_computation(app) setup_director_v2(app) setup_resource_manager(app) # no garbage collector return event_loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": app_config["main"]["port"], "host": app_config["main"]["host"], }, ))
def client( event_loop, aiohttp_client, app_config, mock_orphaned_services, monkeypatch_setenv_from_app_config: Callable, ): monkeypatch_setenv_from_app_config(app_config) app = create_safe_application(app_config) assert setup_settings(app) setup_session(app) setup_security(app) setup_rest(app) assert setup_activity(app) cli = event_loop.run_until_complete(aiohttp_client(app)) return cli
def client( loop, mock_orphaned_services, aiohttp_client, app_config, # waits until swarm with *_services are up monkeypatch_setenv_from_app_config: Callable, ): assert app_config["rest"]["version"] == API_VERSION app_config["main"]["testing"] = True app_config["storage"]["enabled"] = False app_config["computation"]["enabled"] = False monkeypatch_setenv_from_app_config(app_config) app = create_safe_application(app_config) assert setup_settings(app) setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_login(app) setup_resource_manager(app) setup_garbage_collector(app) assert setup_projects(app) setup_catalog(app) setup_products(app) setup_director_v2(app) yield loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": app_config["main"]["port"], "host": app_config["main"]["host"], }, ) )
def client( event_loop: asyncio.AbstractEventLoop, aiohttp_client: Callable, app_config: Dict[str, Any], ## waits until swarm with *_services are up rabbit_service: RabbitSettings, ## waits until rabbit is responsive and set env vars postgres_db: sa.engine.Engine, mocker: MockerFixture, monkeypatch_setenv_from_app_config: Callable, ): app_config["storage"]["enabled"] = False monkeypatch_setenv_from_app_config(app_config) app = create_safe_application(app_config) assert setup_settings(app) assert app[APP_SETTINGS_KEY].WEBSERVER_COMPUTATION setup_db(app) setup_session(app) setup_security(app) setup_rest(app) setup_diagnostics(app) setup_login(app) setup_projects(app) setup_computation(app) setup_director_v2(app) setup_socketio(app) setup_resource_manager(app) # GC not relevant for these test-suite, return event_loop.run_until_complete( aiohttp_client( app, server_kwargs={ "port": app_config["main"]["port"], "host": app_config["main"]["host"], }, ) )
def redis_enabled_app(redis_client: aioredis.Redis, mocker, mock_env_devel_environment) -> web.Application: # app.cleanup_ctx.append(redis_client) in setup_redis would create a client and connect # to a real redis service. Instead, we mock the get_redis_client access mocker.patch("simcore_service_webserver.redis.get_redis_client", return_value=redis_client) mocker.patch( "simcore_service_webserver.resource_manager.registry.get_redis_client", return_value=redis_client, ) # ------------------ app = create_safe_application() assert setup_settings(app) assert setup_resource_manager(app) assert is_setup_completed("simcore_service_webserver.redis", app) assert get_plugin_settings(app).RESOURCE_MANAGER_RESOURCE_TTL_S == 3 assert get_registry(app) return app
def client( event_loop: asyncio.AbstractEventLoop, unused_tcp_port_factory, aiohttp_client, api_version_prefix, mock_environment: None, ): routes = web.RouteTableDef() @routes.get("/error") async def unexpected_error(request: web.Request): raise Exception("boom shall produce 500") @routes.get(r"/fail") async def expected_failure(request: web.Request): raise web.HTTPServiceUnavailable() @routes.get(r"/slow") async def blocking_slow(request: web.Request): time.sleep(SLOW_HANDLER_DELAY_SECS * 1.1) return web.json_response({"data": True, "error": None}) @routes.get(r"/cancel") async def cancelled_task(request: web.Request): task: asyncio.Task = request.app.loop.create_task(asyncio.sleep(10)) task.cancel() # raise CancelledError @routes.get(r"/timeout/{secs}") async def time_out(request: web.Request): secs = float(request.match_info.get("secs", 0)) await asyncio.wait_for(asyncio.sleep(10 * secs), timeout=secs) # raises TimeOutError @routes.get(r"/delay/{secs}") async def delay_response(request: web.Request): secs = float(request.match_info.get("secs", 0)) await asyncio.sleep(secs) # non-blocking slow return web.json_response({"data": True, "error": None}) # ----- main = {"port": unused_tcp_port_factory(), "host": "localhost"} cfg = { "main": main, "rest": { "enabled": True, "version": api_version_prefix }, "diagnostics": { "enabled": True }, } app = create_safe_application(cfg) # activates some sub-modules assert setup_settings(app) setup_security(app) setup_rest(app) setup_diagnostics(app) settings: DiagnosticsSettings = app[APP_SETTINGS_KEY].WEBSERVER_DIAGNOSTICS assert settings.DIAGNOSTICS_MAX_AVG_LATENCY == 2.0 app.router.add_routes(routes) cli = event_loop.run_until_complete( aiohttp_client( app, server_kwargs={key: main[key] for key in ("host", "port")})) return cli