def test_in_query(es_data, engine):
""" """
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active") == V_("true")).where(
in_(
"Organization.meta.lastUpdated",
(
"2010-05-28T05:35:56+00:00",
"2001-05-28T05:35:56+00:00",
"2018-05-28T05:35:56+00:00",
),
))
result = builder().fetchall()
assert result.header.total == 1
# Test NOT IN
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active") == V_("true")).where(
not_in_(
"Organization.meta.lastUpdated",
(
"2010-05-28T05:35:56+00:00",
"2001-05-28T05:35:56+00:00",
"2018-05-28T05:35:56+00:00",
),
))
result = builder().fetchall()
assert result.header.total == 0
def test_fetchall(self):
""" """
self.load_contents()
engine = self.get_engine()
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(
T_("Organization.meta.profile",
"http://hl7.org/fhir/Organization")).sort(
sort_("Organization.meta.lastUpdated", SortOrderType.DESC))
result = builder(async_result=False, unrestricted=True).fetchall()
self.assertEqual(result.header.total, 2)
# Test
builder = Q_(resource="Task", engine=engine)
builder = builder.where(T_("Task.status", "ready"))
result = builder(async_result=False, unrestricted=True).fetchall()
self.assertEqual(result.header.total, 2)
# Search with part-of
# should be two sub tasks
builder = Q_(resource="Task", engine=engine)
builder = builder.where(
T_("Task.partOf.reference",
"Task/5df31190-0ed4-45ba-8b16-3c689fc2e686"))
result = builder(async_result=False, unrestricted=True).fetchall()
self.assertEqual(result.header.total, 2)
async def test_first_query(es_requester):
""" """
async with es_requester as requester:
container, request, txn, tm = await setup_txn_on_container(requester
) # noqa
# init primary data
await init_data(requester)
await load_organizations_data(requester, 5)
engine = query_utility(IElasticsearchEngineFactory).get()
index_name = await engine.get_index_name(container)
conn = engine.connection.raw_connection
await conn.indices.refresh(index=index_name)
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active", "true"))
result = await builder(async_result=True).first()
assert result[0]["resourceType"] == builder._from[0][0]
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active", "false"))
result = await builder(async_result=True).first()
assert result is None
def test_result_count(es_data, engine):
""" """
conn, meta_info = es_data
load_organizations_data(conn, 5)
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active") == V_("true"))
assert builder().count() == 6
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active") == V_("false"))
assert builder().count() == 0
async def test_async_fetch_all(es_data, async_engine):
""" """
conn, meta_info = es_data
load_organizations_data(conn, 152)
builder = Q_(resource="Organization", engine=async_engine)
builder = (builder.where(T_("Organization.active") == V_("true")).where(
T_("Organization.meta.lastUpdated", "2010-05-28T05:35:56+00:00")).sort(
sort_("Organization.meta.lastUpdated",
SortOrderType.DESC)).limit(20, 2))
async for resource in builder():
assert resource.__class__.__name__ == "Organization"
# test fetch all
result = await builder().fetchall()
assert result.__class__.__name__ == "EngineResult"
async def test_async_first_query(es_data, async_engine):
""" """
conn, meta_info = es_data
load_organizations_data(conn, 5)
builder = Q_(resource="Organization", engine=async_engine)
builder = builder.where(T_("Organization.active", "true"))
result = await builder().first()
assert isinstance(result, EngineResultRow)
builder = Q_(resource="Organization", engine=async_engine)
builder = builder.where(T_("Organization.active", "false"))
result = await builder().first()
assert result is None
async def test_async_single_query(es_data, async_engine):
""" """
builder = Q_(resource="ChargeItem", engine=async_engine)
builder = builder.where(exists_("ChargeItem.enteredDate"))
result = await builder().single()
assert result is not None
assert isinstance(result, EngineResultRow)
# test empty result
builder = Q_(resource="ChargeItem", engine=async_engine)
builder = builder.where(not_(exists_("ChargeItem.enteredDate")))
result = await builder().single()
assert result is None
# Test Multiple Result error
conn, meta_info = es_data
load_organizations_data(conn, 2)
builder = Q_(resource="Organization", engine=async_engine)
builder = builder.where(T_("Organization.active", "true"))
with pytest.raises(MultipleResultsFound) as excinfo:
await builder().single()
assert excinfo.type == MultipleResultsFound
async def test_single_query(es_requester):
""" """
async with es_requester as requester:
container, request, txn, tm = await setup_txn_on_container(requester
) # noqa
# init primary data
await init_data(requester)
await load_organizations_data(requester, 2)
engine = query_utility(IElasticsearchEngineFactory).get()
index_name = await engine.get_index_name(container)
conn = engine.connection.raw_connection
await conn.indices.refresh(index=index_name)
builder = Q_(resource="ChargeItem", engine=engine)
builder = builder.where(exists_("ChargeItem.enteredDate"))
result = await builder(async_result=True).single()
assert result is not None
assert result[0]["resourceType"] == builder._from[0][0]
# test empty result
builder = Q_(resource="ChargeItem", engine=engine)
builder = builder.where(not_(exists_("ChargeItem.enteredDate")))
result = await builder(async_result=True).single()
assert result is None
# Test Multiple Result error
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active", "true"))
with pytest.raises(MultipleResultsFound) as excinfo:
await builder(async_result=True).single()
assert excinfo.type == MultipleResultsFound
async def test_async_result_empty(es_data, async_engine):
""" """
conn, meta_info = es_data
load_organizations_data(conn, 5)
builder = Q_(resource="Organization", engine=async_engine)
builder = builder.where(T_("Organization.active") == V_("false"))
empty = await builder().empty()
assert empty is True
async def test_async_select_muiltipaths(es_data, async_engine):
""" """
builder = Q_(resource="Organization",
engine=async_engine).select("Organization.name",
"Organization.address")
builder = builder.where(T_("Organization.active") == V_("true"))
result = await builder().fetchall()
# FIXME looks like we changed how things are built here
assert len(result.body[0]) == 2
def test_query_with_non_fhir_select(es_data, engine):
""" """
builder = Q_(resource="Patient", engine=engine)
el_path1 = ElementPath("creation_date", non_fhir=True)
el_path2 = ElementPath("title", non_fhir=True)
builder = builder.select(
el_path1, el_path2).where(T_("Patient.gender") == V_("male"))
result = builder().fetchall()
assert len(result.header.selects) == 2
assert "creation_date" in result.header.selects
def test_first_query(self):
""" """
self.load_contents()
engine = self.get_engine()
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(
T_("Organization.meta.profile",
"http://hl7.org/fhir/Organization"))
result_query = builder(async_result=False, unrestricted=True)
result = result_query.first()
self.assertEqual(result[0]["resourceType"],
result_query._query.get_from()[0][0])
def test_single_query(self):
""" """
self.load_contents()
engine = self.get_engine()
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.id", "f001"))
result_query = builder(async_result=False, unrestricted=True)
self.assertIsNotNone(result_query.single())
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(
T_("Organization.meta.profile",
"http://hl7.org/fhir/Organization"))
result_query = builder(async_result=False, unrestricted=True)
try:
result_query.single()
raise AssertionError(
"Code should not come here, as multiple resources should in result"
)
except MultipleResultsFound:
pass
async def test_in_query(es_requester):
""" """
async with es_requester as requester:
container, request, txn, tm = await setup_txn_on_container(requester
) # noqa
# init primary data
await init_data(requester)
engine = query_utility(IElasticsearchEngineFactory).get()
index_name = await engine.get_index_name(container)
conn = engine.connection.raw_connection
await conn.indices.refresh(index=index_name)
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active") == V_("true")).where(
in_(
"Organization.meta.lastUpdated",
(
"2010-05-28T05:35:56+00:00",
"2001-05-28T05:35:56+00:00",
"2018-05-28T05:35:56+00:00",
),
))
result = await builder(async_result=True).fetchall()
assert result.header.total == 1
# Test NOT IN
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(T_("Organization.active") == V_("true")).where(
not_in_(
"Organization.meta.lastUpdated",
("2010-05-28T05:35:56+00:00", "2001-05-28T05:35:56+00:00",
"2018-05-28T05:35:56+00:00", "2015-05-28T05:35:56+00:00",
"2019-10-03T05:35:56+00:00"),
))
result = await builder(async_result=True).fetchall()
assert result.header.total == 0
def test_result_with_path_contains_index(es_data, engine):
""" """
conn, meta_info = es_data
load_organizations_data(conn, 5)
builder = Q_(resource="Organization", engine=engine)
builder = builder.select("Organization.name.count()",
"Organization.address[1]").where(
T_("Organization.active") == V_("true"))
result = builder().fetchall()
expected_length = "Burgers University Medical Center"
expected_postal_code = "9100 AA"
assert result.body[0][0] == len(expected_length)
assert result.body[0][1]["postalCode"] == expected_postal_code
def build_security_query(self, query):
# The users who has plone.AccessContent permission by prinperm
# The roles who has plone.AccessContent permission by roleperm
show_inactive = False # we will take care later
user = _getAuthenticatedUser(self.es_catalog.catalogtool)
users_roles = [
FhirString(ur) for ur in
self.es_catalog.catalogtool._listAllowedRolesAndUsers(user)
]
filters = list()
term = T_(
"allowedRolesAndUsers",
value=PrimitiveTypeCollection(*users_roles),
non_fhir=True,
)
filters.append(term)
if not show_inactive and not _checkPermission( # noqa: P001
AccessInactivePortalContent, self.es_catalog.catalogtool):
value = FhirDateTime(FhirDateTime(DateTime().ISO8601()))
terms = list()
term = T_("effectiveRange.effectiveRange1", non_fhir=True) <= value
alsoProvides(term, IIgnoreNestedCheck)
terms.append(term)
term = T_("effectiveRange.effectiveRange2", non_fhir=True) >= value
alsoProvides(term, IIgnoreNestedCheck)
terms.append(term)
filters.extend(terms)
# Let's finalize
for f in filters:
f.finalize(self)
query._where.extend(filters)
async def test_raw_result(es_requester):
""" """
async with es_requester as requester:
container, request, txn, tm = await setup_txn_on_container(requester
) # noqa
# init primary data
await init_data(requester)
await load_organizations_data(requester, 161)
engine = query_utility(IElasticsearchEngineFactory).get()
index_name = await engine.get_index_name(container)
conn = engine.connection.raw_connection
await conn.indices.refresh(index=index_name)
query = Q_(resource="Organization", engine=engine)
result_query = query.where(T_("Organization.active") == "true")(
async_result=True, unrestricted=True)
# Test scrol api! although default size is 100 but engine should collect all
# by chunking based
result = await result_query._engine.execute(result_query._query,
result_query._unrestricted)
assert result.header.total > 0
assert result.header.total == len(result.body)
# Test limit works
result_query = query.where(
T_("Organization.active") == "true").limit(20)(async_result=True)
result = await result_query._engine.execute(result_query._query,
result_query._unrestricted)
assert 20 == len(result.body)
# Test with bundle wrapper
bundle = engine.wrapped_with_bundle(result)
assert bundle.total == result.header.total
def test_result_path_contains_function(es_data, engine):
""" """
builder = Q_(resource="Patient", engine=engine)
builder = builder.select(
"Patient.name.first().given.Skip(0).Take(0)",
"Patient.identifier.last().assigner.display",
).where(T_("Patient.gender") == V_("male"))
result = builder().fetchall()
assert result.body[0][0] == "Patient"
assert result.body[0][1] == "Zitelab ApS"
# Test Some exception
with pytest.raises(NotImplementedError):
builder = Q_(resource="Patient", engine=engine)
builder = builder.select("Patient.language.Skip(0)").where(
T_("Patient.gender") == V_("male"))
result = builder().first()
with pytest.raises(ValidationError):
builder = Q_(resource="Patient", engine=engine)
builder = builder.select("Patient.address[0].Skip(0)").where(
T_("Patient.gender") == V_("male"))
result = builder().first()
def test_negetive_query(self):
""" """
self.load_contents()
engine = self.get_engine()
builder = Q_(resource="Task", engine=engine)
builder = builder.where(
not_(
T_(
"Task.owner.reference",
"Practitioner/fake-ac0-821d-46d9-9d40-a61f2578cadf",
)))
result = builder(async_result=False, unrestricted=True).fetchall()
self.assertEqual(result.header.total, 3)
def test_iter_result(self):
""" """
self.load_contents()
engine = self.get_engine()
builder = Q_(resource="Organization", engine=engine)
builder = builder.where(
T_("Organization.meta.profile",
"http://hl7.org/fhir/Organization")).sort(
sort_("Organization.meta.lastUpdated", SortOrderType.DESC))
count = 0
for resource in builder(async_result=False, unrestricted=True):
count += 1
assert resource.__class__.__name__ == "Organization"
self.assertEqual(count, 2)
