def _create_clean_database(config):
root_client = pymongo.MongoClient(config.host, config.port)
root_db = root_client[config.root_database]
# Create a collection called `pytestMockResourceDbs' in the admin tab if not already created.
db_collection = root_db["pytestMockResourcesDbs"]
# Create a Document in the `pytestMockResourcesDbs` collection.
result = db_collection.insert_one({})
# Create a database where the name is equal to that ID.
db_id = str(result.inserted_id)
new_database = root_client[db_id]
# Create a user as that databases owner
password = "******" # nosec
new_database.command("createUser", db_id, pwd=password, roles=["dbOwner"])
# pass back an authenticated db connection
limited_client = pymongo.MongoClient(
config.host, config.port, username=db_id, password=password, authSource=db_id
)
limited_db = limited_client[db_id]
assign_fixture_credentials(
limited_db,
drivername="mongodb",
host=config.host,
port=config.port,
database=db_id,
username=db_id,
password="******",
)
return limited_db
def _():
# XXX: Ideally we eventually make use of the shared memory cache to enable connecting by
# credentials with sqlite.
# database_name = "file:{}?mode=memory&cache=shared".format(next(_database_names))
database_name = ""
raw_engine = create_engine(
"sqlite+pmrsqlite:///{}".format(database_name))
# This *must* happen before the connection occurs (implicitly in `EngineManager`).
event.listen(raw_engine, "connect", enable_foreign_key_checks)
engine_manager = EngineManager(raw_engine,
ordered_actions,
tables=tables)
for engine in engine_manager.manage(session=session):
with filter_sqlalchemy_warnings(
decimal_warnings_enabled=(not decimal_warnings)):
assign_fixture_credentials(
raw_engine,
drivername="sqlite+pmrsqlite",
host="",
port=None,
database=database_name,
username="",
password="",
)
yield engine
event.remove(raw_engine, "connect", enable_foreign_key_checks)
def _(request, _redis_container, pmr_redis_config):
database_number = 0
if hasattr(request.config, "workerinput"):
worker_input = request.config.workerinput
worker_id = worker_input["workerid"] # For example "gw0".
database_number = int(worker_id[2:])
if database_number >= 16:
raise ValueError(
"The redis fixture currently only supports up to 16 parallel executions"
)
db = redis.Redis(host=pmr_redis_config.host, port=pmr_redis_config.port, db=database_number)
db.flushdb()
assign_fixture_credentials(
db,
drivername="redis",
host=pmr_redis_config.host,
port=pmr_redis_config.port,
database=database_number,
username=None,
password=None,
)
return db
def _(_redis_container):
db = redis.Redis(host=get_docker_host(), port=redis_config["port"])
db.flushall()
assign_fixture_credentials(
db,
drivername="redis",
host=get_docker_host(),
port=redis_config["port"],
database=None,
username=None,
password=None,
)
return db
def _(_mysql_container):
database_name = _create_clean_database()
engine = get_sqlalchemy_engine(database_name)
assign_fixture_credentials(
engine,
drivername="mysql+pymysql",
host=get_docker_host(),
port=config["port"],
database=database_name,
username="******",
password="******",
)
engine_manager = EngineManager(engine, ordered_actions, tables=tables)
for engine in engine_manager.manage(session=session):
yield engine
def _(_mysql_container, pmr_mysql_config):
database_name = _create_clean_database(pmr_mysql_config)
engine = get_sqlalchemy_engine(pmr_mysql_config, database_name)
assign_fixture_credentials(
engine,
drivername="mysql+pymysql",
host=pmr_mysql_config.host,
port=pmr_mysql_config.port,
database=database_name,
username=pmr_mysql_config.username,
password=pmr_mysql_config.password,
)
engine_manager = EngineManager(engine, ordered_actions, tables=tables)
for engine in engine_manager.manage(session=session):
yield engine
def _(_postgres_container):
database_name = _create_clean_database()
engine = get_sqlalchemy_engine(database_name)
assign_fixture_credentials(
engine,
drivername="postgresql+psycopg2",
host=get_docker_host(),
port=config["port"],
database=database_name,
username="******",
password="******",
)
engine_manager = EngineManager(engine,
ordered_actions,
tables=tables,
default_schema="public")
for engine in engine_manager.manage(session=session):
yield engine
def _(_redshift_container, pmr_postgres_config):
database_name = produce_clean_database(pmr_postgres_config)
engine = get_sqlalchemy_engine(pmr_postgres_config, database_name)
assign_fixture_credentials(
engine,
drivername="postgresql+psycopg2",
host=pmr_postgres_config.host,
port=pmr_postgres_config.port,
database=database_name,
username=pmr_postgres_config.username,
password=pmr_postgres_config.password,
)
sqlalchemy.register_redshift_behavior(engine)
with psycopg2.patch_connect(pmr_postgres_config, database_name):
engine_manager = EngineManager(
engine, ordered_actions, tables=tables, default_schema="public"
)
yield from engine_manager.manage(session=session)
def create_engine_manager(pmr_postgres_config,
ordered_actions,
tables,
createdb_template="template1"):
database_name = produce_clean_database(pmr_postgres_config,
createdb_template=createdb_template)
engine = get_sqlalchemy_engine(pmr_postgres_config, database_name)
assign_fixture_credentials(
engine,
drivername="postgresql+psycopg2",
host=pmr_postgres_config.host,
port=pmr_postgres_config.port,
database=database_name,
username=pmr_postgres_config.username,
password=pmr_postgres_config.password,
)
return EngineManager(engine,
ordered_actions,
tables=tables,
default_schema="public")
def _create_clean_database():
from pymongo import MongoClient
client = get_pymongo_client()
db = client[config["root_database"]]
# Create a collection called `pytestMockResourceDbs' in the admin tab if it hasnt already been
# created.
db_collection = db["pytestMockResourcesDbs"]
# create a Document in the `pytestMockResourcesDbs` collection:
result = db_collection.insert_one({})
db_id = str(result.inserted_id)
# Create a database where the name is equal to that ID:
create_db = client[db_id]
# Create a user as that databases owner
create_db.command("createUser", db_id, pwd="password",
roles=["dbOwner"]) # nosec
# pass back an authenticated db connection
limited_client = MongoClient(get_docker_host(), config["port"])
db = limited_client[db_id]
db.authenticate(db_id, "password")
db.config = {"username": db_id, "password": "******", "database": db_id}
assign_fixture_credentials(
db,
drivername="mongodb",
host=get_docker_host(),
port=config["port"],
database=db_id,
username=db_id,
password="******",
)
return db