def test_bad_collection_get(test_server):
for storage_api_addr in [
test_server.get_address() + "collection/1234/entry",
test_server.get_address() + "collection/1234/value",
test_server.get_address() + "collection/1234/list",
test_server.get_address() + "collection/1234/molecule",
]:
r = requests.get(storage_api_addr, json={"meta": {}, "data": {}})
assert r.status_code == 200, f"{r.reason} {storage_api_addr}"
assert r.json()["meta"]["success"] is False, storage_api_addr
def test_result_socket(test_server):
result_api_addr = test_server.get_address("result")
water = portal.data.get_molecule("water_dimer_minima.psimol")
water2 = portal.data.get_molecule("water_dimer_stretch.psimol")
r = requests.post(
test_server.get_address("molecule"),
json={
"meta": {},
"data": {
"water1": water.to_json(),
"water2": water2.to_json()
}
})
assert r.status_code == 200
mol_insert = r.json()
# Generate some random data
page1 = {
"molecule_id": mol_insert["data"]["water1"],
"method": "M1",
"basis": "B1",
"options": "default",
"program": "P1",
"driver": "energy",
"other_data": 5
}
page2 = {
"molecule_id": mol_insert["data"]["water2"],
"method": "M1",
"basis": "B1",
"options": "default",
"program": "P1",
"driver": "energy",
"other_data": 10
}
r = requests.post(result_api_addr, json={"meta": {}, "data": [page1, page2]})
assert r.status_code == 200
pdata = r.json()
assert pdata["meta"].keys() == meta_set
assert pdata["meta"]["n_inserted"] == 2
r = requests.get(result_api_addr, json={"meta": {}, "data": {"molecule_id": mol_insert["data"]["water2"]}})
assert r.status_code == 200
pdata = r.json()
assert len(pdata["data"]) == 1
assert pdata["data"][0]["other_data"] == 10
def test_molecule_socket(test_server):
mol_api_addr = test_server.get_address("molecule")
water = portal.data.get_molecule("water_dimer_minima.psimol")
# Add a molecule
r = requests.post(mol_api_addr, json={"meta": {}, "data": {"water": water.to_json()}})
assert r.status_code == 200
pdata = r.json()
assert pdata["meta"].keys() == meta_set
# Retrieve said molecule
r = requests.get(mol_api_addr, json={"meta": {"index": "id"}, "data": [pdata["data"]["water"]]})
assert r.status_code == 200
gdata = r.json()
assert isinstance(gdata["data"], list)
assert water.compare(gdata["data"][0])
# Retrieve said molecule via hash
r = requests.get(mol_api_addr, json={"meta": {"index": "hash"}, "data": [water.get_hash()]})
assert r.status_code == 200
gdata = r.json()
assert isinstance(gdata["data"], list)
assert water.compare(gdata["data"][0])
def test_storage_socket(test_server):
storage_api_addr = test_server.get_address(
"collection") # Targets and endpoint in the FractalServer
storage = {
"collection": "TorsionDriveRecord",
"name": "Torsion123",
"something": "else",
"array": ["54321"]
}
# Cast collection type to lower since the server-side does it anyways
storage['collection'] = storage['collection'].lower()
r = requests.post(storage_api_addr, json={"meta": {}, "data": storage})
assert r.status_code == 200
pdata = r.json()
assert pdata["meta"].keys() == meta_set
assert pdata["meta"]["n_inserted"] == 1
r = requests.get(storage_api_addr,
json={
"meta": {},
"data": {
"collection": storage["collection"],
"name": storage["name"]
}
})
assert r.status_code == 200
pdata = r.json()
del pdata["data"][0]["id"]
assert pdata["data"][0] == storage
def test_storage_socket(test_server):
storage_api_addr = test_server.get_address(
"collection") # Targets and endpoint in the FractalServer
storage = {
"collection": "TorsionDrive",
"name": "Torsion123",
"something": "else",
"array": ["54321"]
}
r = requests.post(storage_api_addr, json={"meta": {}, "data": storage})
assert r.status_code == 200
pdata = r.json()
assert pdata["meta"].keys() == meta_set
assert pdata["meta"]["n_inserted"] == 1
r = requests.get(storage_api_addr,
json={
"meta": {},
"data": [(storage["collection"], storage["name"])]
})
assert r.status_code == 200
pdata = r.json()
del pdata["data"][0]["id"]
assert pdata["data"][0] == storage
def test_molecule_socket(test_server):
mol_api_addr = test_server.get_address("molecule")
water = ptl.data.get_molecule("water_dimer_minima.psimol")
water_json = json.loads(water.json())
# Add a molecule
r = requests.post(mol_api_addr, json={"meta": {}, "data": [water_json]})
assert r.status_code == 200, r.reason
pdata = r.json()
assert pdata["meta"].keys() == meta_set
# Retrieve said molecule
r = requests.get(mol_api_addr, json={"meta": {}, "data": {"id": pdata["data"][0]}})
assert r.status_code == 200, r.reason
gdata = r.json()
assert isinstance(gdata["data"], list)
assert water.compare(gdata["data"][0])
# Retrieve said molecule via hash
r = requests.get(mol_api_addr, json={"meta": {}, "data": {"molecule_hash": water.get_hash()}})
assert r.status_code == 200, r.reason
gdata = r.json()
assert isinstance(gdata["data"], list)
assert water.compare(gdata["data"][0])
def test_bad_view_endpoints(test_server):
""" Tests that certain misspellings of the view endpoints result in 404s """
addr = test_server.get_address()
assert requests.get(addr + "collection//value").status_code == 404
assert requests.get(addr + "collection/234/values").status_code == 404
assert requests.get(addr + "collections/234/value").status_code == 404
assert requests.get(addr + "collection/234/view/value").status_code == 404
assert requests.get(addr + "collection/value").status_code == 404
assert requests.get(addr + "collection/S22").status_code == 404
def test_storage_socket(test_server):
storage_api_addr = test_server.get_address() + "collection" # Targets and endpoint in the FractalServer
storage = {
"collection": "TorsionDriveRecord",
"name": "Torsion123",
"something": "else",
"array": ["54321"],
"visibility": True,
"view_available": False,
}
# Cast collection type to lower since the server-side does it anyways
storage['collection'] = storage['collection'].lower()
r = requests.post(storage_api_addr, json={"meta": {}, "data": storage})
assert r.status_code == 200, r.reason
pdata = r.json()
assert pdata["meta"].keys() == meta_set
assert pdata["meta"]["n_inserted"] == 1
r = requests.get(storage_api_addr,
json={
"meta": {},
"data": {
"collection": storage["collection"],
"name": storage["name"]
}
})
assert r.status_code == 200, r.reason
pdata = r.json()
col_id = pdata["data"][0].pop("id")
# got a default values when created
pdata["data"][0].pop("tags", None)
pdata["data"][0].pop("tagline", None)
pdata["data"][0].pop("provenance", None)
pdata["data"][0].pop("view_url", None)
pdata["data"][0].pop("view_metadata", None)
pdata["data"][0].pop("owner", None)
pdata["data"][0].pop("description", None)
assert pdata["data"][0] == storage
# Test collection id sub-resource
r = requests.get(f"{storage_api_addr}/{col_id}", json={"meta": {}, "data": {}}).json()
assert r["meta"]["success"] is True
assert len(r["data"]) == 1
assert r["data"][0]["id"] == col_id
r = requests.get(f"{storage_api_addr}/{col_id}", json={"meta": {}, "data": {"name": "wrong name"}}).json()
assert r["meta"]["success"] is True
assert len(r["data"]) == 0
def test_options_portal(test_server):
client = portal.FractalClient(test_server.get_address(""))
opts = portal.data.get_options("psi_default")
# Test add
ret = client.add_options(opts)
# Test get
get_opt = client.get_options([(opts["program"], opts["name"])])
assert opts == get_opt[0]
def test_bad_collection_post(test_server):
storage = {
"collection": "TorsionDriveRecord",
"name": "Torsion123",
"something": "else",
"array": ["54321"],
"visibility": True,
"view_available": False,
}
# Cast collection type to lower since the server-side does it anyways
storage["collection"] = storage["collection"].lower()
for storage_api_addr in [
test_server.get_address() + "collection/1234",
test_server.get_address() + "collection/1234/value",
test_server.get_address() + "collection/1234/entry",
test_server.get_address() + "collection/1234/list",
test_server.get_address() + "collection/1234/molecule",
]:
r = requests.post(storage_api_addr, json={"meta": {}, "data": storage})
assert r.status_code == 200, r.reason
assert r.json()["meta"]["success"] is False
def test_option_socket(test_server):
opt_api_addr = test_server.get_address("option")
opts = portal.data.get_options("psi_default")
# Add a molecule
r = requests.post(opt_api_addr, json={"meta": {}, "data": [opts]})
assert r.status_code == 200
pdata = r.json()
assert pdata["meta"].keys() == meta_set
assert pdata["meta"]["n_inserted"] == 1
r = requests.get(opt_api_addr, json={"meta": {}, "data": [(opts["program"], opts["name"])]})
assert r.status_code == 200
assert r.json()["data"][0] == opts
def test_molecule_portal(test_server):
client = portal.FractalClient(test_server.get_address(""))
water = portal.data.get_molecule("water_dimer_minima.psimol")
# Test add
ret = client.add_molecules({"water": water})
# Test get
get_mol = client.get_molecules(ret["water"], index="id")
assert water.compare(get_mol[0])
# Test molecular_formula get
get_mol = client.get_molecules(["H4O2"], index="molecular_formula")
assert water.compare(get_mol[0])
def compute_manager_fixture(test_server):
client = portal.FractalClient(test_server.get_address())
# Build Fireworks test server and manager
fireworks = pytest.importorskip("fireworks")
logging.basicConfig(level=logging.CRITICAL,
filename="/tmp/fireworks_logfile.txt")
lpad = fireworks.LaunchPad(name="fw_testing_manager",
logdir="/tmp/",
strm_lvl="CRITICAL")
lpad.reset(None, require_password=False)
yield client, test_server, lpad
# Cleanup and reset
lpad.reset(None, require_password=False)
logging.basicConfig(level=None, filename=None)
def test_collection_portal(test_server):
db = {
"collection": "TorsionDrive",
"name": "Torsion123",
"something": "else",
"array": ["54321"]
}
client = portal.FractalClient(test_server.get_address(""))
# Test add
ret = client.add_collection(db)
# Test get
get_db = client.get_collections([(db["collection"], db["name"])])
del get_db[0]["id"]
assert db == get_db[0]
def test_keywords_socket(test_server):
opt_api_addr = test_server.get_address("keyword")
opts = {"program": "qc", "values": {"opt": "a"}}
# Add a molecule
r = requests.post(opt_api_addr, json={"meta": {}, "data": [opts]})
assert r.status_code == 200
pdata = r.json()
assert pdata["meta"].keys() == meta_set
assert pdata["meta"]["n_inserted"] == 1
data_payload = {"id": pdata["data"][0]}
r = requests.get(opt_api_addr, json={"meta": {}, "data": data_payload})
assert r.status_code == 200
assert r.json()["data"][0]["values"] == opts["values"]
# Try duplicates
r = requests.post(opt_api_addr, json={"meta": {}, "data": [opts]})
assert r.status_code == 200
assert len(r.json()["meta"]["duplicates"]) == 1
