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