def test_query_search(capsys):
# Error on no query
q1 = forge.Query(query_search_client)
assert q1.search() == []
out, err = capsys.readouterr()
assert "Error: No query" in out
assert q1.search(info=True) == ([], {"error": "No query"})
# Return info if requested
q2 = forge.Query(query_search_client)
res2 = q2.search(q="Al", info=False)
assert isinstance(res2, list)
assert isinstance(res2[0], dict)
q3 = forge.Query(query_search_client)
res3 = q3.search(q="Al", info=True)
assert isinstance(res3, tuple)
assert isinstance(res3[0], list)
assert isinstance(res3[0][0], dict)
assert isinstance(res3[1], dict)
# Check limit
q4 = forge.Query(query_search_client)
res4 = q4.search("oqmd", limit=3)
assert len(res4) == 3
# Check limit correction
q5 = forge.Query(query_search_client)
res5 = q5.search("nist_xps_db", limit=20000)
assert len(res5) == 10000
def test_query_field():
q1 = forge.Query(query_search_client)
# Single field and return value test
assert isinstance(q1.field("mdf.source_name", "oqmd"), forge.Query)
assert q1.query == "(mdf.source_name:oqmd"
# Multi-field and grouping test
q1.and_join(close_group=True).field("dc.title", "sample")
assert q1.query == "(mdf.source_name:oqmd) AND (dc.title:sample"
# Negation test
q1.negate()
assert q1.query == "(mdf.source_name:oqmd) AND (dc.title:sample NOT "
# Explicit operator test
# Makes invalid query for this case
q1.operator("NOT")
assert q1.query == "(mdf.source_name:oqmd) AND (dc.title:sample NOT NOT "
# Ensure advanced is set
assert q1.advanced
# Test noop on blanks
q2 = forge.Query(query_search_client)
assert q2.query == "("
q2.field(field="", value="value")
assert q2.query == "("
q2.field(field="field", value="")
assert q2.query == "("
q2.field(field="", value="")
assert q2.query == "("
q2.field(field="field", value="value")
assert q2.query == "(field:value"
def test_query_chaining():
q1 = forge.Query(query_search_client)
q1.field("source_name", "cip")
q1.and_join()
q1.field("elements", "Al")
res1 = q1.search(limit=10000)
res2 = forge.Query(query_search_client).field("source_name", "cip").and_join().field("elements", "Al").search(limit=10000)
assert all([r in res2 for r in res1]) and all([r in res1 for r in res2])
def test_query_init():
q1 = forge.Query(query_search_client)
assert q1.query == "("
assert q1.limit is None
assert q1.advanced is False
assert q1.initialized is False
q2 = forge.Query(query_search_client,
q="mdf.source_name:oqmd",
limit=5,
advanced=True)
assert q2.query == "mdf.source_name:oqmd"
assert q2.limit == 5
assert q2.advanced is True
assert q2.initialized is True
def test_query_aggregate(capsys):
q = forge.Query(query_search_client)
# Error on no query
assert q.aggregate() == []
out, err = capsys.readouterr()
assert "Error: No query" in out
# Error on no index
assert q.aggregate(q="abc") == []
out, err = capsys.readouterr()
assert "Error: No index specified" in out
# Basic aggregation
res1 = q.aggregate("mdf.source_name:nist_xps_db", index="mdf")
assert len(res1) > 10000
assert isinstance(res1[0], dict)
# Multi-dataset aggregation
res2 = q.aggregate(
"(mdf.source_name:nist_xps_db OR mdf.source_name:nist_janaf)",
index="mdf")
assert len(res2) > 10000
assert len(res2) > len(res1)
# Unnecessary aggregation fallback to .search()
# Check success in Coveralls
assert len(q.aggregate("mdf.source_name:hopv")) < 10000
def test_query_aggregate(capsys):
q1 = forge.Query(query_search_client)
# Error on no query
assert q1.aggregate() == []
out, err = capsys.readouterr()
assert "Error: No query" in out
# Basic aggregation
res1 = q1.aggregate("mdf.source_name:nist_xps_db")
assert len(res1) > 10000
assert isinstance(res1[0], dict)
# Multi-dataset aggregation
q2 = forge.Query(query_search_client)
res2 = q2.aggregate(
"(mdf.source_name:nist_xps_db OR mdf.source_name:nist_janaf)")
assert len(res2) > 10000
assert len(res2) > len(res1)
def test_query_field():
q = forge.Query(query_search_client)
# Single field and return value test
assert type(q.field("mdf.source_name", "oqmd")) is forge.Query
assert q.query == "(mdf.source_name:oqmd"
# Multi-field and grouping test
q.and_join(close_group=True).field("dc.title", "sample")
assert q.query == "(mdf.source_name:oqmd) AND (dc.title:sample"
# Ensure advanced is set
assert q.advanced
def test_query_term():
q = forge.Query(query_search_client)
# Single match test
assert type(q.term("term1")) is forge.Query
assert q.query == "(term1"
# Multi-match test
q.and_join().term("term2")
assert q.query == "(term1 AND term2"
# Grouping test
q.or_join(close_group=True).term("term3")
assert q.query == "(term1 AND term2) OR (term3"
def test_query_term():
q = forge.Query(query_search_client)
# Single match test
assert isinstance(q.term("term1"), forge.Query)
assert q.query == "(term1"
assert q.initialized is True
# Multi-match test
q.and_join().term("term2")
assert q.query == "(term1 AND term2"
# Grouping test
q.or_join(close_group=True).term("term3")
assert q.query == "(term1 AND term2) OR (term3"
def test_query_and_join(capsys):
q = forge.Query(query_search_client)
# Test not initialized
assert q.and_join() == q
out, err = capsys.readouterr()
assert ("Error: You must add a term before adding an operator. "
"The current query has not been changed.") in out
# Regular join
q.term("foo").and_join()
assert q.query == "(foo AND "
# close_group
q.term("bar").and_join(close_group=True)
assert q.query == "(foo AND bar) AND ("
def test_query_operator(capsys):
q = forge.Query(query_search_client)
assert q.query == "("
# Add bad operator
assert q.operator("FOO") == q
out, err = capsys.readouterr()
assert "Error: 'FOO' is not a valid operator" in out
assert q.query == "("
# Test operator cleaning
q.operator(" and ")
assert q.query == "( AND "
# Test close_group
q.operator("OR", close_group=True)
assert q.query == "( AND ) OR ("
def test_query_search(capsys):
# Error on no query
q1 = forge.Query(query_search_client)
assert q1.search() == []
out, err = capsys.readouterr()
assert "Error: No query specified" in out
# Return info if requested
q2 = forge.Query(query_search_client)
res2 = q2.search(q="Al", info=False)
assert type(res2) is list
assert type(res2[0]) is dict
q3 = forge.Query(query_search_client)
res3 = q3.search(q="Al", info=True)
assert type(res3) is tuple
assert type(res3[0]) is list
assert type(res3[0][0]) is dict
assert type(res3[1]) is dict
# Check limit
q4 = forge.Query(query_search_client)
res4 = q4.search("oqmd", limit=3)
assert len(res4) == 3
def test_query_cleaning():
# Imbalanced/improper parentheses
q1 = forge.Query(query_search_client, q="() term ")
assert q1.clean_query() == "term"
q2 = forge.Query(query_search_client, q="(term)(")
assert q2.clean_query() == "(term)"
q3 = forge.Query(query_search_client, q="(term) AND (")
assert q3.clean_query() == "(term)"
q4 = forge.Query(query_search_client, q="(term AND term2")
assert q4.clean_query() == "(term AND term2)"
q5 = forge.Query(query_search_client, q="term AND term2)")
assert q5.clean_query() == "(term AND term2)"
q6 = forge.Query(query_search_client, q="((((term AND term2")
assert q6.clean_query() == "((((term AND term2))))"
q7 = forge.Query(query_search_client, q="term AND term2))))")
assert q7.clean_query() == "((((term AND term2))))"
# Correct trailing operators
q8 = forge.Query(query_search_client, q="term AND NOT term2 OR")
assert q8.clean_query() == "term AND NOT term2"
q9 = forge.Query(query_search_client, q="term OR NOT term2 AND")
assert q9.clean_query() == "term OR NOT term2"
q10 = forge.Query(query_search_client, q="term OR term2 NOT")
assert q10.clean_query() == "term OR term2"
def test_query_search(capsys):
# Error on no query
q = forge.Query(query_search_client)
assert q.search(index="mdf") == []
out, err = capsys.readouterr()
assert "Error: No query" in out
assert q.search(info=True) == ([], {"error": "No query"})
# Error on no index
assert q.search(q="abc") == []
out, err = capsys.readouterr()
assert "Error: No index specified" in out
assert q.search(q="abc", info=True) == ([], {"error": "No index"})
# Return info if requested
res2 = q.search(q="Al", index="mdf", info=False)
assert isinstance(res2, list)
assert isinstance(res2[0], dict)
res3 = q.search(q="Al", index="mdf", info=True)
assert isinstance(res3, tuple)
assert isinstance(res3[0], list)
assert isinstance(res3[0][0], dict)
assert isinstance(res3[1], dict)
# Check limit
res4 = q.search("oqmd", index="mdf", limit=3)
assert len(res4) == 3
# Check limit correction
res5 = q.search("nist_xps_db", index="mdf", limit=20000)
assert len(res5) == 10000
# Test index translation
# mdf = d6cc98c3-ff53-4ee2-b22b-c6f945c0d30c
res6 = q.search(q="data", index="mdf", limit=1, info=True)
assert len(res6[0]) == 1
assert res6[1]["index"] == "mdf"
assert res6[1]["index_uuid"] == "d6cc98c3-ff53-4ee2-b22b-c6f945c0d30c"
res7 = q.search(q="data",
index="d6cc98c3-ff53-4ee2-b22b-c6f945c0d30c",
limit=1,
info=True)
assert len(res7[0]) == 1
assert res7[1]["index"] == "d6cc98c3-ff53-4ee2-b22b-c6f945c0d30c"
assert res7[1]["index_uuid"] == "d6cc98c3-ff53-4ee2-b22b-c6f945c0d30c"
with pytest.raises(SearchAPIError):
q.search(q="data", index="invalid", limit=1, info=True)
def test_query_aggregate():
q = forge.Query(query_search_client)
r = q.aggregate('mdf.source_name:oqmd AND '
'(oqmd.configuration:static OR oqmd.configuration:standard) '
'AND oqmd.converged:True AND oqmd.band_gap.value:>2')
assert isinstance(r[0], dict)
