def test_remove_interface_from_node(db: Session, superuser: User) -> None:
node = create_random_node(db)
interface = create_random_form_input_interface(db)
crud.node.add_interface(db, node=node, interface=interface)
result = crud.node.remove_interface(db, node=node, interface=interface)
assert result is node
assert interface not in node.interfaces
def node_children_setup(
db: Session,
) -> Dict[str, Union[models.Node, models.Interface, models.UserGroup]]:
"""
Setup: Create a parent_node, create a user group with the parent
node as the parent, create a child node with the parent node as the
parent, create an interface, associate the interface with the parent
node.
Returns a dictionary of the format: {
"parent_node": Node,
"child_node": Node,
"user_group": UserGroup,
"interface": Interface
}
"""
parent_node = create_random_node(db)
user_group = create_random_user_group(db, node_id=parent_node.id)
child_node = create_random_node(db, parent_id=parent_node.id)
interface = create_random_form_input_interface(db)
crud.node.add_interface(db, node=parent_node, interface=interface)
return {
"parent_node": parent_node,
"child_node": child_node,
"user_group": user_group,
"interface": interface,
}
def test_remove_interface_from_node_normal_user(client: TestClient,
db: Session) -> None:
"""Successfully remove an interface from a node as a normal user"""
setup = node_permission_setup(
db,
node_type="test",
permission_type=PermissionTypeEnum.update,
permission_enabled=True,
)
node = setup["node"]
user = setup["user"]
interface = create_random_form_input_interface(db)
user_token_headers = authentication_token_from_email(client=client,
email=user.email,
db=db)
crud.node.add_interface(db, node=node, interface=interface)
response = client.post(
f"{settings.API_V1_STR}/nodes/{node.id}/interfaces/{interface.id}/remove",
headers=user_token_headers,
)
db.refresh(node)
assert response.status_code == 200
assert interface not in node.interfaces
def test_remove_interface_from_node_normal_user_fail_no_permission(
client: TestClient, db: Session) -> None:
"""Successfully add an interface to a node as a normal user"""
setup = node_permission_setup(
db,
node_type="test",
permission_type=PermissionTypeEnum.update,
permission_enabled=False,
)
node = setup["node"]
user = setup["user"]
interface = create_random_form_input_interface(db)
user_token_headers = authentication_token_from_email(client=client,
email=user.email,
db=db)
response = client.post(
f"{settings.API_V1_STR}/nodes/{node.id}/interfaces/{interface.id}/remove",
headers=user_token_headers,
)
content = response.json()
assert response.status_code == 403
assert content["detail"] == (
f"User ID {user.id} does not have "
f"{setup['permission'].permission_type} permissions for "
f"{setup['permission'].resource_type} ID {node.id}")
def test_read_form_input_interface_fail_not_superuser(
client: TestClient, normal_user_token_headers: dict,
db: Session) -> None:
"""If the user attempting to access the endpoint is not a superuser"""
form_input = create_random_form_input_interface(db)
response = client.get(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}",
headers=normal_user_token_headers,
)
content = response.json()
assert response.status_code == 400
assert content["detail"] == "The user is not a superuser"
def test_build_table_fail_not_superuser(client: TestClient,
normal_user_token_headers: dict,
db: Session) -> None:
"""Fail if the user is not a superuser"""
form_input = create_random_form_input_interface(db)
response = client.post(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}/build_table",
headers=normal_user_token_headers,
)
content = response.json()
assert response.status_code == 400
assert content["detail"] == "The user is not a superuser"
def test_read_form_input_interface_schema_fail_table_not_created(
client: TestClient, superuser_token_headers: dict,
db: Session) -> None:
"""Fail when the backing table hasn't been created yet"""
form_input = create_random_form_input_interface(db)
response = client.get(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}/schema",
headers=superuser_token_headers,
)
content = response.json()
assert response.status_code == 403
assert content["detail"] == (
"The backing table for this interface has not been created.")
def test_build_table_endpoint(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully build a form input interface's backing table"""
form_input = create_random_form_input_interface(db)
response = client.post(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}/build_table",
headers=superuser_token_headers,
)
content = response.json()
assert response.status_code == 200
assert content["name"] == form_input.name
assert content["table_created"]
def test_remove_interface_from_node_fail_node_not_exist(
client: TestClient, superuser_token_headers: dict,
db: Session) -> None:
"""Fail if the node doesn't exist"""
interface = create_random_form_input_interface(db)
response = client.post(
f"{settings.API_V1_STR}/nodes/{-1}/interfaces/{interface.id}/remove",
headers=superuser_token_headers,
)
content = response.json()
assert response.status_code == 404
assert content["detail"] == "Cannot find node."
def test_add_interface_to_node(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully add an interface to a node"""
node = create_random_node(db)
interface = create_random_form_input_interface(db)
response = client.post(
f"{settings.API_V1_STR}/nodes/{node.id}/interfaces/{interface.id}/add",
headers=superuser_token_headers,
)
db.refresh(node)
assert response.status_code == 200
assert interface in node.interfaces
def test_update_form_input_interface_fail_not_superuser(
client: TestClient, normal_user_token_headers: dict,
db: Session) -> None:
"""Fail if the user is not a superuser"""
form_input = create_random_form_input_interface(db)
data = {"name": random_lower_string()}
response = client.put(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}",
headers=normal_user_token_headers,
json=data,
)
content = response.json()
assert response.status_code == 400
assert content["detail"] == "The user is not a superuser"
def test_delete_form_input_interface(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully delete a form input interface"""
form_input = create_random_form_input_interface(db)
response = client.delete(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}",
headers=superuser_token_headers,
)
stored_interface = crud.form_input.get(db, id=form_input.id)
content = response.json()
assert response.status_code == 200
assert content["name"] == form_input.name
assert stored_interface is None
def test_remove_interface_from_node(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully remove an interface from a node"""
node = create_random_node(db)
interface = create_random_form_input_interface(db)
crud.node.add_interface(db, node=node, interface=interface)
response = client.post(
f"{settings.API_V1_STR}/nodes/{node.id}/interfaces/{interface.id}/remove",
headers=superuser_token_headers,
)
db.refresh(node)
assert response.status_code == 200
assert interface not in node.interfaces
def test_create_form_input_entry_fail_interface_table_not_created(
client: TestClient, superuser_token_headers: dict,
db: Session) -> None:
"""Fail if the interface backing table hasn't been created"""
form_input = create_random_form_input_interface(
db, table_name="fail_table_not_created")
response = client.post(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}/entries/",
headers=superuser_token_headers,
json={},
)
content = response.json()
assert response.status_code == 403
assert content["detail"] == (
"The backing table for this interface has not been created.")
def test_read_form_input_interface(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully retrieve a form input by ID"""
form_input = create_random_form_input_interface(db)
response = client.get(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}",
headers=superuser_token_headers,
)
content = response.json()
assert response.status_code == 200
assert content["id"] == form_input.id
assert content["name"] == form_input.name
assert content["interface_type"] == FORM_INPUT_INTERFACE_TYPE
assert content["template"] == form_input.template
def test_get_node_children(db: Session, superuser: User) -> None:
node = create_random_node(db)
user_group = create_random_user_group(db, node_id=node.id)
child_node = create_random_node(db, parent_id=node.id)
interface = create_random_form_input_interface(db)
crud.node.add_interface(db, node=node, interface=interface)
result = crud.node.get_node_children(db, id=node.id)
for node_child in result:
assert node_child.node_id == node.id
if node_child.child_type == "interface":
assert node_child.child_id == interface.id
if node_child.child_type == "node":
assert node_child.child_id == child_node.id
if node_child.child_type == "user_group":
assert node_child.child_id == user_group.id
def test_delete_form_input_entry_fail_interface_table_not_created(
client: TestClient, superuser_token_headers: dict,
db: Session) -> None:
"""Fail if the specified interface doesn't have a backing table"""
form_input = create_random_form_input_interface(
db, table_name="fail_table_not_created5")
form_input_entry = create_random_form_input_table_entry(db)
response = client.delete(
(f"{settings.API_V1_STR}/interfaces/form-inputs/"
f"{form_input.id}/entries/{form_input_entry.id}"),
headers=superuser_token_headers,
)
content = response.json()
assert response.status_code == 403
assert content["detail"] == (
"The backing table for this interface has not been created.")
def test_update_form_input_interface(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully update a form input interface"""
form_input = create_random_form_input_interface(db)
data = {"name": random_lower_string()}
response = client.put(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}",
headers=superuser_token_headers,
json=data,
)
content = response.json()
assert response.status_code == 200
assert content["name"] == data["name"]
assert content["id"] == form_input.id
assert content["interface_type"] == FORM_INPUT_INTERFACE_TYPE
assert content["template"] == form_input.template
def test_update_form_input_interface_fail_table_created(
client: TestClient, superuser_token_headers: dict,
db: Session) -> None:
"""Fail if the table has already been created"""
form_input = create_random_form_input_interface(db)
crud.form_input.create_template_table(db, id=form_input.id)
data = {"template": test_table_template().dict()}
response = client.put(
f"{settings.API_V1_STR}/interfaces/form-inputs/{form_input.id}",
headers=superuser_token_headers,
json=data,
)
content = response.json()
assert response.status_code == 400
assert content["detail"] == (
"Cannot modify the table template, the table has already been created."
)
def test_delete_form_input_entry_normal_user_fail_no_permission(
client: TestClient, db: Session) -> None:
"""Fail if the normal user doesn't have delete permissions"""
setup = form_input_permission_setup(
db,
permission_type=PermissionTypeEnum.delete,
permission_enabled=False)
form_input = setup["form_input"]
user = setup["user"]
form_input_entry = create_random_form_input_interface(db)
user_token_headers = authentication_token_from_email(client=client,
email=user.email,
db=db)
response = client.delete(
(f"{settings.API_V1_STR}/interfaces/form-inputs/"
f"{form_input.id}/entries/{form_input_entry.id}"),
headers=user_token_headers,
)
content = response.json()
assert response.status_code == 403
assert content["detail"] == (
f"User ID {user.id} does not have delete permissions for "
f"interface ID {form_input.id}")
def test_read_multi_form_input_interface(client: TestClient,
superuser_token_headers: dict,
db: Session) -> None:
"""Successfully retrieve multiple interfaces"""
form_inputs = [create_random_form_input_interface(db) for i in range(10)]
response = client.get(
f"{settings.API_V1_STR}/interfaces/form-inputs/",
headers=superuser_token_headers,
)
content = response.json()
assert response.status_code == 200
for form_input in form_inputs:
found_match = False
for stored_form_input in content["records"]:
id_match = stored_form_input["id"] == form_input.id
name_match = stored_form_input["name"] == form_input.name
type_match = (stored_form_input["interface_type"] ==
FORM_INPUT_INTERFACE_TYPE)
template_match = stored_form_input[
"template"] == form_input.template
if id_match and name_match and type_match and template_match:
found_match = True
break
assert found_match
def create_random_interface(db):
die = random.randint(0, 100)
if die < 50:
return create_random_form_input_interface(db)
return create_random_query_interface(db)
