from pytest_postgresql import factories
DE_DB_HOST = '127.0.0.1'
DE_DB_USER = '******'
DE_DB_PASS = None
DE_DB_NAME = 'decisionengine'
DE_SCHEMA = [
os.path.dirname(os.path.abspath(__file__)) + "/../postgresql.sql",
]
# DE_DB_PORT assigned at random
PG_PROG = factories.postgresql_proc(user=DE_DB_USER,
password=DE_DB_PASS,
host=DE_DB_HOST,
port=None)
DE_DB = factories.postgresql('PG_PROG', db_name=DE_DB_NAME, load=DE_SCHEMA)
@pytest.fixture
def mock_data_block():
'''
This fixture replaces the standard datablock implementation.
The current DataBlock implementation does not own any data
products but forwards them immediately to a backend datasource.
The only implemented datasource requires Postgres, which is
overkill when needing to test simple data-product communication
between modules.
This mock datablock class directly owns the data products, thus
avoiding the need for a datasource backend. It is anticipated
)
SELECT * FROM employees_cte
"""
ALL = {"postgres", "sqlite"}
DATABASE = os.environ["DB"]
IS_POSTGRES = DATABASE == "postgres"
IS_SQLITE = DATABASE == "sqlite"
# Travis has only PostgreSQL 9.6
if IS_POSTGRES and "TRAVIS" in os.environ:
from pytest_postgresql import factories
postgresql_proc = factories.postgresql_proc(
executable="/usr/lib/postgresql/9.6/bin/pg_ctl")
postgresql = factories.postgresql("postgresql_proc")
def is_search_path_fixed(connection):
"""Check if a security issue with `search_path` is fixed in the current PG version.
Ref: CVE-2018-1058.
"""
version = connection.server_version
return (version >= 100003 or 90608 <= version < 100000
or 90512 <= version < 90600 or 90417 <= version < 90500
or 90322 <= version < 90400)
@pytest.fixture
def dbname(tmpdir):
import os
import pytest
import shutil
import mirakuru
from elasticsearch import Elasticsearch
from pytest_postgresql import factories
pgsql_proc = factories.postgresql_proc(executable='/usr/bin/pg_ctl',
host='localhost',
port=45678,
user='******')
pgsql_db = factories.postgresql('pgsql_proc', db='jslcrud_tests')
@pytest.fixture(scope='session')
def es_proc(request):
port = 9085
home_dir = '/tmp/elasticsearch_%s' % port
os.environ['ES_HOME'] = home_dir
command = [
os.environ['ELASTICSEARCH_EXECUTABLE'], '-p',
'/tmp/elasticsearch.%s.pid' % port, '-E',
'http.port=%s' % port, '-E',
'default.path.logs=/tmp/elasticsearch_%s_logs' % port, '-E',
'cluster.name=elasticsearch_cluster_%s' % port, '-E',
"network.publish_host='127.0.0.1'", '-E', 'index.store.type=mmapfs'
]
es_proc = mirakuru.HTTPExecutor(command,
shell=True,
url='http://127.0.0.1:%s' % port)
es_proc.start()
f.write(chunk)
# extract the tarball
t = tarfile.open(tarball, "r")
t.extractall(path=cache_dir)
# server_root should be created by extraction
assert os.path.isdir(server_root)
return server_root
_php_ini = os.path.join(os.path.dirname(__file__), "../../misc/php.ini")
mw_nginx_proc = factories.nginx_php_proc(
"mw_server_root", php_fpm_params="--php-ini {}".format(_php_ini))
# direct connection to MediaWiki's database
mwpg_conn = postgresql("postgresql_proc", db_name=_mw_db_name)
class MediaWikiFixtureInstance:
def __init__(self, mw_nginx_proc, postgresql_proc):
self._mw_nginx_proc = mw_nginx_proc
self._postgresql_proc = postgresql_proc
# trivial aliases, usable also in tests
self.hostname = mw_nginx_proc.host
self.port = mw_nginx_proc.port
# always write the config to reflect its possible updates
self._init_local_settings()
# init the database and users
# linux
return find_pg_ctl(f'/usr/lib/postgresql/{ver}/')
TEST_SQL_DIR = os.path.dirname(os.path.abspath(__file__)) + '/test_sql/'
# pylint:disable=invalid-name
postgresql95 = factories.postgresql_proc(create_version(ver='9.5'), port=None)
postgresql96 = factories.postgresql_proc(create_version(ver='9.6'), port=None)
postgresql10 = factories.postgresql_proc(create_version(ver='10'), port=None)
postgresql11 = factories.postgresql_proc(create_version(ver='11'), port=None)
postgresql12 = factories.postgresql_proc(create_version(ver='12'), port=None)
postgresql13 = factories.postgresql_proc(create_version(ver='13'), port=None)
postgresql_proc2 = factories.postgresql_proc(port=9876)
postgres10 = factories.postgresql('postgresql10')
postgresql2 = factories.postgresql('postgresql_proc2', db_name='test-db')
postgresql_load_1 = factories.postgresql('postgresql_proc2',
db_name='test-db',
load=[
TEST_SQL_DIR + 'test.sql',
])
postgresql_load_2 = factories.postgresql(
'postgresql_proc2',
db_name='test-db',
load=[TEST_SQL_DIR + 'test.sql', TEST_SQL_DIR + 'test2.sql'])
postgresql_rand_proc = factories.postgresql_proc(port=None)
postgresql_rand = factories.postgresql('postgresql_rand_proc')
postgresql_max_conns_proc = factories.postgresql_proc(postgres_options='-N 11')
def test_postgresql_proc(request, postgres):
"""Test different postgresql versions."""
postgresql_proc = request.getfixturevalue(postgres)
assert postgresql_proc.running() is True
def test_main_postgres(postgresql):
"""Check main postgresql fixture."""
cur = postgresql.cursor()
cur.execute(query)
postgresql.commit()
cur.close()
postgresql_proc2 = factories.postgresql_proc(port=9876)
postgresql2 = factories.postgresql('postgresql_proc2')
def test_two_postgreses(postgresql, postgresql2):
"""Check two postgresql fixtures on one test."""
cur = postgresql.cursor()
cur.execute(query)
postgresql.commit()
cur.close()
cur = postgresql2.cursor()
cur.execute(query)
postgresql2.commit()
cur.close()
"""Template database tests."""
import pytest
from pytest_postgresql.factories import postgresql, postgresql_proc
from pytest_postgresql.compat import connection
from tests.loader import load_database
postgresql_proc_with_template = postgresql_proc(
port=21987,
dbname="stories_templated",
load=[load_database],
)
postgresql_template = postgresql(
"postgresql_proc_with_template",
dbname="stories_templated",
)
@pytest.mark.parametrize("_", range(5))
def test_template_database(postgresql_template: connection, _: int) -> None:
"""Check that the database struture gets recreated out of a template."""
with postgresql_template.cursor() as cur:
cur.execute("SELECT * FROM stories")
res = cur.fetchall()
assert len(res) == 4
cur.execute("TRUNCATE stories")
cur.execute("SELECT * FROM stories")
res = cur.fetchall()
assert len(res) == 0
"""Tests main conftest file."""
import os
from pytest_postgresql import factories
pytest_plugins = ["pytester"]
POSTGRESQL_VERSION = os.environ.get("POSTGRES", "13")
TEST_SQL_DIR = os.path.dirname(os.path.abspath(__file__)) + "/test_sql/"
postgresql_proc2 = factories.postgresql_proc(port=None)
postgresql2 = factories.postgresql("postgresql_proc2", dbname="test-db")
postgresql_load_1 = factories.postgresql(
"postgresql_proc2",
dbname="test-load-db",
load=[
TEST_SQL_DIR + "test.sql",
],
)
postgresql_load_2 = factories.postgresql(
"postgresql_proc2",
dbname="test-load-moredb",
load=[TEST_SQL_DIR + "test.sql", TEST_SQL_DIR + "test2.sql"],
)
from swh.scheduler import get_scheduler
from swh.scheduler.backend import SchedulerBackend
# celery tasks for testing purpose; tasks themselves should be
# in swh/scheduler/tests/tasks.py
TASK_NAMES = ["ping", "multiping", "add", "error", "echo"]
scheduler_postgresql_proc = factories.postgresql_proc(load=[
partial(
initialize_database_for_module,
modname="scheduler",
version=SchedulerBackend.current_version,
)
], )
postgresql_scheduler = factories.postgresql("scheduler_postgresql_proc")
@pytest.fixture
def swh_scheduler_config(request, postgresql_scheduler):
return {
"db": postgresql_scheduler.dsn,
}
@pytest.fixture
def swh_scheduler(swh_scheduler_config):
scheduler = get_scheduler("postgresql", **swh_scheduler_config)
for taskname in TASK_NAMES:
scheduler.create_task_type({
"type":
"owner": "test",
"start_date": datetime.datetime(2020, 1, 1)
},
schedule_interval="@daily",
)
@pytest.fixture(autouse=True)
def ports_collection():
client = mongomock.MongoClient()
collection = client['unece_test']['ports']
collection.insert_one({
'countryName': 'Philippines',
'portName': 'Aleran/Ozamis',
'unlocode': 'PH ALE',
'coordinates': '4234N 00135E'
})
return collection
postgresql_proc = postgresql_noproc(
host='postgresqldb_test',
port=5432,
user=os.environ.get('POSTGRES_USER'),
password=os.environ.get('POSTGRES_PASSWORD'))
postgresql = postgresql(
'postgresql_proc',
load=[os.path.join(COMMON_BASE_DIR, 'db', 'postgres-init.sql')],
db_name='unece_test')
import subprocess
import pytest
import pytest_postgresql
from pytest_postgresql import factories
from rdbms_subsetter.subsetter import Db
try:
subprocess.check_output('command -v pg_ctl', shell=True)
PG_CTL_MISSING = False # sorry for the double-negative, but it's convenient later
except subprocess.CalledProcessError:
PG_CTL_MISSING = True
postgresql_dest_proc = factories.postgresql_proc()
postgresql_dest = factories.postgresql('postgresql_dest_proc')
class DummyArgs(object):
logarithmic = False
fraction = 0.25
force_rows = {}
children = 25
config = {}
tables = []
schema = []
exclude_tables = []
full_tables = []
buffer = 1000
import pandas as pd
from pytest_postgresql import factories
from postgres_pandas import db_utils
import pytest
pginst = factories.postgresql_proc('/usr/local/bin/pg_ctl')
dbinst = factories.postgresql('pginst', 'test_db')
@pytest.fixture
def dsn(pginst):
return {'host': pginst.host,
'port': pginst.port,
'user': pginst.user}
@pytest.fixture(autouse=True)
def use_test_db(monkeypatch, dsn):
def mock_config():
return {**dsn, 'dbname': 'test_db'}
monkeypatch.setattr(db_utils, 'get_db_config', mock_config)
@pytest.fixture
def test_data():
df = pd.DataFrame({'plant_name': ['p1', 'p2', 'p3'],
'ph_6_code': ['0815', '0815', '0815'],
'date': ['2019-01-01', '2019-01-01', '2019-01-01'],
),
possible_exception=psycopg.OperationalError,
)
with pytest.raises(psycopg.OperationalError):
psycopg.connect(
dbname=postgres_with_password.user,
user=postgres_with_password.user,
password="******",
host=postgres_with_password.host,
port=postgres_with_password.port,
)
postgresql_max_conns_proc = postgresql_proc(postgres_options="-N 42")
postgres_max_conns = postgresql("postgresql_max_conns_proc")
def test_postgres_options(postgres_max_conns: connection) -> None:
"""Check that max connections (-N 42) is honored."""
cur = postgres_max_conns.cursor()
cur.execute("SHOW max_connections")
assert cur.fetchone() == ("42", )
postgres_isolation_level = postgresql(
"postgresql_proc", isolation_level=psycopg.IsolationLevel.SERIALIZABLE)
def test_custom_isolation_level(postgres_isolation_level: connection) -> None:
"""Check that a client fixture with a custom isolation level works."""
from pytest_postgresql import factories
DE_DB_HOST = "127.0.0.1"
DE_DB_USER = "******"
DE_DB_PASS = None
DE_DB_NAME = "decisionengine"
DE_SCHEMA = [
os.path.dirname(os.path.abspath(__file__)) + "/../postgresql.sql",
]
# DE_DB_PORT assigned at random
PG_PROG = factories.postgresql_proc(user=DE_DB_USER,
password=DE_DB_PASS,
host=DE_DB_HOST,
port=None)
DE_DB = factories.postgresql("PG_PROG", dbname=DE_DB_NAME, load=DE_SCHEMA)
@pytest.fixture
def mock_data_block():
"""
This fixture replaces the standard datablock implementation.
The current DataBlock implementation does not own any data
products but forwards them immediately to a backend datasource.
The only implemented datasource requires Postgres, which is
overkill when needing to test simple data-product communication
between modules.
This mock datablock class directly owns the data products, thus
avoiding the need for a datasource backend. It is anticipated
import pytest
from pytest_postgresql import factories
from pgantomizer.anonymize import (InvalidAnonymizationSchemaError,
MissingAnonymizationRuleError,
load_anonymize_remove,
load_db_to_new_instance)
from pgantomizer.dump import dump_db
from pgantomizer.dump import main as dump_main
from pgantomizer.anonymize import main as anonymize_main
from .asserts import assert_db_anonymized, assert_db_empty
anonymized_proc = factories.postgresql_proc(port='8765', logsdir='/tmp')
anonymized = factories.postgresql('anonymized_proc')
DUMP_PATH = 'test_dump.sql'
SCHEMA_PATH = 'example_schema.yaml'
ORIGINAL_DB_ARGS = {
'password': '',
'dbname': 'tests',
'user': '******',
'host': '127.0.0.1',
'port': '9876'
}
ANONYMIZED_DB_ARGS = {**ORIGINAL_DB_ARGS, **{'port': '8765'}}
DUMP_DB_ARGS = [
ORIGINAL_DB_ARGS[arg] for arg in ('dbname', 'user', 'host', 'port')
]
#! /usr/bin/env python3
import pytest
from pytest_postgresql import factories
import sqlalchemy
pg_executable = "/usr/bin/pg_ctl"
db_name = "wiki_scripts"
# postgresql process fixture
postgresql_proc = factories.postgresql_proc(logs_prefix="pytest-", executable=pg_executable)
# fixture holding an instance of a psycopg2 connection
postgresql = factories.postgresql("postgresql_proc", db=db_name)
@pytest.fixture(scope="function")
def pg_engine(postgresql):
return sqlalchemy.create_engine("postgresql+psycopg2://", poolclass=sqlalchemy.pool.StaticPool, creator=lambda: postgresql)
__all__ = ("postgresql_proc", "postgresql", "pg_engine")
from pytest_rabbitmq.factories import rabbitmq_proc
import pytest
import pika
import os
import pytest
import shutil
import mirakuru
from elasticsearch import Elasticsearch
from pytest_postgresql import factories
import time
pgsql_proc = factories.postgresql_proc(executable='/usr/bin/pg_ctl',
host='localhost',
port=45678,
user='******')
pgsql_db = factories.postgresql('pgsql_proc', db='morp_tests')
rabbitmq_pika_proc = rabbitmq_proc(
server='/usr/lib/rabbitmq/bin/rabbitmq-server', port=34567)
@pytest.fixture
def pika_connection_channel(rabbitmq_pika_proc):
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='localhost',
port=34567,
credentials=pika.PlainCredentials(
'guest', 'guest')))
channel = connection.channel()
return [connection, channel]
parser.addoption('--postgresql-options',
action='store',
dest='postgresql_options',
help=_help_options)
parser.addoption('--postgresql-startparams',
action='store',
dest='postgresql_startparams',
help=_help_startparams)
parser.addoption('--postgresql-logsprefix',
action='store',
dest='postgresql_logsprefix',
help=_help_logsprefix)
parser.addoption('--postgresql-unixsocketdir',
action='store',
dest='postgresql_unixsocketdir',
help=_help_unixsocketdir)
parser.addoption('--postgresql-dbname',
action='store',
dest='postgresql_dbname',
help=_help_dbname)
postgresql_proc = factories.postgresql_proc()
postgresql_nooproc = factories.postgresql_noproc()
postgresql = factories.postgresql('postgresql_proc')
import subprocess
import pytest
import pytest_postgresql
from pytest_postgresql import factories
from rdbms_subsetter.subsetter import Db
try:
subprocess.check_output('command -v pg_ctl', shell=True)
PG_CTL_MISSING = False # sorry for the double-negative, but it's convenient later
except subprocess.CalledProcessError:
PG_CTL_MISSING = True
postgresql_dest_proc = factories.postgresql_proc()
postgresql_dest = factories.postgresql('postgresql_dest_proc')
class DummyArgs(object):
logarithmic = False
fraction = 0.25
force_rows = {}
children = 25
config = {}
tables = []
schema = []
exclude_tables = []
full_tables = []
buffer = 1000
Initializes contracts to be used with the `app` fixture
"""
return init_contracts(app.config)
@pytest.fixture
def celery_app_contracts(celery_app): # pylint: disable=redefined-outer-name
"""
Initializes contracts to be used with the `celery_app` fixture
"""
# Pull singletons off of the default first task
task = celery_app.celery.tasks["update_discovery_provider"]
return init_contracts(task.shared_config)
postgresql_my = factories.postgresql("postgresql_nooproc")
# Returns Postgres DB session, and configures
# SQLAlchemy to use said connection.
# This fixture is primarily used by the
# `postgres_mock_db` fixture, and probably shouldn't
# be consumed directly by a test.
#
# More or less follows steps here:
# https://medium.com/@geoffreykoh/fun-with-fixtures-for-database-applications-8253eaf1a6d
# pylint: disable=W0621
@pytest.fixture(scope="function")
def setup_database(postgresql_my):
def dbcreator():
return postgresql_my.cursor().connection
from swh.core.db.pytest_plugin import initialize_database_for_module
from swh.storage import get_storage
from swh.storage.postgresql.storage import Storage as StorageDatastore
from swh.storage.tests.storage_data import StorageData
environ["LC_ALL"] = "C.UTF-8"
swh_storage_postgresql_proc = factories.postgresql_proc(load=[
partial(
initialize_database_for_module,
modname="storage",
version=StorageDatastore.current_version,
)
], )
swh_storage_postgresql = factories.postgresql("swh_storage_postgresql_proc", )
@pytest.fixture
def swh_storage_backend_config(swh_storage_postgresql):
"""Basic pg storage configuration with no journal collaborator
(to avoid pulling optional dependency on clients of this fixture)
"""
yield {
"cls": "postgresql",
"db": swh_storage_postgresql.dsn,
"objstorage": {
"cls": "memory"
},
"check_config": {
"SQLALCHEMY_PG_WITH_SCHEMA",
"SQLALCHEMY_TEMPFILE_SQLITE",
"datasource",
"mock_data_block",
]
# DE_DB_PORT assigned at random
PG_PROG = factories.postgresql_proc(
user="******",
password=None,
host="127.0.0.1",
port=None,
postgres_options="-N 1000",
)
PG_DE_DB_WITHOUT_SCHEMA = factories.postgresql(
"PG_PROG",
dbname="decisionengine",
)
if sys.version_info.major == 3 and sys.version_info.minor > 6 and platform.python_implementation(
) == "CPython":
# sqlite on EL7 is too old for efficient testing
# sqlite on pypy is unnecessary and really slow
DATABASES_TO_TEST = ("SQLALCHEMY_PG_WITH_SCHEMA",
"SQLALCHEMY_TEMPFILE_SQLITE")
else:
DATABASES_TO_TEST = ("SQLALCHEMY_PG_WITH_SCHEMA", )
@pytest.fixture()
def SQLALCHEMY_PG_WITH_SCHEMA(PG_DE_DB_WITHOUT_SCHEMA):
"""
#! /usr/bin/env python3
import pytest
from pytest_postgresql import factories
import sqlalchemy
pg_executable = "/usr/bin/pg_ctl"
db_name = "wiki_scripts"
# postgresql process fixture
postgresql_proc = factories.postgresql_proc(logs_prefix="pytest-", executable=pg_executable)
# fixture holding an instance of a psycopg2 connection
postgresql = factories.postgresql("postgresql_proc", db_name=db_name)
@pytest.fixture(scope="function")
def pg_engine(postgresql):
return sqlalchemy.create_engine("postgresql+psycopg2://", poolclass=sqlalchemy.pool.StaticPool, creator=lambda: postgresql)
__all__ = ("postgresql_proc", "postgresql", "pg_engine")
import pytest
from pytest_postgresql import factories as psql_factories
from pytest_redis import factories as redis_factories
from sanauth.core import sanauth
postgresql_my_proc = psql_factories.postgresql_proc()
postgresql_my = psql_factories.postgresql('postgresql_my_proc')
redis_my_proc = redis_factories.redis_proc()
redis_my = redis_factories.redisdb('redis_my_proc')
@pytest.fixture
def db_settings(request):
return dict(
user='******',
password='',
host='127.0.0.1',
port=5433,
), dict(address=('127.0.0.1', 6380), minsize=1, maxsize=10)
@pytest.fixture
def app(db_settings, postgresql_my_proc, postgresql_my, redis_my_proc,
redis_my):
pg_settings, redis_config = db_settings
sanauth_app = sanauth(pg_cfg=pg_settings, r_cfg=redis_config)
yield sanauth_app
@pytest.fixture
def app_fixture(loop, app, test_server):
"PG_DE_DB_WITHOUT_SCHEMA",
"SQLALCHEMY_PG_WITH_SCHEMA",
"SQLALCHEMY_IN_MEMORY_SQLITE",
"datasource",
"mock_data_block",
]
# DE_DB_PORT assigned at random
PG_PROG = factories.postgresql_proc(user="******",
password=None,
host="127.0.0.1",
port=None)
PG_DE_DB_WITH_SCHEMA = factories.postgresql(
"PG_PROG",
dbname="decisionengine",
load=[
os.path.dirname(os.path.abspath(__file__)) + "/../postgresql.sql",
],
)
PG_DE_DB_WITHOUT_SCHEMA = factories.postgresql(
"PG_PROG",
dbname="decisionengine",
)
DATABASES_TO_TEST = ("PG_DE_DB_WITH_SCHEMA", )
@pytest.fixture
def SQLALCHEMY_PG_WITH_SCHEMA(request):
"""
Get a blank database from pytest_postgresql.
# Copyright (c) 2019 Mohd Izhar Firdaus Bin Ismail
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
from pytest_postgresql import factories
pgsql_proc = factories.postgresql_proc(
executable="/usr/bin/pg_ctl",
host="localhost",
port=45678,
user="******",
)
pgsql_db = factories.postgresql("pgsql_proc", db_name="morpcc_tests")
pgsql_db_warehouse = factories.postgresql("pgsql_proc",
db_name="morpcc_warehouse")
pgsql_db_cache = factories.postgresql("pgsql_proc", db_name="morpcc_cache")
track_factory_contract = web3.eth.contract(
address=track_factory_address, abi=abi_values["TrackFactory"]["abi"])
return {
"abi_values": abi_values,
"registry_address": registry_address,
"user_factory_address": user_factory_address,
"user_factory_contract": user_factory_contract,
"track_factory_address": track_factory_address,
"track_factory_contract": track_factory_contract,
"web3": web3,
}
postgresql_my = factories.postgresql('postgresql_nooproc')
# Returns Postgres DB session, and configures
# SQLAlchemy to use said connection.
# This fixture is primarily used by the
# `postgres_mock_db` fixture, and probably shouldn't
# be consumed directly by a test.
#
# More or less follows steps here:
# https://medium.com/@geoffreykoh/fun-with-fixtures-for-database-applications-8253eaf1a6d
# pylint: disable=W0621
@pytest.fixture(scope='function')
def setup_database(postgresql_my):
def dbcreator():
return postgresql_my.cursor().connection
"""Tests main conftest file."""
from pytest_postgresql import factories
PG_CTL = '/usr/lib/postgresql/{ver}/bin/pg_ctl'
# pylint:disable=invalid-name
postgresql92 = factories.postgresql_proc(PG_CTL.format(ver='9.2'), port=None)
postgresql93 = factories.postgresql_proc(PG_CTL.format(ver='9.3'), port=None)
postgresql94 = factories.postgresql_proc(PG_CTL.format(ver='9.4'), port=None)
postgresql95 = factories.postgresql_proc(PG_CTL.format(ver='9.5'), port=None)
postgresql96 = factories.postgresql_proc(PG_CTL.format(ver='9.6'), port=None)
postgresql10 = factories.postgresql_proc(PG_CTL.format(ver='10'), port=None)
postgresql11 = factories.postgresql_proc(PG_CTL.format(ver='11'), port=None)
postgresql_proc2 = factories.postgresql_proc(port=9876)
postgresql2 = factories.postgresql('postgresql_proc2', db_name='test-db')
postgresql_rand_proc = factories.postgresql_proc(port=None)
postgresql_rand = factories.postgresql('postgresql_rand_proc')
# pylint:enable=invalid-name
import pytest
import datetime
from django.urls import reverse
from django.conf import settings
from pytest_postgresql import factories
postgresql_external = factories.postgresql('postgresql_nooproc')
<<<<<<< HEAD
=======
# @pytest.fixture(scope='session')
>>>>>>> ft-testing-backend
@pytest.fixture
def api_client():
from rest_framework.test import APIClient
return APIClient()
@pytest.mark.django_db
def test_part_list(api_client):
url = reverse('parturation_list')
res = api_client.get(url)
assert res.status_code == 200
def connection(self):
"""Simple connection instead of TMDB's pool."""
return self._connection
def add_test_unit(self, source, target, slang=None, tlang=None):
lang_config = tmdb.lang_to_config('en')
po = pofile()
u = po.addsourceunit(source)
u.target = target
self.add_store(po, slang or 'en', tlang or 'af')
# avoid cached language lists:
self._available_langs = {}
pg_server = factories.postgresql_proc(port=None, logsdir='/tmp')
pg_connection = factories.postgresql('pg_server', db_name='amagama_test')
@pytest.fixture
def amagama(pg_connection):
"""Returns an amagama app already connected to a database."""
app = amagama_server_factory()
app.testing = True
app.tmdb = TempTMDB(connection=pg_connection, app=app)
app.tmdb.init_db(['en'])
from flask_caching import Cache
cache = Cache(app,
config={
'CACHE_TYPE': 'simple',
'CACHE_THRESHOLD': 100000,
})
import os
import pytest
import pickle
from google.cloud import bigquery
from pytest_postgresql import factories
from coinblas.bitcoin import Chain, Block, Tx, Address
from pygraphblas import *
postgresql_my_proc = factories.postgresql_noproc(host="db",
user="******",
password="******")
postgresql = factories.postgresql("postgresql_my_proc",
db_name="test",
load=["/docker-entrypoint-initdb.d/01.sql"])
import pytest
@pytest.fixture
def btc(postgresql, mocker, datadir, tmp_path):
q = mocker.patch("google.cloud.bigquery.Client.query", autospec=True)
q.return_value = pickle.load(
open(datadir / "initialize_blocks.pickle", "rb"))
c = Chain(
"host=db dbname=test user=postgres password=postgres",
tmp_path / "blocks",
pool_size=1,
)
c.initialize_blocks()
import json
import os
import shutil
from pathlib import Path
import dodoo_init.cache as cache
import pytest
from psycopg2.extensions import make_dsn
from pytest_postgresql import factories
postgres = factories.postgresql_proc()
pg_conn_main = factories.postgresql("postgres")
pg_conn_test = factories.postgresql("postgres", db_name="test")
@pytest.fixture(autouse=True, scope="package")
def environ(tmp_path_factory) -> None:
secrets = tmp_path_factory.mktemp("secrets")
admin_passwd = secrets / "admin"
admin_passwd.write_text("admin-pwd")
admin_passwd.chmod(0o500)
session_encryption_key = secrets / "sessionencryptionkey"
session_encryption_key.write_text("secret-key")
session_encryption_key.chmod(0o500)
smtpuser = secrets / "smtpuser"
smtpuser.write_text("smtp-user")
smtpuser.chmod(0o500)
smtppwd = secrets / "smtppwd"
smtppwd.write_text("smtp-pwd")
smtppwd.chmod(0o500)
os.environ.update(ODOOADMINPASSWORD_FILE=str(admin_passwd))
for chunk in r.iter_content(chunk_size=4096):
f.write(chunk)
# extract the tarball
t = tarfile.open(tarball, "r")
t.extractall(path=cache_dir)
# server_root should be created by extraction
assert os.path.isdir(server_root)
return server_root
_php_ini = os.path.join(os.path.dirname(__file__), "../../misc/php.ini")
mw_nginx_proc = factories.nginx_php_proc("mw_server_root",
php_fpm_params="--php-ini {}".format(_php_ini))
# direct connection to MediaWiki's database
mwpg_conn = postgresql("postgresql_proc", db=_mw_db_name)
class MediaWikiFixtureInstance:
def __init__(self, mw_nginx_proc, postgresql_proc):
self._mw_nginx_proc = mw_nginx_proc
self._postgresql_proc = postgresql_proc
# trivial aliases, usable also in tests
self.hostname=mw_nginx_proc.host
self.port=mw_nginx_proc.port
# always write the config to reflect its possible updates
self._init_local_settings()
# init the database and users
self._init_mw_database()
