def bible( self, request: pytest.FixtureRequest, default_version: str, default_abbr: str, MockBible: type[Any], ) -> Any: name = cast(Callable[..., Any], cast(Any, request).function).__name__ data: dict[str, Any] if name == 'test_search': data = request.getfixturevalue('search_data') elif name == 'test_get_passage': data = request.getfixturevalue('passage_data') else: data = {} return MockBible( command='bib', name='The Bible', abbr=data.get('abbr', default_abbr), service='MyService', service_version=data.get('version', default_version), rtl=False, )
def testStorageAndHydraulicExports(self, project: _Project, request: _pt.FixtureRequest): helper = _Helper(project) helper.setup() # The following line is required otherwise QT will crash application = _qtw.QApplication([]) def quitApplication(): application.quit() request.addfinalizer(quitApplication) projectFolderPath = helper.actualProjectFolderPath self._exportHydraulic(projectFolderPath, _format="mfs") mfsDdckRelativePath = f"{project.projectName}_mfs.dck" helper.ensureFilesAreEqual(mfsDdckRelativePath, shallReplaceRandomizedFlowRates=True) self._exportHydraulic(projectFolderPath, _format="ddck") hydraulicDdckRelativePath = "ddck/hydraulic/hydraulic.ddck" helper.ensureFilesAreEqual(hydraulicDdckRelativePath, shallReplaceRandomizedFlowRates=False) storageTankNames = self._exportStorageTanksAndGetNames(projectFolderPath) for storageTankName in storageTankNames: ddckFileRelativePath = f"ddck/{storageTankName}/{storageTankName}.ddck" helper.ensureFilesAreEqual(ddckFileRelativePath, shallReplaceRandomizedFlowRates=False) ddcxFileRelativePath = f"ddck/{storageTankName}/{storageTankName}.ddcx" helper.ensureFilesAreEqual(ddcxFileRelativePath, shallReplaceRandomizedFlowRates=False)
def test_change_container_pass(happi_client: Client, item: str, target: str, request: pytest.FixtureRequest): i = request.getfixturevalue(item) t = request.getfixturevalue(target) kw = happi_client.change_container(i, t) for k in kw: assert i.post()[k] == kw[k]
def bokeh_server(request: pytest.FixtureRequest, log_file: IO[str]) -> str: bokeh_port: int = request.config.option.bokeh_port cmd = ["python", "-m", "bokeh", "serve"] argv = [f"--port={bokeh_port}"] bokeh_server_url = f"http://localhost:{bokeh_port}" env = os.environ.copy() env['BOKEH_MINIFIED'] = 'false' try: proc = subprocess.Popen(cmd + argv, env=env, stdout=log_file, stderr=log_file) except OSError: write(f"Failed to run: {' '.join(cmd + argv)}") sys.exit(1) else: # Add in the clean-up code def stop_bokeh_server() -> None: write("Shutting down bokeh-server ...") proc.kill() request.addfinalizer(stop_bokeh_server) def wait_until(func: Callable[[], Any], timeout: float = 5.0, interval: float = 0.01) -> bool: start = time.time() while True: if func(): return True if time.time() - start > timeout: return False time.sleep(interval) def wait_for_bokeh_server() -> bool: def helper() -> Any: if proc.returncode is not None: return True try: # type: ignore[unreachable] # XXX: typeshed bug, proc.returncode: int return requests.get(bokeh_server_url) except ConnectionError: return False return wait_until(helper) if not wait_for_bokeh_server(): write(f"Timeout when running: {' '.join(cmd + argv)}") sys.exit(1) if proc.returncode is not None: write(f"bokeh server exited with code {proc.returncode}") sys.exit(1) return bokeh_server_url # type: ignore[unreachable] # XXX: typeshed bug, proc.returncode: int
def test_setup_test_db_creates_db(request: FixtureRequest, db_dsn): server_dsn, dsn, db_name = db_dsn request.getfixturevalue("setup_test_db") with create_db_client(dsn) as db_client: assert len(db_client.query("SELECT File")) == 0 with create_db_client(server_dsn) as db_client: db_client.execute(f"DROP DATABASE {db_name};")
def projects_path(user_path: pathlib.Path, request: pytest.FixtureRequest) -> pathlib.Path: """User's local checkouts and clones. Emphemeral directory.""" dir = user_path / "projects" dir.mkdir(exist_ok=True) def clean() -> None: shutil.rmtree(dir) request.addfinalizer(clean) return dir
def remote_repos_path(user_path: pathlib.Path, request: pytest.FixtureRequest) -> pathlib.Path: """System's remote (file-based) repos to clone andpush to. Emphemeral directory.""" dir = user_path / "remote_repos" dir.mkdir(exist_ok=True) def clean() -> None: shutil.rmtree(dir) request.addfinalizer(clean) return dir
def test_recreates_db_and_applies_migration(request: FixtureRequest, db_dsn): server_dsn, dsn, db_name = db_dsn with create_db_client(server_dsn) as db_client: db_client.execute(f"CREATE DATABASE {db_name};") request.getfixturevalue("setup_test_db") with create_db_client(dsn) as db_client: assert len(db_client.query("SELECT File")) == 0 with create_db_client(server_dsn) as db_client: db_client.execute(f"DROP DATABASE {db_name};")
def screenshoter(browser: WebDriver, request: pytest.FixtureRequest): class Screenshoter: def save(self): if SCREENSHOTS_FOLDER is None: return assert browser.save_screenshot( f'{SCREENSHOTS_FOLDER}/{time.time_ns()}_{request.node.name}.png' ) instance = Screenshoter() request.addfinalizer(lambda: instance.save()) return instance
def db_client_or_tx(request: FixtureRequest): """ Yield either a `tx` or a `db_client` fixture depending on `pytest.mark.database` params. """ marker = request.node.get_closest_marker("database") if not marker: raise RuntimeError("Access to database without `database` marker!") if marker.kwargs.get("transaction", False): yield request.getfixturevalue("db_client") else: yield request.getfixturevalue("tx")
def test_file_path_and_url(request: pytest.FixtureRequest, file_server: SimpleWebServer) -> Tuple[str, str]: filename = request.function.__name__ + '.html' file_obj = request.fspath.dirpath().join(filename) file_path = file_obj.strpath url = file_path.replace('\\', '/') # Windows-proof def tear_down() -> None: if file_obj.isfile(): file_obj.remove() request.addfinalizer(tear_down) return file_path, file_server.where_is(url)
def _config(request: FixtureRequest): """Fixture that parametrizes the configuration used in the tests below.""" test_name = request.function.__name__ model_name: str = request.param # type: ignore model_type = ng.optimizers.registry[model_name] if model_name in NOT_WORKING: pytest.skip(reason=f"Model {model_name} is not supported.") tweaks = MODEL_NAMES[model_name] if model_type.no_parallelization: num_workers = 1 else: num_workers = 10 TestNevergradOptimizer.config["model_name"] = model_name TestNevergradOptimizer.config["num_workers"] = num_workers mark = tweaks.get(test_name, None) current_phase: TestPhase = request.getfixturevalue("phase") if (mark and test_name == "test_seed_rng_init" and request.getfixturevalue("phase").n_trials > 0 and mark in _deterministic_first_point.values()): # Remove the mark, because The algo always gives back the same first trial, regardless of # the seed. This means that since `test_seed_rng_init` expects different seeds to give # different results, the test will fail if we're at the first phase, but pass in other # phases. mark = None if model_name == "MultiScaleCMA" and test_name == "test_state_dict": # NOTE: Only fails at the optimization phase. if current_phase.n_trials == 0: mark = None if mark == "skip": pytest.skip(reason="Skipping test") elif mark: request.node.add_marker(mark) start = TestNevergradOptimizer.max_trials if model_name == "MultiScaleCMA" and test_name == "test_state_dict": TestNevergradOptimizer.max_trials = 20 yield TestNevergradOptimizer.max_trials = start
def test_recreates_db(request: FixtureRequest, db_dsn): server_dsn, dsn, db_name = db_dsn with create_db_client(server_dsn) as db_client: db_client.execute(f"CREATE DATABASE {db_name};") request.getfixturevalue("setup_test_db") with create_db_client(dsn) as db_client: with pytest.raises(edgedb.InvalidReferenceError) as excinfo: assert len(db_client.query("SELECT File")) == 0 assert str(excinfo.value) == "object type or alias 'default::File' does not exist" with create_db_client(server_dsn) as db_client: db_client.execute(f"DROP DATABASE {db_name};")
def possibly_skip_test(request: pytest.FixtureRequest, info: dict[str, Any]) -> dict[str, Any]: if "segfault" in info: pytest.skip(f"known segfault: {info['segfault']}") if "xfail" in info: reason = info["xfail"] if request.config.option.run_xfail: request.applymarker( pytest.mark.xfail( run=False, reason=f"known failure: {reason}", )) else: pytest.xfail(f"known failure: {reason}") return info
def postgresql_factory(request: FixtureRequest) -> Iterator[connection]: """ Fixture factory for PostgreSQL. :param request: fixture request object :returns: postgresql client """ check_for_psycopg() proc_fixture: Union[PostgreSQLExecutor, NoopExecutor] = request.getfixturevalue( process_fixture_name) pg_host = proc_fixture.host pg_port = proc_fixture.port pg_user = proc_fixture.user pg_password = proc_fixture.password pg_options = proc_fixture.options pg_db = dbname or proc_fixture.dbname pg_load = load or [] with DatabaseJanitor(pg_user, pg_host, pg_port, pg_db, proc_fixture.version, pg_password, isolation_level) as janitor: db_connection: connection = psycopg.connect( dbname=pg_db, user=pg_user, password=pg_password, host=pg_host, port=pg_port, options=pg_options, ) for load_element in pg_load: janitor.load(load_element) yield db_connection db_connection.close()
def redis_proc_fixture(request: FixtureRequest, tmp_path_factory: TempPathFactory): """ Fixture for pytest-redis. #. Get configs. #. Run redis process. #. Stop redis process after tests. :param request: fixture request object :param tmpdir_factory: :rtype: pytest_redis.executors.TCPExecutor :returns: tcp executor """ config = get_config(request) redis_exec = executable or config["exec"] rdbcompression = config[ "compression"] if compression is None else compression rdbchecksum = config["rdbchecksum"] if checksum is None else checksum if datadir: redis_datadir = Path(datadir) elif config["datadir"]: redis_datadir = Path(config["datadir"]) else: redis_datadir = tmp_path_factory.mktemp( f"pytest-redis-{request.fixturename}") redis_executor = RedisExecutor( executable=redis_exec, databases=db_count or config["db_count"], redis_timeout=timeout or config["timeout"], loglevel=loglevel or config["loglevel"], rdbcompression=rdbcompression, rdbchecksum=rdbchecksum, syslog_enabled=syslog or config["syslog"], save=save or config["save"], host=host or config["host"], port=get_port(port) or get_port(config["port"]), timeout=60, datadir=redis_datadir, ) redis_executor.start() request.addfinalizer(redis_executor.stop) return redis_executor
def output_file_url(request: pytest.FixtureRequest, file_server: SimpleWebServer) -> str: from bokeh.io import output_file filename = request.function.__name__ + '.html' file_obj = request.fspath.dirpath().join(filename) file_path = file_obj.strpath url = file_path.replace('\\', '/') # Windows-proof output_file(file_path, mode='inline') def tear_down() -> None: if file_obj.isfile(): file_obj.remove() request.addfinalizer(tear_down) return file_server.where_is(url)
def _push_request_context(request: pytest.FixtureRequest): """During tests execution request context has been pushed, e.g. `url_for`, `session`, etc. can be used in tests as is:: def test_app(app, client): assert client.get(url_for('myview')).status_code == 200 """ if "app" not in request.fixturenames: return app = request.getfixturevalue("app") ctx = app.test_request_context() ctx.push() def teardown(): ctx.pop() request.addfinalizer(teardown)
async def session_context( request: pytest.FixtureRequest, event_loop: AbstractEventLoop, ) -> contextvars.Context: if "nosession" not in request.keywords: await initialize_connection("spellbot-test", use_transaction=True) test_session = db_session_maker() DatabaseSession.set(test_session) # type: ignore BlockFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore ChannelFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore ConfigFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore GameFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore GuildAwardFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore GuildFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore PlayFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore UserAwardFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore UserFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore VerifyFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore WatchFactory._meta.sqlalchemy_session = DatabaseSession # type: ignore def cleanup_session(): async def finalizer() -> None: try: await rollback_transaction() except Exception: # pragma: no cover pass event_loop.run_until_complete(finalizer()) request.addfinalizer(cleanup_session) context = contextvars.copy_context() def cleanup_context(): nonlocal context for c in context: c.set(context[c]) request.addfinalizer(cleanup_context) return context
def reports_test_dir(request: pytest.FixtureRequest) -> str: """Returns the relative path to the test reports directory. Also, adds a finaliser function to remove the test reports directory and its contents once the test has completed. Args: request (pytest.FixtureRequest): A pytest fixture providing information of the requesting test function. Returns: str: The relative path to the test reports directory. """ # Declare relative path to the test reports directory # to be created in the relevant tests reports_test_dir_path = "./src/test/reports" # Add finalizer function to remove the test reports directory # and its contents once the test has finished def remove_reports_dir_contents(): shutil.rmtree(reports_test_dir_path) # Add finalizer function request.addfinalizer(remove_reports_dir_contents) return reports_test_dir_path
def update_parameterized(cls, request: pytest.FixtureRequest, config: BaseConfig): """Update the given configuration object with parameterized values if the key is present""" config_type = config.__class__.__name__ parameterized_keys = cls._get_parameterized_keys(request) for fixture_name in parameterized_keys: with suppress(pytest.FixtureLookupError, AttributeError): if hasattr(config, fixture_name): value = request.getfixturevalue(fixture_name) config.set_value(fixture_name, value) log.debug( f"{config_type}.{fixture_name} value updated from parameterized value to {value}" ) else: raise AttributeError( f"No attribute name {fixture_name} in {config_type} object type" )
async def flush_db_if_needed(request: FixtureRequest): """Flush database after each tests.""" try: yield finally: marker = request.node.get_closest_marker("database") if not marker: return if not marker.kwargs.get("transaction", False): return session_db_client: DBClient = request.getfixturevalue( "session_db_client") await session_db_client.execute(""" DELETE Account; DELETE File; DELETE MediaType; DELETE Namespace; DELETE User; """)
def test_change_container_fail(happi_client: Client, item: str, target: str, request: pytest.FixtureRequest): i = request.getfixturevalue(item) t = request.getfixturevalue(target) with pytest.raises(TransferError): happi_client.change_container(i, t)
def file_server(request: pytest.FixtureRequest) -> SimpleWebServer: server = SimpleWebServer() server.start() request.addfinalizer(server.stop) return server
def device(request: pytest.FixtureRequest) -> DysonDevice: with patch(f"{MODULE}._async_get_platforms", return_value=["sensor"]): yield request.param()
async def recorder( request: pytest.FixtureRequest, ) -> typing.Optional[RecorderFixture]: is_unittest_class = request.cls is not None marker = request.node.get_closest_marker("recorder") if not is_unittest_class and marker is None: return None if is_unittest_class: cassette_library_dir = os.path.join( CASSETTE_LIBRARY_DIR_BASE, request.cls.__name__, request.node.name, ) else: cassette_library_dir = os.path.join( CASSETTE_LIBRARY_DIR_BASE, request.node.module.__name__.replace( "mergify_engine.tests.functional.", "").replace(".", "/"), request.node.name, ) # Recording stuffs if RECORD: if os.path.exists(cassette_library_dir): shutil.rmtree(cassette_library_dir) os.makedirs(cassette_library_dir) recorder = vcr.VCR( cassette_library_dir=cassette_library_dir, record_mode="all" if RECORD else "none", match_on=["method", "uri"], ignore_localhost=True, filter_headers=[ ("Authorization", "<TOKEN>"), ("X-Hub-Signature", "<SIGNATURE>"), ("User-Agent", None), ("Accept-Encoding", None), ("Connection", None), ], before_record_response=pyvcr_response_filter, before_record_request=pyvcr_request_filter, ) if RECORD: github.CachedToken.STORAGE = {} else: # Never expire token during replay patcher = mock.patch.object(github_app, "get_or_create_jwt", return_value="<TOKEN>") patcher.start() request.addfinalizer(patcher.stop) patcher = mock.patch.object( github.GithubAppInstallationAuth, "get_access_token", return_value="<TOKEN>", ) patcher.start() request.addfinalizer(patcher.stop) # Let's start recording cassette = recorder.use_cassette("http.json") cassette.__enter__() request.addfinalizer(cassette.__exit__) record_config_file = os.path.join(cassette_library_dir, "config.json") if RECORD: with open(record_config_file, "w") as f: f.write( json.dumps( RecordConfigType({ "organization_id": config.TESTING_ORGANIZATION_ID, "organization_name": config.TESTING_ORGANIZATION_NAME, "repository_id": config.TESTING_REPOSITORY_ID, "repository_name": github_types.GitHubRepositoryName( config.TESTING_REPOSITORY_NAME), "branch_prefix": datetime.datetime.utcnow().strftime("%Y%m%d%H%M%S"), }))) with open(record_config_file, "r") as f: return RecorderFixture( typing.cast(RecordConfigType, json.loads(f.read())), recorder)
def test_automatic_mock_event_emission( server_url_fixture: str, mock_client_wait_timeout: float, mock_client_wait_interval: float, client: socketio.Client, request: pytest.FixtureRequest, ): server_url: str = request.getfixturevalue(server_url_fixture) new_message_event = "new message" new_message_mock_ack = Mock() @client.on(new_message_event) def _new_message_handler(data): jsonschema.validate(data, { "username": { "type": "string" }, "message": { "type": "string" } }) # Assert that message is of sentence format: assert data["message"].endswith(".") assert " " in data["message"] # Assert that username is a first name: assert data["username"].istitle() new_message_mock_ack(new_message_event) typing_event = "typing" typing_mock_ack = Mock() @client.on(typing_event) def _typing_handler(data): jsonschema.validate(data, {"username": {"type": "string"}}) # Assert that username is a first name: assert data["username"].istitle() typing_mock_ack(typing_event) user_joined_event = "user joined" user_joined_mock_ack = Mock() @client.on(user_joined_event) def _user_joined_handler(data): jsonschema.validate(data, { "username": { "type": "string" }, "numUsers": { "type": "integer" } }) # Assert that username is a first name: assert data["username"].istitle() user_joined_mock_ack(user_joined_event) client.connect(server_url, wait_timeout=mock_client_wait_timeout) # Wait for all messages to arrive: client.sleep(mock_client_wait_interval) new_message_mock_ack.assert_called_with(new_message_event) typing_mock_ack.assert_called_with(typing_event) user_joined_mock_ack.assert_called_with(user_joined_event)
async def dashboard(redis_cache: redis_utils.RedisCache, request: pytest.FixtureRequest) -> DashboardFixture: is_unittest_class = request.cls is not None subscription_active = False marker = request.node.get_closest_marker("subscription") if marker: subscription_active = marker.args[0] elif is_unittest_class: subscription_active = request.cls.SUBSCRIPTION_ACTIVE api_key_admin = "a" * 64 sub = subscription.Subscription( redis_cache, config.TESTING_ORGANIZATION_ID, "You're not nice", frozenset( getattr(subscription.Features, f) for f in subscription.Features.__members__) if subscription_active else frozenset([subscription.Features.PUBLIC_REPOSITORY]), ) await sub._save_subscription_to_cache() user_tokens = user_tokens_mod.UserTokens( redis_cache, config.TESTING_ORGANIZATION_ID, [ { "id": github_types.GitHubAccountIdType(config.ORG_ADMIN_ID), "login": github_types.GitHubLogin("mergify-test1"), "oauth_access_token": config.ORG_ADMIN_GITHUB_APP_OAUTH_TOKEN, "name": None, "email": None, }, { "id": github_types.GitHubAccountIdType(config.ORG_USER_ID), "login": github_types.GitHubLogin("mergify-test4"), "oauth_access_token": config.ORG_USER_PERSONAL_TOKEN, "name": None, "email": None, }, ], ) await typing.cast(user_tokens_mod.UserTokensSaas, user_tokens).save_to_cache() real_get_subscription = subscription.Subscription.get_subscription async def fake_retrieve_subscription_from_db(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return sub return subscription.Subscription( redis_cache, owner_id, "We're just testing", set(subscription.Features.PUBLIC_REPOSITORY), ) async def fake_subscription(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return await real_get_subscription(redis_cache, owner_id) return subscription.Subscription( redis_cache, owner_id, "We're just testing", set(subscription.Features.PUBLIC_REPOSITORY), ) patcher = mock.patch( "mergify_engine.dashboard.subscription.Subscription._retrieve_subscription_from_db", side_effect=fake_retrieve_subscription_from_db, ) patcher.start() request.addfinalizer(patcher.stop) patcher = mock.patch( "mergify_engine.dashboard.subscription.Subscription.get_subscription", side_effect=fake_subscription, ) patcher.start() request.addfinalizer(patcher.stop) async def fake_retrieve_user_tokens_from_db(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return user_tokens return user_tokens_mod.UserTokens(redis_cache, owner_id, {}) real_get_user_tokens = user_tokens_mod.UserTokens.get async def fake_user_tokens(redis_cache, owner_id): if owner_id == config.TESTING_ORGANIZATION_ID: return await real_get_user_tokens(redis_cache, owner_id) return user_tokens_mod.UserTokens(redis_cache, owner_id, {}) patcher = mock.patch( "mergify_engine.dashboard.user_tokens.UserTokensSaas._retrieve_from_db", side_effect=fake_retrieve_user_tokens_from_db, ) patcher.start() request.addfinalizer(patcher.stop) patcher = mock.patch( "mergify_engine.dashboard.user_tokens.UserTokensSaas.get", side_effect=fake_user_tokens, ) patcher.start() request.addfinalizer(patcher.stop) async def fake_application_get(redis_cache, api_access_key, api_secret_key, account_scope): if (api_access_key == api_key_admin[:32] and api_secret_key == api_key_admin[32:]): return application_mod.Application( redis_cache, 123, "testing application", api_access_key, api_secret_key, account_scope={ "id": config.TESTING_ORGANIZATION_ID, "login": config.TESTING_ORGANIZATION_NAME, }, ) raise application_mod.ApplicationUserNotFound() patcher = mock.patch( "mergify_engine.dashboard.application.ApplicationSaas.get", side_effect=fake_application_get, ) patcher.start() request.addfinalizer(patcher.stop) return DashboardFixture( api_key_admin, sub, user_tokens, )
def cfg_all(request: FixtureRequest): return request.getfixturevalue(request.param)
def app(request: pytest.FixtureRequest) -> "SecurityFixture": app = SecurityFixture(__name__) app.response_class = Response app.debug = True app.config["SECRET_KEY"] = "secret" app.config["TESTING"] = True app.config["LOGIN_DISABLED"] = False app.config["WTF_CSRF_ENABLED"] = False # Our test emails/domain isn't necessarily valid app.config["SECURITY_EMAIL_VALIDATOR_ARGS"] = {"check_deliverability": False} app.config["SECURITY_TWO_FACTOR_SECRET"] = { "1": "TjQ9Qa31VOrfEzuPy4VHQWPCTmRzCnFzMKLxXYiZu9B" } app.config["SECURITY_SMS_SERVICE"] = "test" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False app.config["SECURITY_PASSWORD_SALT"] = "salty" # Make this plaintext for most tests - reduces unit test time by 50% app.config["SECURITY_PASSWORD_HASH"] = "plaintext" # Make this hex_md5 for token tests app.config["SECURITY_HASHING_SCHEMES"] = ["hex_md5"] app.config["SECURITY_DEPRECATED_HASHING_SCHEMES"] = [] for opt in [ "changeable", "recoverable", "registerable", "trackable", "passwordless", "confirmable", "two_factor", "unified_signin", "webauthn", ]: app.config["SECURITY_" + opt.upper()] = opt in request.keywords pytest_major = int(pytest.__version__.split(".")[0]) if pytest_major >= 4: marker_getter = request.node.get_closest_marker else: marker_getter = request.keywords.get settings = marker_getter("settings") if settings is not None: for key, value in settings.kwargs.items(): app.config["SECURITY_" + key.upper()] = value app.mail = Mail(app) # type: ignore app.json_encoder = JSONEncoder # use babel marker to signify tests that need babel extension. babel = marker_getter("babel") if babel: if NO_BABEL: raise pytest.skip("Requires Babel") Babel(app) @app.route("/") def index(): return render_template("index.html", content="Home Page") @app.route("/profile") @auth_required() def profile(): if hasattr(app, "security"): if app.security._want_json(flask_request): return jsonify(message="profile") return render_template("index.html", content="Profile Page") @app.route("/post_login") @login_required def post_login(): return render_template("index.html", content="Post Login") @app.route("/http") @http_auth_required def http(): return "HTTP Authentication" @app.route("/http_admin_required") @http_auth_required @permissions_required("admin") def http_admin_required(): assert get_request_attr("fs_authn_via") == "basic" return "HTTP Authentication" @app.route("/http_custom_realm") @http_auth_required("My Realm") def http_custom_realm(): assert get_request_attr("fs_authn_via") == "basic" return render_template("index.html", content="HTTP Authentication") @app.route("/token", methods=["GET", "POST"]) @auth_token_required def token(): assert get_request_attr("fs_authn_via") == "token" return render_template("index.html", content="Token Authentication") @app.route("/multi_auth") @auth_required("session", "token", "basic") def multi_auth(): return render_template("index.html", content="Session, Token, Basic auth") @app.route("/post_logout") def post_logout(): return render_template("index.html", content="Post Logout") @app.route("/post_register") def post_register(): return render_template("index.html", content="Post Register") @app.route("/post_confirm") def post_confirm(): return render_template("index.html", content="Post Confirm") @app.route("/admin") @roles_required("admin") def admin(): assert get_request_attr("fs_authn_via") == "session" return render_template("index.html", content="Admin Page") @app.route("/admin_and_editor") @roles_required("admin", "editor") def admin_and_editor(): return render_template("index.html", content="Admin and Editor Page") @app.route("/admin_or_editor") @roles_accepted("admin", "editor") def admin_or_editor(): return render_template("index.html", content="Admin or Editor Page") @app.route("/simple") @roles_accepted("simple") def simple(): return render_template("index.html", content="SimplePage") @app.route("/admin_perm") @permissions_accepted("full-write", "super") def admin_perm(): return render_template( "index.html", content="Admin Page with full-write or super" ) @app.route("/admin_perm_required") @permissions_required("full-write", "super") def admin_perm_required(): return render_template("index.html", content="Admin Page required") @app.route("/page1") def page_1(): return "Page 1" @app.route("/json", methods=["GET", "POST"]) def echo_json(): return jsonify(flask_request.get_json()) @app.route("/unauthz", methods=["GET", "POST"]) def unauthz(): return render_template("index.html", content="Unauthorized") @app.route("/fresh", methods=["GET", "POST"]) @auth_required(within=60) def fresh(): if app.security._want_json(flask_request): return jsonify(title="Fresh Only") else: return render_template("index.html", content="Fresh Only") def revert_forms(): # Some forms/tests have dynamic fields - be sure to revert them. if hasattr(app, "security"): if hasattr(app.security.login_form, "email"): del app.security.login_form.email if hasattr(app.security.register_form, "username"): del app.security.register_form.username if hasattr(app.security.confirm_register_form, "username"): del app.security.confirm_register_form.username request.addfinalizer(revert_forms) return app