def test_get_product_id(url, client):
login(client)
resp = client.get(url, content_type='application/json')
response_data = json.loads(resp.data)
assert resp.status_code == 200
assert Product.get(1).slug == response_data['slug']
def test_save_in_user_check_permission():
assert Role.query.all() == []
create_user()
role = Role.query.filter_by(name=app.config["USER_ROLE"])
assert role.count() == 1
with app.test_client() as c:
assert getattr(g, "user", False) == False
user = User.query.filter_by(email="*****@*****.**").first()
assert user is not None
user.set_password("test").save()
Permissions.create(name="test_permissions")
role = user.role
role.permissions.append(Permissions(name="test_permissions_in_role"))
role.save()
login(c, "*****@*****.**", "test")
assert getattr(g, "user").email == "*****@*****.**"
c.get(url_for("account.sessions"))
g_user = getattr(g, "user")
assert g_user.email == "*****@*****.**"
assert check_permission("test_permissions") == False
assert check_permission("test_permissions_in_role") == True
def test_product_create(url, client):
data = first_product.copy()
login(client)
resp = client.post(url, content_type='application/json')
assert resp.status_code == 400
resp = client.post(url, data=json.dumps(data),
content_type='application/json')
assert resp.status_code == 201
assert 'slug' in json.loads(resp.data)
def test_edge_table_with_key_field(server, managed_workspace, managed_user,
data_directory):
"""Test that an edge table with a key field is recognized as an edge table."""
with open(data_directory / "membership_with_keys.csv") as csv_file:
request_body = csv_file.read()
table_name = "membership_with_keys"
with conftest.login(managed_user, server):
resp = server.post(f"/api/csv/{managed_workspace.name}/{table_name}",
data=request_body)
assert resp.status_code == 200
edge_table_resp = server.get(
f"/api/workspaces/{managed_workspace.name}/tables",
query_string={"type": "edge"},
)
node_table_resp = server.get(
f"/api/workspaces/{managed_workspace.name}/tables",
query_string={"type": "node"},
)
assert edge_table_resp.status_code == 200
assert table_name in edge_table_resp.json
assert node_table_resp.status_code == 200
assert table_name not in node_table_resp.json
def test_addresses_get_success(url, client):
uid = json.loads(login(client).data)['uid']
resp = client.get(url, content_type='application/json')
assert json.loads(resp.data) == {}
assert resp.status_code == 200
logout(client, uid)
def test_add_user(test_db, seed_db, test_client):
x = test_client.get("/")
assert 'log in' in x.data
x = login('*****@*****.**', 'user1123', test_client)
assert 'User 1' in x.data
x = logout(test_client)
assert 'log in' in x.data
def test_csv_upload_with_compatible_metadata(
managed_workspace, managed_user, server, data_directory
):
"""Test that uploading a CSV file with compatible metadata succeeds."""
table_name = "test"
metadata = {
"columns": [
{"key": "name", "type": "label"},
{"key": "latitude", "type": "number"},
{"key": "longitude", "type": "number"},
{"key": "altitude", "type": "number"},
{"key": "year built", "type": "date"},
]
}
with open(data_directory / "airports.csv") as csv_file:
request_body = csv_file.read()
with conftest.login(managed_user, server):
resp = server.post(
f"/api/csv/{managed_workspace.name}/{table_name}",
data=request_body,
query_string={"metadata": json.dumps(metadata)},
)
assert resp.status_code == 200
# Assert that the table was created and metadata populated successfully
resp = server.get(
f"/api/workspaces/{managed_workspace.name}/tables/{table_name}/metadata"
)
assert resp.status_code == 200
assert resp.json["table"] == metadata
def test_generated_workspace(managed_workspace, managed_user, server):
"""Test that a generated workspace exists when querying the API."""
with conftest.login(managed_user, server):
resp = server.get(
f"/api/workspaces/{managed_workspace.name}/permissions")
assert resp.status_code == 200
def test_add_user(test_db, seed_db, test_client):
x = test_client.get("/")
assert 'log in' in x.data
x = login('*****@*****.**','user1123',test_client)
assert 'User 1' in x.data
x = logout(test_client)
assert 'log in' in x.data
def test_login_logout(client):
"""Make sure login and logout works."""
rv = login(client, email, password)
assert b'Add news here' in rv.data
assert b'Login' not in rv.data
rv = logout(client)
assert b'Login' in rv.data
def test_require_reader(server, managed_workspace, managed_user):
"""Test the `require_reader` decorator."""
with conftest.login(managed_user, server):
resp = server.get(
f"/api/workspaces/{managed_workspace.name}/permissions")
assert resp.status_code == 200
assert resp.json["owner"]["sub"] == managed_user.sub
def test_addresses_put_not_valid_data(url, client):
uid = json.loads(login(client).data)['uid']
address_data = first_address.copy()
del address_data['city']
resp = client.put(url, data=json.dumps(address_data),
content_type='application/json')
assert resp.status_code == 404
logout(client, uid)
def test_user_context(managed_workspace, managed_user, server):
"""Test that the user context properly controls login."""
with conftest.login(managed_user, server):
resp = server.get(f"/api/workspaces/{managed_workspace.name}/tables")
assert resp.status_code == 200
resp = server.get(f"/api/workspaces/{managed_workspace.name}/tables")
assert resp.status_code == 401
def test_addresses_put_201(url, client):
uid = json.loads(login(client).data)['uid']
resp = client.put(url, data=json.dumps(first_address),
content_type='application/json')
response_data = json.loads(resp.data)
assert 'id' in response_data
assert response_data['city'] == first_address['city']
assert resp.status_code == 201
logout(client, uid)
def test_logout(server, managed_workspace, managed_user):
"""Test that logout works properly."""
with conftest.login(managed_user, server):
resp = server.get(f"/api/user/logout")
assert resp.status_code == 200
resp = server.get(
f"/api/workspaces/{managed_workspace.name}/permissions")
assert resp.status_code == 401
def test_register_and_login_prepare(self):
country = "86"
pytest.email = rand_email()
pytest.password = rand_password()
register(email=pytest.email, password=pytest.password, promotion_code="",
verification_code=BACK_DOOR_VERIFY_CODE,
country=country)
pytest.base_token = login(api, pytest.email, pytest.password, challenge="", seccode=BACK_DOOR_VERIFY_CODE,
validate="")
print("register return base_token:%s" % pytest.base_token)
def auth(mongo, client):
email = "test@test"
pwd = "1234"
hashed_password = bcrypt.hashpw(pwd.encode(), bcrypt.gensalt())
mongo.db.users.insert_one({
'first_name': "test",
"last_name": 'test_surname',
"email": email,
"password": hashed_password
})
r = login(client, email, pwd)
return {'client': client, 'response': r}
def test_set_invalid_table_metadata(
populated_workspace, managed_user, server, metadata, expected
):
"""Test that setting invalid metadata fails."""
workspace, _, node_table, _ = populated_workspace
with conftest.login(managed_user, server):
resp = server.put(
f"/api/workspaces/{workspace.name}/tables/{node_table}/metadata",
json=metadata,
)
assert resp.status_code == expected
def test_address_creation_failed_no_data(url, client):
data = first_address.copy()
del data['type'], data['city'], data['street']
uid = json.loads(login(client).data)['uid']
resp = client.post(url, data=json.dumps(data),
content_type='application/json')
assert 'type' in json.loads(resp.data)
assert 'city' in json.loads(resp.data)
assert 'street' in json.loads(resp.data)
assert resp.status_code == 400
logout(client, uid)
def test_set_valid_table_metadata(populated_workspace, managed_user, server):
"""Test that setting valid metadata succeeds."""
workspace, _, node_table, _ = populated_workspace
metadata = {"columns": [{"key": "test", "type": "label"}]}
with conftest.login(managed_user, server):
resp = server.put(
f"/api/workspaces/{workspace.name}/tables/{node_table}/metadata",
json=metadata,
)
assert resp.status_code == 200
assert resp.json["table"] == metadata
def test_existing_table(populated_workspace, managed_user, server):
"""Test that attempt to create a table with an existing name fails."""
workspace, _, node_table, _ = populated_workspace
aql = f"FOR thing in {node_table} RETURN thing"
with conftest.login(managed_user, server):
resp = server.post(
f"/api/workspaces/{workspace.name}/tables",
data=aql,
query_string={"table": node_table},
)
assert resp.status_code == 409
assert resp.data.decode() == node_table
def test_malformed_aql(managed_workspace, managed_user, server):
"""Test that invalid/malformed AQL results in an error."""
table_name = "malformed_table"
malformed_aql = "FOR members RETURN member"
malformed_aql_error = "unexpected RETURN declaration"
with conftest.login(managed_user, server):
resp = server.post(
f"/api/workspaces/{managed_workspace.name}/tables",
data=malformed_aql,
query_string={"table": table_name},
)
assert resp.status_code == 400
assert malformed_aql_error in resp.data.decode()
def test_create_edge_table(populated_workspace, managed_user, server):
"""Test that creating an edge table succeeds."""
workspace, _, node_table, edge_table = populated_workspace
aql = f"FOR doc in {edge_table} RETURN doc"
new_table_name = "new_table"
with conftest.login(managed_user, server):
resp = server.post(
f"/api/workspaces/{workspace.name}/tables",
data=aql,
query_string={"table": new_table_name},
)
assert resp.status_code == 200
assert resp.data.decode() == new_table_name
def test_unsupported_table(populated_workspace, managed_user, server):
"""Test that creating a non edge/node table results in an error."""
workspace, _, node_table, edge_table = populated_workspace
aql = f"FOR doc in {edge_table} RETURN {{ name: 'something' }}"
new_table_name = "new_table"
with conftest.login(managed_user, server):
resp = server.post(
f"/api/workspaces/{workspace.name}/tables",
data=aql,
query_string={"table": new_table_name},
)
error_types = {error["type"] for error in resp.json["errors"]}
assert resp.status_code == 400
assert "UnsupportedTable" in error_types
def test_mutating_aql(populated_workspace, managed_user, server):
"""Test that an AQL query which updates documents fails."""
workspace, _, node_table, _ = populated_workspace
mutating_aql = f"FOR thing in {node_table} UPDATE thing in {node_table}"
mutating_aql_error = "AQL: read only"
new_table_name = "mutating_table"
with conftest.login(managed_user, server):
resp = server.post(
f"/api/workspaces/{workspace.name}/tables",
data=mutating_aql,
query_string={"table": new_table_name},
)
assert resp.status_code == 400
assert mutating_aql_error in resp.data.decode()
def test_csv_upload_with_invalid_metadata_format(
managed_workspace, managed_user, server, data_directory
):
"""Test that uploading a CSV file with invalid json fails properly."""
table_name = "test"
metadata_str = "{"
with open(data_directory / "membership_with_keys.csv") as csv_file:
request_body = csv_file.read()
with conftest.login(managed_user, server):
resp = server.post(
f"/api/csv/{managed_workspace.name}/{table_name}",
data=request_body,
query_string={"metadata": metadata_str},
)
assert resp.status_code == 400
assert resp.json["argument"] == "metadata"
assert resp.json["value"] == metadata_str
def test_populated_workspace(populated_workspace, managed_user, server):
"""Test that the populated workspace has a graph, an edge and node table."""
workspace, graphs, *tables = populated_workspace
with conftest.login(managed_user, server):
# Graphs
resp = server.get(f"/api/workspaces/{workspace.name}/graphs")
assert resp.status_code == 200
graphs = resp.json
assert len(graphs) == 1
assert graphs[0] == "miserables"
# Tables
resp = server.get(f"/api/workspaces/{workspace.name}/tables")
assert resp.status_code == 200
tables = resp.json
assert len(tables) == 2
assert "miserables_nodes" in tables
assert "miserables_links" in tables
def test_csv_upload_with_incompatible_metadata(
managed_workspace, managed_user, server, data_directory
):
"""Test that uploading a CSV file with incompatible metadata returns errors."""
table_name = "test"
metadata = {
"columns": [
{"key": "name", "type": "number"},
{"key": "longitude", "type": "boolean"},
{"key": "city", "type": "date"},
]
}
with open(data_directory / "airports.csv") as csv_file:
request_body = csv_file.read()
with conftest.login(managed_user, server):
resp = server.post(
f"/api/csv/{managed_workspace.name}/{table_name}",
data=request_body,
query_string={"metadata": json.dumps(metadata)},
)
assert resp.status_code == 400
# The product of the number of rows (3) and the number of incorrect columns (3)
assert len(resp.json["errors"]) == 9
assert all(
error["type"] == "TypeConversionFailure" for error in resp.json["errors"]
)
# Assert that the table was not created
resp = server.get(
f"/api/workspaces/{managed_workspace.name}/tables/{table_name}/metadata"
)
assert resp.status_code == 404
assert resp.status == "404 Table Not Found"
assert resp.data.decode() == f"{managed_workspace.name}/{table_name}"
def test_user_unsuccesful_login(client, mongo):
r = login(client, "wrong", "wrong")
assert b"Incorrect username or password" in r.data
def test_addresses_put_400(url, client):
uid = json.loads(login(client).data)['uid']
resp = client.put(url, content_type='application/json')
assert resp.status_code == 400
logout(client, uid)
def test_login_invalid_email(client):
"""Make sure login check invalid input"""
rv = login(client, f"{email}INVALID", password)
assert b'Please logged in to view this page' in rv.data
def test_login_invalid_passowrd(client):
"""Make sure login check invalid input"""
rv = login(client, email, f'{password}INVALID')
assert b'Please logged in to view this page' in rv.data
