AnonymousSpottedToad/securityPatternsRecovery / codebase /repos /python /bluesky_tiled /tests /utils.py
| import contextlib | |
| import sqlite3 | |
| import tempfile | |
| import threading | |
| import time | |
| import uuid | |
| from enum import IntEnum | |
| from importlib import resources | |
| from pathlib import Path | |
| import httpx | |
| import pytest | |
| import uvicorn | |
| from sqlalchemy import text | |
| from sqlalchemy.engine import Connection | |
| from sqlalchemy.ext.asyncio import create_async_engine | |
| from tiled.client import context | |
| from tiled.client.base import BaseClient | |
| from tiled.utils import ensure_specified_sql_driver | |
| def fail_with_status_code(status_code): | |
| with pytest.raises(httpx.HTTPStatusError) as info: | |
| yield info | |
| assert info.value.response.status_code == status_code | |
| async def temp_postgres(uri): | |
| if uri.endswith("/"): | |
| uri = uri[:-1] | |
| # Create a fresh database. | |
| engine = create_async_engine(ensure_specified_sql_driver(uri)) | |
| database_name = f"tiled_test_disposable_{uuid.uuid4().hex}" | |
| async with engine.connect() as connection: | |
| # close the automatically-started transaction | |
| await connection.execute(text("COMMIT")) | |
| await connection.execute(text(f"CREATE DATABASE {database_name};")) | |
| await connection.commit() | |
| yield f"{uri}/{database_name}" | |
| # Drop the database | |
| async with engine.connect() as connection: | |
| await connection.execute(text("COMMIT")) | |
| # Terminate any lingering sessions first so DROP doesn't fail | |
| await connection.execute( | |
| text( | |
| "SELECT pg_terminate_backend(pid) FROM pg_stat_activity " | |
| f"WHERE datname = '{database_name}' AND pid <> pg_backend_pid();" | |
| ) | |
| ) | |
| await connection.execute(text(f"DROP DATABASE {database_name};")) | |
| await connection.commit() | |
| def enter_username_password(username, password): | |
| """ | |
| Override getpass, when prompt_for_credentials with username only | |
| used like: | |
| >>> with enter_username_password(...): | |
| ... # Run code that calls prompt_for_credentials and subsequently getpass.getpass(). | |
| """ | |
| original_username_input = context.username_input | |
| context.username_input = lambda: username | |
| original_password_input = context.password_input | |
| context.password_input = lambda: password | |
| try: | |
| # Ensures that raise in calling routine does not prevent context from being exited. | |
| yield | |
| finally: | |
| context.username_input = original_username_input | |
| context.password_input = original_password_input | |
| class URL_LIMITS(IntEnum): | |
| HUGE = 80_000 | |
| DEFAULT = BaseClient.URL_CHARACTER_LIMIT | |
| TINY = 10 | |
| def sqlite_from_dump(filename): | |
| """Create a SQLite db in a temporary directory, loading a SQL script. | |
| SQL script should be given as a filename, assumed to be in tests/sql/ | |
| """ | |
| with tempfile.TemporaryDirectory() as directory: | |
| database_path = Path(directory, "catalog.db") | |
| conn = sqlite3.connect(database_path) | |
| ref = resources.files("tests.sql") / filename | |
| with resources.as_file(ref) as path: | |
| conn.executescript(path.read_text()) | |
| conn.close() | |
| yield database_path | |
| class Server(uvicorn.Server): | |
| # https://github.com/encode/uvicorn/discussions/1103#discussioncomment-941726 | |
| def install_signal_handlers(self): | |
| pass | |
| def run_in_thread(self): | |
| thread = threading.Thread(target=self.run) | |
| thread.start() | |
| try: | |
| # Wait for server to start up, or raise TimeoutError. | |
| for _ in range(100): | |
| time.sleep(0.1) | |
| if self.started: | |
| break | |
| else: | |
| raise TimeoutError("Server did not start in 10 seconds.") | |
| host, port = self.servers[0].sockets[0].getsockname() | |
| yield f"http://{host}:{port}" | |
| finally: | |
| self.should_exit = True | |
| thread.join() | |
| def sql_table_exists(conn: Connection, dialect: str, table_name: str) -> bool: | |
| """Check if a table exists in the SQLite database.""" | |
| # Use a dialect-specific query and parameter style | |
| if dialect == "sqlite": | |
| query = f""" | |
| SELECT name FROM sqlite_master | |
| WHERE type='table' AND name='{table_name}'; | |
| """ | |
| elif dialect == "duckdb": | |
| query = f""" | |
| SELECT table_name FROM information_schema.tables | |
| WHERE table_schema = 'main' AND table_name = '{table_name}'; | |
| """ | |
| elif dialect == "postgresql": | |
| query = f""" | |
| SELECT tablename FROM pg_catalog.pg_tables | |
| WHERE schemaname = 'public' AND tablename = '{table_name}' | |
| """ | |
| # NOTE: no trailing semicolon in PostgreSQL query as it is run as a COPY | |
| else: | |
| raise ValueError(f"Unsupported database dialect: {dialect}") | |
| with conn.cursor() as cursor: | |
| cursor.execute(query) | |
| return cursor.fetchone() is not None | |
Xet Storage Details
- Size:
- 5 kB
- Xet hash:
- 7832cf665981b212f2fdc3975911462531d5c9c970c41ab30de66239074f8ecf
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.