def test_transaction_logs_quick_search(client, submitter, pg_driver_clean,
cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
with pg_driver_clean.session_scope():
id_ = str(
pg_driver_clean.nodes(models.submission.TransactionLog).first().id)
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""{
a: transaction_log (quick_search: "%s") { id }
b: transaction_log (quick_search: %s) { id }
c: transaction_log (quick_search: "A") { id }
}""" % (id_, id_)
}),
)
assert r.json == {
"data": {
"a": [{
"id": id_
}],
"b": [{
"id": id_
}],
"c": []
}
}, r.data
def test_transaction_log_related_cases_filter(client, submitter,
pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
data = json.dumps({
"query":
"""
{a: transaction_log (first: 1) { related_cases { id }}}
"""
})
r = client.post(path, headers=submitter, data=data)
assert r.status_code == 200
print(r.data)
case_id = r.json["data"]["a"][0]["related_cases"][0]["id"]
data = json.dumps({
"query": """
query Test($caseId: String) {
a: transaction_log (related_cases: [$caseId]) {
related_cases { id submitter_id }
}
}
""",
"variables": {
"caseId": case_id
},
})
r = client.post(path, headers=submitter, data=data)
assert r.status_code == 200
print(r.data)
related_case_doc = r.json["data"]["a"][0]["related_cases"][0]
assert related_case_doc["id"] == case_id
assert related_case_doc["submitter_id"]
def test_transaction_log_related_cases_filter(client, submitter, pg_driver,
cgci_blgsp):
utils.reset_transactions(pg_driver)
post_example_entities_together(client, pg_driver, submitter)
data = json.dumps({
'query':
"""
{a: transaction_log (first: 1) { related_cases { id }}}
"""
})
r = client.post(path, headers=submitter(path, 'post'), data=data)
assert r.status_code == 200
print r.data
case_id = r.json['data']['a'][0]['related_cases'][0]['id']
data = json.dumps({
'query': """
query Test($caseId: String) {
a: transaction_log (related_cases: [$caseId]) {
related_cases { id submitter_id }
}
}
""",
"variables": {
"caseId": case_id
},
})
r = client.post(path, headers=submitter(path, 'post'), data=data)
assert r.status_code == 200
print r.data
related_case_doc = r.json['data']['a'][0]['related_cases'][0]
assert related_case_doc['id'] == case_id
assert related_case_doc['submitter_id']
def test_transaction_logs_order_desc(client, submitter, pg_driver_clean,
cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
with pg_driver_clean.session_scope():
assert pg_driver_clean.nodes(
models.submission.TransactionLog).count() == 1
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""{
a: transaction_log (order_by_desc: "id") {
id
project_id
created_datetime
}
}"""
}),
)
print(r.data)
_original = r.json["data"]["a"]
_sorted = sorted(_original, key=(lambda x: x["id"]))
assert _original == _sorted, r.data
def test_transaction_log_entities_errors(client, submitter, pg_driver_clean,
cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
put_response = utils.put_entity_from_file(client,
"read_group_invalid.json",
submitter=submitter,
validate=False)
transaction_id = put_response.json.get("transaction_id")
# using response
query = """
{{ log: transaction_log( id: {} ) {{
doc: documents {{ resp: response {{ ent: entities {{
err: errors {{ type keys message }} }} }} }} }} }}
"""
query = query.format(transaction_id)
r = client.post(path, headers=submitter, data=json.dumps({"query": query}))
assert r.status_code == 200
error = r.json["data"]["log"][0]["doc"][0]["resp"]["ent"][0]["err"][0]
# using response_json
query = """
{{ log: transaction_log( id: {} ) {{
doc: documents {{ resp: response_json
}} }} }}
"""
query = query.format(transaction_id)
r = client.post(path, headers=submitter, data=json.dumps({"query": query}))
assert r.status_code == 200
resp = json.loads(r.json["data"]["log"][0]["doc"][0]["resp"])
error = resp["entities"][0]["errors"][0]
assert all(key in error for key in ("type", "keys", "message"))
def test_transaction_log_entities(client, submitter, pg_driver_clean,
cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
# using response
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""{ log: transaction_log {
doc: documents { resp: response { ent: entities { type }}}}}"""
}),
)
assert r.status_code == 200
entities = r.json["data"]["log"][0]["doc"][0]["resp"]["ent"]
assert all(e["type"] for e in entities)
# using response_json
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""{ log: transaction_log {
doc: documents { resp: response_json }}}"""
}),
)
assert r.status_code == 200
resp = json.loads(r.json["data"]["log"][0]["doc"][0]["resp"])
assert all(entity["type"] for entity in resp["entities"])
def test_transaction_logs_quick_search(client, submitter, pg_driver,
cgci_blgsp):
utils.reset_transactions(pg_driver)
post_example_entities_together(client, pg_driver, submitter)
with pg_driver.session_scope():
id_ = str(pg_driver.nodes(models.submission.TransactionLog).first().id)
r = client.post(path,
headers=submitter(path, 'post'),
data=json.dumps({
'query':
"""{
a: transaction_log (quick_search: "%s") { id }
b: transaction_log (quick_search: %s) { id }
c: transaction_log (quick_search: "A") { id }
}""" % (id_, id_)
}))
assert r.json == {
'data': {
'a': [{
'id': id_
}],
'b': [{
'id': id_
}],
'c': [],
}
}, r.data
def test_transaction_log_related_cases(client, submitter, pg_driver_clean,
cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""
query Test {
a: transaction_log (first: 1) {
type documents {response { entities {related_cases {
id submitter_id
}}}}}
}"""
}),
)
assert r.status_code == 200
print(r.data)
related_case = r.json["data"]["a"][0]["documents"][0]["response"][
"entities"][1]["related_cases"][0]
assert "submitter_id" in related_case
assert "id" in related_case
def test_transaction_log_documents(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(path, headers=submitter, data=json.dumps({
'query': """{ log: transaction_log {
doc: documents { doc_size name }}}"""}))
doc = r.json['data']['log'][0]['doc'][0]
assert doc['name'] is None
assert isinstance(doc['doc_size'], int)
def mock_tx_log(pg_driver_clean):
utils.reset_transactions(pg_driver_clean)
with pg_driver_clean.session_scope() as session:
return session.merge(models.submission.TransactionLog(
is_dry_run=True,
program='CGCI',
project='BLGSP',
role='create',
state='SUCCEEDED',
committed_by=12345,
closed=False,
))
def test_order_by_asc_id(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(path,
headers=submitter,
data=json.dumps({
'query':
"""query Test { case (order_by_asc: "id") { id }}"""
}))
print r.data
_original = r.json['data']['case']
_sorted = sorted(_original, cmp=(lambda a, b: cmp(a['id'], b['id'])))
assert _original == _sorted, r.data
def test_auth_transaction_logs(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
with pg_driver_clean.session_scope() as s:
log = pg_driver_clean.nodes(models.submission.TransactionLog).one()
log.program = 'OTHER'
s.merge(log)
r = client.post(path,
headers=submitter,
data=json.dumps(
{'query':
"""query Test { transaction_log { id } }"""}))
with pg_driver_clean.session_scope():
assert len(r.json['data']['transaction_log']) == 0, r.data
def test_transaction_log_type(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(path, headers=submitter, data=json.dumps({
'query': """{ a: transaction_log { role type }}"""}))
print r.data
type_ = graphql.transaction.TransactionLog.TYPE_MAP['create']
assert r.json['data']['a'][0]['type'] == type_
r = client.post(path, headers=submitter, data=json.dumps({
'query': """{
a: transaction_log(type: "%s") { role type }
}""" % type_}))
print r.data
assert r.json['data']['a']
def test_transaction_log_entities(client, submitter, pg_driver, cgci_blgsp):
utils.reset_transactions(pg_driver)
post_example_entities_together(client, pg_driver, submitter)
r = client.post(path,
headers=submitter(path, 'post'),
data=json.dumps({
'query':
"""{ log: transaction_log {
doc: documents { resp: response { ent: entities { type }}}}}"""
}))
print r.data
assert r.status_code == 200
entities = r.json['data']['log'][0]['doc'][0]['resp']['ent']
assert all(e['type'] for e in entities)
def test_transaction_log_documents(client, submitter, pg_driver_clean,
cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""{ log: transaction_log {
doc: documents { doc_size name }}}"""
}),
)
doc = r.json["data"]["log"][0]["doc"][0]
assert doc["name"] is None
assert isinstance(doc["doc_size"], int)
def test_transaction_logs_order_desc(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
with pg_driver_clean.session_scope():
assert pg_driver_clean.nodes(models.submission.TransactionLog).count() == 1
r = client.post(path, headers=submitter, data=json.dumps({
'query': """{
a: transaction_log (order_by_desc: "id") {
id
project_id
created_datetime
}
}"""}))
print r.data
_original = r.json['data']['a']
_sorted = sorted(_original, cmp=(lambda a, b: cmp(b['id'], a['id'])))
assert _original == _sorted, r.data
def test_property_lists(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
with pg_driver_clean.session_scope() as s:
s.merge(
models.Case('case1', submitter_id='s1', project_id='CGCI-BLGSP'))
s.merge(
models.Case('case2', submitter_id='s2', project_id='CGCI-BLGSP'))
data = json.dumps({
'query':
"""{
case (submitter_id: ["s1", "s2"]) {
id submitter_id
},
c1: _transaction_log_count(project_id: ["CGCI-BLGSP"])
c2: _transaction_log_count(project_id: ["CGCI-FAKE"])
c3: _transaction_log_count(project_id: "CGCI-BLGSP")
}""",
})
response = client.post(path, headers=submitter, data=data)
# fix for the unicode artifacts
expected_json = json.loads(
json.dumps({
"data": {
'case': [
{
"id": "case1",
"submitter_id": "s1"
},
{
"id": "case2",
"submitter_id": "s2"
},
],
'c1':
1,
'c2':
0,
'c3':
1,
}
}))
assert response.json == expected_json, response.data
def test_transaction_log_entities(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
# using response
r = client.post(path, headers=submitter, data=json.dumps({
'query': """{ log: transaction_log {
doc: documents { resp: response { ent: entities { type }}}}}"""}))
assert r.status_code == 200
entities = r.json['data']['log'][0]['doc'][0]['resp']['ent']
assert all(e['type'] for e in entities)
# using response_json
r = client.post(path, headers=submitter, data=json.dumps({
'query': """{ log: transaction_log {
doc: documents { resp: response_json }}}"""}))
assert r.status_code == 200
resp = json.loads(r.json['data']['log'][0]['doc'][0]['resp'])
assert all(entity['type'] for entity in resp['entities'])
def test_transaction_log_entities_errors(client, submitter, pg_driver,
cgci_blgsp):
utils.reset_transactions(pg_driver)
post_example_entities_together(client, pg_driver, submitter)
put_response = utils.put_entity_from_file(client,
'read_group_invalid.json',
submitter=submitter,
validate=False)
transaction_id = put_response.json.get('transaction_id')
query = """
{{ log: transaction_log( id: {} ) {{
doc: documents {{ resp: response {{ ent: entities {{
err: errors {{ type keys message }} }} }} }} }} }}
"""
query = query.format(transaction_id)
r = client.post(path,
headers=submitter(path, 'post'),
data=json.dumps({'query': query}))
assert r.status_code == 200
error = r.json['data']['log'][0]['doc'][0]['resp']['ent'][0]['err'][0]
assert all(key in error for key in ('type', 'keys', 'message'))
def test_transaction_log_type(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(
path,
headers=submitter,
data=json.dumps({"query": """{ a: transaction_log { role type }}"""}),
)
print(r.data)
type_ = graphql.transaction.TransactionLog.TYPE_MAP["create"]
assert r.json["data"]["a"][0]["type"] == type_
r = client.post(
path,
headers=submitter,
data=json.dumps({
"query":
"""{
a: transaction_log(type: "%s") { role type }
}""" % type_
}),
)
print(r.data)
assert r.json["data"]["a"]
def test_transaction_log_related_cases(client, submitter, pg_driver,
cgci_blgsp):
utils.reset_transactions(pg_driver)
post_example_entities_together(client, pg_driver, submitter)
r = client.post(path,
headers=submitter(path, 'post'),
data=json.dumps({
'query':
"""
query Test {
a: transaction_log (first: 1) {
type documents {response { entities {related_cases {
id submitter_id
}}}}}
}"""
}))
assert r.status_code == 200
print(r.data)
related_case = (r.json['data']['a'][0]['documents'][0]['response']
['entities'][1]['related_cases'][0])
assert 'submitter_id' in related_case
assert 'id' in related_case
def test_null_variable(client, submitter, pg_driver_clean, cgci_blgsp):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
r = client.post(path,
headers=submitter,
data=json.dumps({
'query':
"""
query Test ($projectId: [String]) {
a: _case_count (project_id: $projectId)
t: _transaction_log_count(project_id: $projectId)
}
""",
}))
with pg_driver_clean.session_scope():
cases = pg_driver_clean.nodes(models.Case).count()
print r.data
assert r.json == {
"data": {
'a': cases,
't': 1,
}
}
def populated_blgsp(client, submitter, pg_driver_clean):
utils.reset_transactions(pg_driver_clean)
post_example_entities_together(client, pg_driver_clean, submitter)
def test_transaction_logs(client, submitter, pg_driver, cgci_blgsp):
utils.reset_transactions(pg_driver)
post_example_entities_together(client, pg_driver, submitter)
with pg_driver.session_scope():
assert pg_driver.nodes(models.submission.TransactionLog).count() == 1
