def _prepare_channel_outbox_repo(self, conf):
blockchain_outbox_repo_conf = env_postgres_config(
'PROC_BCH_OUTBOX_REPO')
if conf:
blockchain_outbox_repo_conf.update(conf)
self.blockchain_outbox_repo = ApiOutboxRepo(
blockchain_outbox_repo_conf)
def test_repository_patch_status(docker_setup, pg_session):
"""
Posting a message returns an integer
The integer returned is a unique local ID of the message in the repo.
"""
repo = postgresrepo.PostgresRepo(env_postgres_config('TEST'))
# what is the statechart for api_outbox messages?
for status in ('rejected', 'accepted'):
msg_dict = test_messages._generate_msg_dict()
msg = gd.Message.from_dict(msg_dict)
msg_id = repo.post(msg)
updates = {"status": status}
assert repo.patch(msg_id, updates)
assert not repo.patch(msg_id, updates)
fetched_msg = repo.get(msg_id)
assert fetched_msg.status == status
with pytest.raises(Exception):
repo.patch(msg_id, {'receiver': 'ES'})
assert not repo.patch(msg_id, {'status': 'ahaha'})
assert not repo.patch(-10, {'status': 'rejected'})
def test_repository_delete_by_id_returns_truthy(docker_setup, pg_session):
repo = postgresrepo.PostgresRepo(env_postgres_config('TEST'))
msg_dict = test_messages._generate_msg_dict()
msg = gd.Message.from_dict(msg_dict)
msg_id = repo.post(msg)
assert repo.delete(msg_id)
assert not repo.delete(msg_id)
def test_complex():
assert igl_value('default_sqs', 'qname') == 'IGL_DEFAULT_SQS_QNAME'
assert igl_value('default_s3', 'bucket') == 'IGL_DEFAULT_S3_BUCKET'
assert igl_value('default_postgres',
'dbname') == 'IGL_DEFAULT_POSTGRES_DBNAME'
for key, value in TEST_ENV.items():
assert os.environ.get(key) == value
default_s3_conf = conf.env_s3_config(TEST_NON_EXISTING_CONF_NAME)
default_sqs_conf = conf.env_queue_config(TEST_NON_EXISTING_CONF_NAME)
default_postgres_conf = conf.env_postgres_config(
TEST_NON_EXISTING_CONF_NAME)
assert to_str_dict(default_s3_conf) == TEST_S3_DEFAULT_CONF
assert to_str_dict(default_sqs_conf) == TEST_SQS_DEFAULT_CONF
assert to_str_dict(default_postgres_conf) == TEST_POSTGRES_DEFAULT_CONF
# bool values
assert isinstance(default_s3_conf['use_ssl'], bool)
assert isinstance(default_sqs_conf['use_ssl'], bool)
# nullable values
del os.environ['IGL_DEFAULT_SQS_QNAME']
del os.environ['IGL_DEFAULT_S3_BUCKET']
del os.environ['IGL_DEFAULT_POSTGRES_DBNAME']
default_s3_conf = conf.env_s3_config(TEST_NON_EXISTING_CONF_NAME)
default_sqs_conf = conf.env_queue_config(TEST_NON_EXISTING_CONF_NAME)
default_postgres_conf = conf.env_postgres_config(
TEST_NON_EXISTING_CONF_NAME)
assert default_s3_conf['bucket'] is None
assert default_sqs_conf['queue_name'] is None
assert default_postgres_conf['dbname'] is None
# testing fully custom configs
custom_s3_conf = conf.env_s3_config(CUSTOM_S3_CONF_NAME)
custom_sqs_conf = conf.env_queue_config(CUSTOM_SQS_CONF_NAME)
custom_postgres_conf = conf.env_postgres_config(CUSTOM_POSTGRES_CONF_NAME)
assert custom_s3_conf == CUSTOM_S3_CONF, os.environ
assert custom_sqs_conf == CUSTOM_SQS_CONF, os.environ
assert custom_postgres_conf == CUSTOM_POSTGRES_CONF, os.environ
def pg_engine(docker_setup):
# docker_services.wait_until_responsive(
# timeout=30.0, pause=0.1,
# check=lambda: pg_is_responsive("postgresql", docker_setup)
# )
conf = env_postgres_config('TEST')
conn_str = "postgresql+psycopg2://{}:{}@{}/{}".format(
conf['user'], conf['password'], conf['host'], conf['dbname'])
engine = sqlalchemy.create_engine(conn_str)
if not sqlalchemy_utils.database_exists(engine.url):
sqlalchemy_utils.create_database(engine.url)
conn = engine.connect()
yield engine
conn.close()
def test_repository_get_by_id(docker_setup, pg_session):
repo = postgresrepo.PostgresRepo(env_postgres_config('TEST'))
msg_dict = test_messages._generate_msg_dict()
msg = gd.Message.from_dict(msg_dict)
msg_id = repo.post(msg)
msg2 = repo.get(msg_id)
assert str(msg.sender) == str(msg2.sender)
assert str(msg.receiver) == str(msg2.receiver)
assert str(msg.subject) == str(msg2.subject)
assert str(msg.obj) == str(msg2.obj)
assert str(msg.predicate) == str(msg2.predicate)
# never mind status, it's unlikely but possible that
# a race condition could make them different
assert not repo.get(-10)
def test():
s3 = env_s3_config('TEST')
queue = env_queue_config('TEST')
postgres = env_postgres_config('TEST')
assert s3['bucket'] == 'test-bucket-1'
assert queue['queue_name'] == 'test-queue-1'
assert postgres['dbname'] == 'postgres_test'
s3 = env_s3_config('TEST_1')
queue = env_queue_config('TEST_1')
assert s3['bucket'] == 'test-bucket-1'
assert queue['queue_name'] == 'test-queue-1'
s3 = env_s3_config('TEST_2')
queue = env_queue_config('TEST_2')
assert s3['bucket'] == 'test-bucket-2'
assert queue['queue_name'] == 'test-queue-2'
import re
from intergov.conf import env_postgres_config
from intergov.repos.api_outbox import postgresrepo
CONF = env_postgres_config('TEST')
def test_repository_search_without_filters(
docker_setup, pg_data, pg_session):
repo = postgresrepo.PostgresRepo(CONF)
repo_messages = repo.search()
assert set([m.sender for m in repo_messages]) == \
set([m['sender'] for m in pg_data])
assert set([m.receiver for m in repo_messages]) == \
set([m['receiver'] for m in pg_data])
assert set([m.predicate for m in repo_messages]) == \
set([m['predicate'] for m in pg_data])
assert set([m.subject for m in repo_messages]) == \
set([m['subject'] for m in pg_data])
assert set([m.obj for m in repo_messages]) == \
set([m['obj'] for m in pg_data])
def test_repository_search_messages_with_sender_filter(
docker_setup, pg_data, pg_session):
repo = postgresrepo.PostgresRepo(CONF)
for d in pg_data:
sender = d["sender"]
repo_messages = repo.search(
from intergov.repos.bc_inbox.elasticmq.elasticmqrepo import BCInboxRepo
from intergov.repos.message_lake import MessageLakeRepo
from intergov.repos.notifications import NotificationsRepo
from intergov.repos.object_acl import ObjectACLRepo
from intergov.repos.object_retrieval import ObjectRetrievalRepo
from tests.unit.domain.wire_protocols.test_generic_message import (
_generate_msg_object)
MESSAGE_LAKE_REPO_CONF = env_s3_config('TEST_1')
OBJECT_ACL_REPO_CONF = env_s3_config('TEST_2')
BC_INBOX_REPO_CONF = env_queue_config('TEST_1')
OBJECT_RETRIEVAL_REPO_CONF = env_queue_config('TEST_2')
NOTIFICATIONS_REPO_CONF = env_queue_config('TEST_3')
BLOCKCHAIN_OUTBOX_REPO_CONF = env_postgres_config('TEST')
OUR_JRD = env("IGL_COUNTRY", default="AU")
def test():
# creating testing versions of all required repos
message_lake_repo = MessageLakeRepo(MESSAGE_LAKE_REPO_CONF)
object_acl_repo = ObjectACLRepo(OBJECT_ACL_REPO_CONF)
bc_inbox_repo = BCInboxRepo(BC_INBOX_REPO_CONF)
object_retrieval_repo = ObjectRetrievalRepo(OBJECT_RETRIEVAL_REPO_CONF)
notifications_repo = NotificationsRepo(NOTIFICATIONS_REPO_CONF)
blockchain_outbox_repo = ApiOutboxRepo(BLOCKCHAIN_OUTBOX_REPO_CONF)
from unittest import mock
import pytest
from intergov.conf import env_postgres_config
from intergov.repos.api_outbox.postgresrepo import PostgresRepo
TEST_CONFIG = env_postgres_config('TEST')
@mock.patch('intergov.repos.api_outbox.postgresrepo.TESTING', False)
def test_unsafe_methods_not_allowed():
repo = PostgresRepo(TEST_CONFIG)
with pytest.raises(RuntimeError):
repo._unsafe_method__clear()
def test_unsafe_methods():
repo = PostgresRepo(TEST_CONFIG)
repo._unsafe_method__clear()
assert repo.is_empty()
def _prepare_outbox_repo(self, conf):
outbox_repo_conf = env_postgres_config('PROC_BCH_OUTBOX')
if conf:
outbox_repo_conf.update(conf)
self.outbox_repo = ApiOutboxRepo(outbox_repo_conf)
from intergov.conf import env_queue_config, env_postgres_config
from intergov.repos.api_outbox import ApiOutboxRepo
from intergov.domain.wire_protocols.generic_discrete import (Message)
from intergov.repos.rejected_message import RejectedMessagesRepo
from intergov.processors.loopback_bch_worker import LoopbackBlockchainWorker
from tests.unit.domain.wire_protocols.test_generic_message import (
_generate_msg_dict)
TEST_API_OUTBOX_REPO_CONF = env_postgres_config('TEST')
TEST_REJECTED_MESSAGES_REPO_CONF = env_queue_config('TEST')
def _generate_msg(**kwargs):
return Message.from_dict(_generate_msg_dict(**kwargs))
def _generate_sender_ref(base):
return "-".join([(f"{base}" * 3)] * 3)
def test():
api_outbox_repo = ApiOutboxRepo(TEST_API_OUTBOX_REPO_CONF)
rejected_messages_repo = RejectedMessagesRepo(
TEST_REJECTED_MESSAGES_REPO_CONF)
api_outbox_repo._unsafe_clear_for_test()
rejected_messages_repo._unsafe_clear_for_test()
# check that repos are really empty
assert not api_outbox_repo.get_next_pending_message()
assert not rejected_messages_repo.get()