def test_psycopg2_args_dict(self):
config, intxn_table_map = parse_test_db_config()
adapter = Psycopg2Adapter(
Psycopg2Adapter.to_psycopg_args(config),
intxn_table_map
)
adapter.db_connection.cursor().execute("SELECT 1")
def run(args, config):
# set up database connection
db_logger = logging.getLogger()
db_config, intxn_table_mappings = parse_config(config)
db_pars = Psycopg2Adapter.to_psycopg_args(db_config)
if db_config is None:
error("could not read DB configuration")
if intxn_table_mappings is None:
error("table mappings are not defined")
try:
db_adapter = Psycopg2Adapter(db_pars,
intxn_table_mappings,
logger=db_logger)
except py_tag2domain.exceptions.AdapterConnectionException as e:
error("could not connect to database - %s" % str(e))
# create MeasruementToTags object
msm2tags_logger = logging.getLogger()
max_measurement_age_int = config.getint("tag2domain",
"max_measurement_age",
fallback=None)
if max_measurement_age_int is None:
max_measurement_age = None
logging.info(
"setting up MeasurementToTags without a max measurement age")
else:
max_measurement_age = datetime.timedelta(
minutes=max_measurement_age_int)
logging.info("setting up MeasurementToTags with max measurement "
"age of %i minutes" % (max_measurement_age_int))
msm2tags = MeasurementToTags(db_adapter,
logger=msm2tags_logger,
max_measurement_age=max_measurement_age)
def msm_handler(msm):
try:
result = msm2tags.handle_measurement(msm)
except py_tag2domain.exceptions.InvalidMeasurementException as e:
logging.warning("invalid measurement - %s" % str(e))
raise
except py_tag2domain.exceptions.StaleMeasurementException as e:
logging.warning("stale measurement - %s" % str(e))
return True, None
except Exception as e:
bt = traceback.format_exc()
error("unknown exception - %s\n%s" % (str(e), bt))
return True, result
msm_looper = get_msm_looper(args, config, msm_handler)
msm_looper.loop()
logging.info("all measurements consumed - exiting")
def test_get_stmt_unknown_stmt_fail(self):
config, intxn_table_map = parse_test_db_config()
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
adapter = Psycopg2Adapter(conn, intxn_table_map)
self.assertRaises(
ValueError,
adapter.get_compiled_stmt,
"some unknown stmt",
"domain"
)
def test_get_stmt_unknown_type_fail(self):
config, intxn_table_map = parse_test_db_config()
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
adapter = Psycopg2Adapter(conn, intxn_table_map)
self.assertRaises(
AdapterDBError,
adapter.get_compiled_stmt,
"get_open_tags",
"some unknown type"
)
def test_psycopg2_args_string(self):
config, intxn_table_map = parse_test_db_config()
args_dict = Psycopg2Adapter.to_psycopg_args(config)
args_list = [
"%s=%s" % (key, val)
for key, val in args_dict.items()
if key != "options"
]
args = ' '.join(args_list)
print(args)
adapter = Psycopg2Adapter(args, intxn_table_map)
adapter.db_connection.cursor().execute("SELECT 1")
def test_get_db_dict_cursor(self):
config, _ = parse_test_db_config()
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
set_db(conn)
cursor = get_db_dict_cursor()
self.assertIsInstance(cursor, psycopg2.extensions.cursor)
cursor.execute("SELECT 1;")
disconnect_db()
def test_set_db(self):
config, _ = parse_test_db_config()
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
set_db(conn)
db_conn = get_db()
self.assertIsInstance(db_conn, psycopg2.extensions.connection)
assert tag2domain_api.app.util.db._db_config is None
assert tag2domain_api.app.util.db._config is None
def test_execute_db_correct_stmt(self):
config, _ = parse_test_db_config()
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
set_db(conn)
rows = execute_db("SELECT 1;")
assert len(rows) == 1
assert rows[0][0] == 1
disconnect_db()
def test_psycopg2_args_autocommmit_conn_fail(self):
config, intxn_table_map = parse_test_db_config()
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
conn.set_session(autocommit=True)
self.assertRaisesRegex(
ValueError,
"DB connection used must not be in in autocommit mode",
Psycopg2Adapter,
conn,
intxn_table_map
)
def test_connect_db_fails_when_set_db_used(self):
config, _ = parse_test_db_config()
old_db_conn = connect_db(config)
connection_args = Psycopg2Adapter.to_psycopg_args(config)
conn = psycopg2.connect(**connection_args)
set_db(conn)
old_db_conn.close()
self.assertRaisesRegex(
ValueError,
"No config given",
connect_db
)
async def msm2tag(msm: MeasurementModel = Body(
...,
example={
"version": "1",
"tag_type": "intersection",
"tagged_id": 3,
"taxonomy": "colors",
"producer": "test",
"measured_at": "2020-12-22T12:35:32",
"measurement_id": "test/12345",
"tags": [
{
"tag": "rgb::blue"
},
{
"tag": "cmyk::black"
},
]
})):
_db_adapter = Psycopg2Adapter(get_db(),
intxn_table_mappings,
logger=logger)
_msm2tags = MeasurementToTags(_db_adapter,
logger=logger,
max_measurement_age=max_measurement_age)
try:
logger.debug(msm.dict(exclude_unset=True))
_msm2tags.handle_measurement(msm.dict(exclude_unset=True),
skip_validation=True)
except (InvalidMeasurementException, StaleMeasurementException) as e:
logger.info("error 400: " + str(e))
logger.debug(traceback.format_exc())
raise HTTPException(status_code=400, detail=str(e))
return {"message": "OK"}
from py_tag2domain.util import parse_config
from py_tag2domain.db import Psycopg2Adapter
def parse_test_db_config():
DB_CONFIG_FILE = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"config",
"db.cfg"
)
return parse_config(DB_CONFIG_FILE)
config, TypeIntxnTableMappings = parse_test_db_config()
DB_CONNECTION = Psycopg2Adapter.to_psycopg_args(config)
class PostgresReadOnlyDBTest(TestCase):
@classmethod
def setUpClass(cls):
print("setting up class PostgresReadOnlyDBTest")
cls.intxn_table_mappings = TypeIntxnTableMappings
if DB_CONNECTION is None:
cls.no_db_flag = True
else:
cls.no_db_flag = False
if isinstance(DB_CONNECTION, str):
cls.db_connection = psycopg2.connect(DB_CONNECTION)
elif isinstance(DB_CONNECTION, dict):
cls.db_connection = psycopg2.connect(**DB_CONNECTION)
def setUpClass(cls):
print("setting up class PostgresReadOnlyPsycopgAdapterTest")
super(PostgresReadOnlyPsycopgAdapterTest, cls).setUpClass()
cls.adapter = Psycopg2Adapter(cls.db_connection,
cls.intxn_table_mappings)
def setUp(self):
print("setting up instance of PostgresPsycopgAdapterAutoDBTest")
super(PostgresPsycopgAdapterAutoDBTest, self).setUp()
self.adapter = Psycopg2Adapter(self.db_connection,
self.__class__.intxn_table_mappings)
def test_psycopg_args_with_null_returns_null(self):
self.assertIsNone(Psycopg2Adapter.to_psycopg_args(None))