Flows and dashboards are created by POST under an issued or superuser-pinned id; PUT only updates; deleted flows leave a tombstone with their key; the controller stores by id and runs by key, hooks live under /hooks/<flow id>; a key with state or queued work behind it is refused until cleared

This commit is contained in:
2026-11-02 17:41:23 +01:00
parent fae85f5ecb
commit 08a6376836
63 changed files with 2832 additions and 936 deletions
+3 -3
View File
@@ -36,10 +36,10 @@ def save(
) -> Callable[..., Any]:
"""Seed the flow as a superuser, then save a change as someone else."""
client.delete(f"{PREFIX}/{FLOW}", headers=superuser_token_headers)
seeded = client.put(
f"{PREFIX}/{FLOW}", headers=superuser_token_headers, json=a_flow(0)
seeded = client.post(
f"{PREFIX}/", headers=superuser_token_headers, json={**a_flow(0), "id": FLOW}
)
assert seeded.status_code == 200, seeded.text
assert seeded.status_code == 201, seeded.text
version = seeded.json()["definition"]["version"]
def put(headers: dict[str, str], **changes: Any) -> Any:
+83 -39
View File
@@ -1,8 +1,10 @@
"""Dashboards over HTTP: saving one, which is also how the first one is made."""
"""Dashboards over HTTP: creating one under an issued id, and saving it."""
from fastapi.testclient import TestClient
from fluksio.core.config import settings
from fluksio.flow.store import ISSUED_ID
from tests.utils.flows import put_dashboard
PREFIX = f"{settings.API_V1_STR}/dashboards"
@@ -26,37 +28,78 @@ def a_dashboard(name: str) -> dict:
}
def test_a_save_creates_a_dashboard_that_does_not_exist_yet(
def test_a_dashboard_is_created_with_an_id_and_saved_by_it(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""A first draft, not a 404: creating one *is* saving it at version 0."""
body = a_dashboard("put_creates")
response = client.put(
f"{PREFIX}/put_creates", headers=superuser_token_headers, json=body
"""A first draft under an id the server issues, which every path then names."""
created = client.post(
f"{PREFIX}/", headers=superuser_token_headers, json={"name": "made_here"}
)
assert response.status_code == 200, response.text
saved = response.json()
assert saved["version"] == 1 and saved["has_draft"] is True
assert created.status_code == 201, created.text
made = created.json()
assert ISSUED_ID.fullmatch(made["id"]) and made["name"] == "made_here"
assert made["version"] == 1 and made["has_draft"] is True
# A draft alone: nothing was published, so no panel can be shown it.
assert (
client.get(f"{PREFIX}/put_creates", headers=superuser_token_headers).status_code
client.get(
f"{PREFIX}/{made['id']}", headers=superuser_token_headers
).status_code
== 404
)
body = {**a_dashboard("made_here"), "version": made["version"]}
saved = client.put(
f"{PREFIX}/{made['id']}", headers=superuser_token_headers, json=body
)
assert saved.status_code == 200, saved.text
draft = client.get(
f"{PREFIX}/put_creates?draft=true", headers=superuser_token_headers
f"{PREFIX}/{made['id']}?draft=true", headers=superuser_token_headers
)
assert draft.json()["widgets"] == body["widgets"]
(listed,) = client.get(
f"{PREFIX}/?name=made_here", headers=superuser_token_headers
).json()["data"]
assert listed["id"] == made["id"]
copy = client.post(
f"{PREFIX}/{made['id']}/duplicate", headers=superuser_token_headers
).json()
assert copy["name"] == "made_here_copy" and copy["id"] != made["id"]
for dashboard_id in (made["id"], copy["id"]):
client.delete(f"{PREFIX}/{dashboard_id}", headers=superuser_token_headers)
def test_a_save_neither_creates_nor_renames(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
missing = client.put(
f"{PREFIX}/nowhere",
headers=superuser_token_headers,
json={**a_dashboard("nowhere"), "version": 0},
)
assert missing.status_code == 404
saved = put_dashboard(
client, superuser_token_headers, a_dashboard("put_fixed")
).json()
renamed = client.put(
f"{PREFIX}/put_fixed",
headers=superuser_token_headers,
json={**saved, "name": "renamed"},
)
assert renamed.status_code == 409
elsewhere = client.put(
f"{PREFIX}/put_fixed",
headers=superuser_token_headers,
json={**saved, "id": "elsewhere"},
)
assert elsewhere.status_code == 422
client.delete(f"{PREFIX}/put_fixed", headers=superuser_token_headers)
def test_a_save_of_an_existing_dashboard_keeps_what_it_did_not_change(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
seeded = a_dashboard("put_updates")
first = client.put(
f"{PREFIX}/put_updates", headers=superuser_token_headers, json=seeded
).json()
first = put_dashboard(client, superuser_token_headers, seeded).json()
renamed = {**first, "widgets": [{**first["widgets"][0], "title": "Outside"}]}
second = client.put(
@@ -78,37 +121,38 @@ def test_a_save_based_on_a_version_someone_moved_past_is_refused(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
body = a_dashboard("put_conflicts")
client.put(f"{PREFIX}/put_conflicts", headers=superuser_token_headers, json=body)
put_dashboard(client, superuser_token_headers, body)
stale = client.put(
f"{PREFIX}/put_conflicts", headers=superuser_token_headers, json=body
f"{PREFIX}/put_conflicts",
headers=superuser_token_headers,
json={**body, "version": 1},
)
assert stale.status_code == 409
assert stale.json()["detail"]["current_version"] == 1
assert stale.json()["detail"]["current_version"] == 2
def test_a_dashboard_is_known_by_an_id_no_save_changes(
client: TestClient, superuser_token_headers: dict[str, str]
def test_only_a_superuser_pins_a_dashboard_id(
client: TestClient,
superuser_token_headers: dict[str, str],
normal_user_token_headers: dict[str, str],
) -> None:
saved = client.put(
f"{PREFIX}/put_identified",
pinned = {"id": "pinned_hall", "name": "pinned_hall"}
refused = client.post(f"{PREFIX}/", headers=normal_user_token_headers, json=pinned)
assert refused.status_code == 403
made = client.post(f"{PREFIX}/", headers=superuser_token_headers, json=pinned)
assert made.status_code == 201 and made.json()["id"] == "pinned_hall"
again = client.post(
f"{PREFIX}/",
headers=superuser_token_headers,
json=a_dashboard("put_identified"),
).json()
assert saved["id"] == "put_identified"
elsewhere = client.put(
f"{PREFIX}/put_identified",
headers=superuser_token_headers,
json={**saved, "id": "elsewhere"},
json={"id": "pinned_hall", "name": "other_hall"},
)
assert elsewhere.status_code == 422
renamed = client.post(
f"{PREFIX}/put_identified/rename",
headers=superuser_token_headers,
json={"name": "renamed"},
assert again.status_code == 409
# Anyone may make one under an id of the server's.
issued = client.post(
f"{PREFIX}/", headers=normal_user_token_headers, json={"name": "their_hall"}
)
assert renamed.status_code in (404, 405)
client.delete(f"{PREFIX}/put_identified", headers=superuser_token_headers)
assert issued.status_code == 201
for dashboard_id in ("pinned_hall", issued.json()["id"]):
client.delete(f"{PREFIX}/{dashboard_id}", headers=superuser_token_headers)
+32 -19
View File
@@ -12,6 +12,7 @@ from fluksio.cloud import config as cloud_config
from fluksio.core.config import settings
from fluksio.flow.devices import DeviceState
from fluksio.main import app
from tests.utils.flows import put_flow
PREFIX = f"{settings.API_V1_STR}/devices"
#: What the openpanel firmware calls, kept as aliases.
@@ -54,8 +55,10 @@ def _dashboard(client: TestClient, headers: dict[str, str], name: str) -> dict:
A new one is a draft, and a panel is only ever shown what is published.
"""
created = client.post(f"{DASHBOARDS}/{name}", headers=headers)
assert created.status_code == 200, created.text
created = client.post(
f"{DASHBOARDS}/", headers=headers, json={"id": name, "name": name}
)
assert created.status_code == 201, created.text
published = client.post(
f"{DASHBOARDS}/{name}/publish",
headers=headers,
@@ -95,7 +98,11 @@ def test_assign_and_read_back(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
for name in ("hall_a", "hall_b"):
client.post(f"{DASHBOARDS}/{name}", headers=superuser_token_headers)
client.post(
f"{DASHBOARDS}/",
headers=superuser_token_headers,
json={"id": name, "name": name},
)
_panels(
client,
@@ -132,7 +139,11 @@ def test_touch_belongs_to_the_device(
The same dashboard may hang on a hallway tablet and on a desk browser, so
the flag rides on the panel and each one answers for itself.
"""
client.post(f"{DASHBOARDS}/shared", headers=superuser_token_headers)
client.post(
f"{DASHBOARDS}/",
headers=superuser_token_headers,
json={"id": "shared", "name": "shared"},
)
_panels(
client,
superuser_token_headers,
@@ -553,12 +564,8 @@ def _publish_flow(
) -> dict:
"""Write a flow and publish it, replacing whatever was there."""
client.delete(f"{FLOWS}/{name}", headers=headers)
saved = client.put(
f"{FLOWS}/{name}",
headers=headers,
json={"name": name, "nodes": nodes, "version": 0, **more},
)
assert saved.status_code == 200, saved.text
saved = put_flow(client, headers, {"name": name, "nodes": nodes, **more}, name)
assert saved.is_success, saved.text
published = client.post(
f"{FLOWS}/{name}/publish",
headers=headers,
@@ -590,10 +597,10 @@ def test_a_devices_io_comes_from_its_device_nodes(
_panels(client, superuser_token_headers, {"panels": [{"id": "porch_io"}]})
_publish_flow(client, superuser_token_headers, "porch", [PORCH_NODE])
# A draft wires nothing until it is published.
client.put(
f"{FLOWS}/porch_draft",
headers=superuser_token_headers,
json={
put_flow(
client,
superuser_token_headers,
{
"name": "porch_draft",
"nodes": [
_device_node(
@@ -603,6 +610,7 @@ def test_a_devices_io_comes_from_its_device_nodes(
],
"version": 0,
},
"porch_draft",
)
first = client.get(f"{PREFIX}/porch_io", headers=superuser_token_headers)
@@ -792,10 +800,10 @@ def test_a_port_wired_twice_or_an_unknown_device_is_an_issue(
"ports": [{"port": "touch", "direction": "in", "dtype": "bool"}],
}
store._write_states(states)
client.put(
f"{FLOWS}/porch_too",
headers=superuser_token_headers,
json={
put_flow(
client,
superuser_token_headers,
{
"name": "porch_too",
"version": client.get(
f"{FLOWS}/porch_too", headers=superuser_token_headers
@@ -816,6 +824,7 @@ def test_a_port_wired_twice_or_an_unknown_device_is_an_issue(
)
],
},
"porch_too",
)
assert codes("porch_too") == {
("device_port", "relay", True),
@@ -1440,7 +1449,11 @@ def test_a_panel_credential_cannot_move_artifacts(
the scope check has to be handed the request there too — without it a panel
would act as whoever approved it.
"""
client.post(f"{DASHBOARDS}/panel_art", headers=superuser_token_headers)
client.post(
f"{DASHBOARDS}/",
headers=superuser_token_headers,
json={"id": "panel_art", "name": "panel_art"},
)
_panels(
client,
superuser_token_headers,
+7 -8
View File
@@ -7,6 +7,7 @@ from sqlmodel import Session, select
from fluksio.core.config import settings
from fluksio.core.db import seed_flavors
from fluksio.models import Flavor
from tests.utils.flows import put_flow
def test_an_instance_starts_with_sizes_to_pick_from(
@@ -97,12 +98,11 @@ def test_a_flow_cannot_name_a_size_that_does_not_exist(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""Caught at the save, which covers the canvas and `fluksio sync` at once."""
response = client.put(
f"{settings.API_V1_STR}/flows/flavor_check",
response = client.post(
f"{settings.API_V1_STR}/flows/",
headers=superuser_token_headers,
json={
"name": "flavor_check",
"version": 1,
"nodes": [
{"id": "fit", "type": "python", "resources": {"flavor": "imaginary"}}
],
@@ -120,12 +120,11 @@ def test_a_size_a_node_still_asks_for_is_not_deleted(
headers=superuser_token_headers,
json={"name": "in-use", "cpus": 2},
)
client.put(
f"{settings.API_V1_STR}/flows/flavor_user",
headers=superuser_token_headers,
json={
put_flow(
client,
superuser_token_headers,
{
"name": "flavor_user",
"version": 1,
"nodes": [
{"id": "fit", "type": "python", "resources": {"flavor": "in-use"}}
],
+341
View File
@@ -0,0 +1,341 @@
"""Flows over HTTP by id, with keys apart from them.
A flow made through the API gets an opaque id unless a superuser pins one, so
most tests here run on both: a pinned ``x_<key>`` and an issued id. A path
that quietly read the key where it meant the id passes for a flow whose id is
its key, and nowhere else.
"""
import uuid
from collections.abc import Callable
from datetime import UTC, datetime
from typing import Any
import pytest
from fastapi.testclient import TestClient
from sqlmodel import Session, delete, select
from fluksio.core.config import settings
from fluksio.flow.store import ISSUED_ID
from fluksio.flow.tombstones import names_of
from fluksio.models import FlowTombstone, Run
FLOWS = f"{settings.API_V1_STR}/flows"
DASHBOARDS = f"{settings.API_V1_STR}/dashboards"
SENSOR = "def process():\n return {'reading': 21.5}\n"
DOUBLE = "def process(reading):\n return {'doubled': reading * 2}\n"
def a_flow(key: str, mode: str = "live") -> dict[str, Any]:
return {
"name": key,
"mode": mode,
"nodes": [
{
"id": "sensor",
"type": "python",
"provides": [{"name": "reading", "dtype": "float"}],
},
{
"id": "double",
"type": "python",
"requires": [{"name": "reading", "dtype": "float"}],
"provides": [{"name": "doubled", "dtype": "float"}],
},
{
"id": "hook",
"type": "http",
"params": {"url": "/tick", "method": "POST"},
"provides": [{"name": "tick", "dtype": "float"}],
},
],
"outputs": ["doubled"] if mode == "batch" else [],
}
def a_key() -> str:
return f"ids_{uuid.uuid4().hex[:8]}"
Make = Callable[..., dict[str, Any]]
@pytest.fixture(params=["pinned", "issued"])
def make(
request: pytest.FixtureRequest,
client: TestClient,
superuser_token_headers: dict[str, str],
) -> Make:
"""Create a flow, pinned to ``x_<key>`` or under an issued id; its detail."""
made: list[str] = []
def create(key: str, **document: Any) -> dict[str, Any]:
body = {**a_flow(key), **document}
if request.param == "pinned":
body["id"] = f"x_{key}"
response = client.post(f"{FLOWS}/", headers=superuser_token_headers, json=body)
assert response.status_code == 201, response.text
detail: dict[str, Any] = response.json()
made.append(detail["definition"]["id"])
return detail
yield create # type: ignore[misc]
for flow_id in made:
client.delete(f"{FLOWS}/{flow_id}", headers=superuser_token_headers)
def test_a_flow_is_made_found_and_saved_by_its_id(
make: Make, client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
key = a_key()
definition = make(key)["definition"]
flow_id = definition["id"]
assert flow_id != key and definition["name"] == key
assert flow_id == f"x_{key}" or ISSUED_ID.fullmatch(flow_id)
read = client.get(f"{FLOWS}/{flow_id}", headers=superuser_token_headers)
assert read.json()["definition"]["name"] == key
# By its key it is not there: only a client resolves a key.
assert client.get(
f"{FLOWS}/{key}", headers=superuser_token_headers
).status_code == (404)
(listed,) = client.get(
f"{FLOWS}/?name={key}", headers=superuser_token_headers
).json()["data"]
assert (listed["id"], listed["name"]) == (flow_id, key)
assert (
client.get(f"{FLOWS}/?name={key}_no", headers=superuser_token_headers).json()[
"data"
]
== []
)
saved = client.put(
f"{FLOWS}/{flow_id}",
headers=superuser_token_headers,
json={**definition, "title": "Retitled"},
)
assert saved.status_code == 200, saved.text
assert saved.json()["definition"]["title"] == "Retitled"
renamed = client.put(
f"{FLOWS}/{flow_id}",
headers=superuser_token_headers,
json={**saved.json()["definition"], "name": f"{key}_b"},
)
assert renamed.status_code == 409
copy = client.post(
f"{FLOWS}/{flow_id}/duplicate", headers=superuser_token_headers
).json()["definition"]
assert copy["name"] == f"{key}_copy" and ISSUED_ID.fullmatch(copy["id"])
client.delete(f"{FLOWS}/{copy['id']}", headers=superuser_token_headers)
def test_a_flow_runs_under_its_key_and_is_reached_by_its_id(
make: Make, client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""Publish, a message, the nodes running, the state under the key."""
key = a_key()
flow_id = make(key)["definition"]["id"]
for node, code in (("sensor", SENSOR), ("double", DOUBLE)):
saved = client.put(
f"{FLOWS}/{flow_id}/nodes/{node}/source",
headers=superuser_token_headers,
json={"code": code},
)
assert saved.json()["id"] == f"{key}.{node}"
version = client.get(f"{FLOWS}/{flow_id}", headers=superuser_token_headers).json()[
"definition"
]["version"]
published = client.post(
f"{FLOWS}/{flow_id}/publish",
headers=superuser_token_headers,
json={"version": version},
)
assert published.status_code == 200, published.text
assert {n["id"]: n["status"] for n in published.json()["nodes"]} == {
f"{key}.sensor": "active",
f"{key}.double": "active",
f"{key}.hook": "active",
}
ran = client.post(
f"{FLOWS}/{flow_id}/run", headers=superuser_token_headers, json={"inputs": {}}
)
assert ran.json()["values"][f"{key}.doubled"]["value"] == 43.0
triggered = client.post(
f"{FLOWS}/{flow_id}/nodes/double/trigger",
headers=superuser_token_headers,
json={"values": {f"{key}.reading": 1.0}},
)
assert triggered.json()["values"][f"{key}.doubled"]["value"] == 2.0
history = client.get(
f"{FLOWS}/{flow_id}/history/doubled", headers=superuser_token_headers
).json()
assert history["message"] == f"{key}.doubled" and history["points"]
# The webhook is under the id, which a later key change leaves alone.
hooked = client.post(f"/hooks/{flow_id}/tick", json={"tick": 7.0})
assert hooked.status_code == 200, hooked.text
assert client.post(f"/hooks/{key}/tick", json={"tick": 8.0}).status_code == 404
state = client.get(f"{FLOWS}/{flow_id}/state", headers=superuser_token_headers)
assert state.json()["values"][f"{key}.tick"]["value"] == 7.0
paused = client.post(f"{FLOWS}/{flow_id}/pause", headers=superuser_token_headers)
assert paused.status_code == 200
assert client.get(f"{FLOWS}/{flow_id}", headers=superuser_token_headers).json()[
"paused"
]
client.post(f"{FLOWS}/{flow_id}/resume", headers=superuser_token_headers)
stopped = client.post(f"{FLOWS}/{flow_id}/stop", headers=superuser_token_headers)
assert stopped.json()["enabled"] is False
assert (
client.post(
f"{FLOWS}/{flow_id}/run",
headers=superuser_token_headers,
json={"inputs": {}},
).status_code
== 409
)
started = client.post(f"{FLOWS}/{flow_id}/start", headers=superuser_token_headers)
assert started.json()["enabled"] is True
acknowledged = client.post(
f"{FLOWS}/{flow_id}/nodes/double/acknowledge", headers=superuser_token_headers
)
assert acknowledged.status_code == 200
def test_a_results_dashboard_is_made_from_a_flow_id_under_the_flows_key(
make: Make, client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
key = a_key()
flow_id = make(key, mode="batch")["definition"]["id"]
client.post(
f"{FLOWS}/{flow_id}/publish",
headers=superuser_token_headers,
json={"version": 1},
)
made = client.post(
f"{DASHBOARDS}/from-flow/{flow_id}", headers=superuser_token_headers
)
assert made.status_code == 201, made.text
board = made.json()
assert board["name"] == f"{key}_results" and ISSUED_ID.fullmatch(board["id"])
assert board["has_draft"] is False
again = client.post(
f"{DASHBOARDS}/from-flow/{flow_id}", headers=superuser_token_headers
)
assert again.status_code == 409
by_key = client.post(
f"{DASHBOARDS}/from-flow/{key}", headers=superuser_token_headers
)
assert by_key.status_code == 404
client.delete(f"{DASHBOARDS}/{board['id']}", headers=superuser_token_headers)
def test_who_may_create_what(
client: TestClient,
superuser_token_headers: dict[str, str],
normal_user_token_headers: dict[str, str],
) -> None:
key = a_key()
plain = {"name": key, "nodes": [{"id": "hold", "type": "delay"}]}
# Anyone makes a flow under an issued id, as anyone could save one before.
made = client.post(f"{FLOWS}/", headers=normal_user_token_headers, json=plain)
assert made.status_code == 201, made.text
flow_id = made.json()["definition"]["id"]
assert ISSUED_ID.fullmatch(flow_id)
# Code stays a superuser's to put there, and so does choosing an id.
coded = client.post(
f"{FLOWS}/",
headers=normal_user_token_headers,
json={**plain, "name": f"{key}_code", "nodes": [{"id": "fn"}]},
)
assert coded.status_code == 403
pinned = client.post(
f"{FLOWS}/",
headers=normal_user_token_headers,
json={**plain, "name": f"{key}_pin", "id": f"x_{key}"},
)
assert pinned.status_code == 403
def pin(flow: str, name: str) -> int:
return client.post(
f"{FLOWS}/",
headers=superuser_token_headers,
json={**plain, "name": name, "id": flow},
).status_code
assert pin("Not-An-Id", f"{key}_a") == 422
assert pin("graph", f"{key}_b") == 422 # behind `GET /flows/graph`
assert pin(flow_id, f"{key}_c") == 409 # a live flow's
assert pin(f"x_{key}", key) == 409 # the key is taken
assert pin(f"x_{key}", "f_k3q7m2xa") == 400 # shaped like an issued id
client.delete(f"{FLOWS}/{flow_id}", headers=superuser_token_headers)
def test_a_deleted_flow_keeps_its_name_and_frees_its_key(
make: Make,
client: TestClient,
superuser_token_headers: dict[str, str],
db: Session,
) -> None:
key = a_key()
old = make(key)["definition"]["id"]
db.add(Run(id=f"run-{key}", flow=old, status="ok", created_at=datetime.now(UTC)))
db.commit()
controller = client.app.state.flow_controller # type: ignore[attr-defined]
controller.state.set(f"{key}.doubled", 1.0)
deleted = client.delete(f"{FLOWS}/{old}", headers=superuser_token_headers)
assert deleted.status_code == 200
assert db.get(FlowTombstone, old).name == key
assert names_of([old], controller.store) == {old: key}
# What the old flow left under its key went with it.
assert controller.key_residue(key) == []
# Something still writing there keeps the key from a new flow.
controller.state.set(f"{key}.stray", 1.0)
refused = client.post(
f"{FLOWS}/", headers=superuser_token_headers, json=a_flow(key)
)
assert refused.status_code == 409 and f"{key}.stray" in refused.json()["detail"]
controller.forget_flow(key)
# Under an id of its own, not the one the runs are filed under.
made = client.post(f"{FLOWS}/", headers=superuser_token_headers, json=a_flow(key))
assert made.status_code == 201, made.text
new = made.json()["definition"]["id"]
assert new != old
assert db.exec(select(Run).where(Run.flow == new)).first() is None
client.delete(f"{FLOWS}/{new}", headers=superuser_token_headers)
db.exec(delete(Run).where(Run.id == f"run-{key}")) # type: ignore[call-overload]
db.commit()
def test_a_pinned_restore_takes_its_history_back(
client: TestClient, superuser_token_headers: dict[str, str], db: Session
) -> None:
key = a_key()
pin = f"x_{key}"
plain = {"name": key, "nodes": []}
client.post(f"{FLOWS}/", headers=superuser_token_headers, json={**plain, "id": pin})
client.delete(f"{FLOWS}/{pin}", headers=superuser_token_headers)
other = client.post(
f"{FLOWS}/",
headers=superuser_token_headers,
json={**plain, "name": f"{key}_b", "id": pin},
)
assert other.status_code == 409
restored = client.post(
f"{FLOWS}/", headers=superuser_token_headers, json={**plain, "id": pin}
)
assert restored.status_code == 201, restored.text
db.expire_all()
assert db.get(FlowTombstone, pin) is None
client.delete(f"{FLOWS}/{pin}", headers=superuser_token_headers)
+42 -81
View File
@@ -11,6 +11,7 @@ from fluksio.api.routes import flows as flows_route
from fluksio.core.config import settings
from fluksio.flow.events import event_bus
from fluksio.models import Run, RunArtifact, RunMetric, RunNode
from tests.utils.flows import put_flow
PREFIX = f"{settings.API_V1_STR}/flows"
@@ -51,10 +52,8 @@ def test_flows_require_authentication(client: TestClient) -> None:
def test_save_then_read_flow(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
response = client.put(
f"{PREFIX}/demo", headers=superuser_token_headers, json=a_flow()
)
assert response.status_code == 200
response = put_flow(client, superuser_token_headers, a_flow(), "demo")
assert response.status_code == 201
response = client.get(f"{PREFIX}/demo", headers=superuser_token_headers)
assert response.status_code == 200
@@ -68,58 +67,35 @@ def test_save_then_read_flow(
assert datetime.fromisoformat(summary["updated_at"]).tzinfo is not None
def test_name_mismatch_is_rejected(
def test_a_save_neither_creates_nor_renames(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
response = client.put(
f"{PREFIX}/other", headers=superuser_token_headers, json=a_flow("demo")
put_flow(client, superuser_token_headers, a_flow(), "demo")
current = client.get(f"{PREFIX}/demo", headers=superuser_token_headers).json()
document = current["definition"]
missing = client.put(
f"{PREFIX}/nowhere", headers=superuser_token_headers, json=a_flow("nowhere")
)
assert response.status_code == 400
def test_a_flow_is_known_by_an_id_no_save_changes(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""For now the id of a new flow is its key, and the URL names both."""
saved = client.put(
f"{PREFIX}/identified",
assert missing.status_code == 404
renamed = client.put(
f"{PREFIX}/demo",
headers=superuser_token_headers,
json=a_flow("identified"),
).json()["definition"]
assert saved["id"] == "identified"
listed = client.get(f"{PREFIX}/", headers=superuser_token_headers).json()["data"]
assert {"id": "identified", "name": "identified"}.items() <= next(
f for f in listed if f["name"] == "identified"
).items()
json={**document, "name": "other"},
)
assert renamed.status_code == 409
elsewhere = client.put(
f"{PREFIX}/identified",
f"{PREFIX}/demo",
headers=superuser_token_headers,
json={**saved, "id": "elsewhere"},
json={**document, "id": "elsewhere"},
)
assert elsewhere.status_code == 400
# A key changes by a rename, and that route is not there yet.
renamed = client.post(
f"{PREFIX}/identified/rename",
headers=superuser_token_headers,
json={"new_name": "renamed"},
)
assert renamed.status_code in (404, 405)
# Shaped like an id the server issues, which a new key may not be.
issued = client.put(
f"{PREFIX}/f_k3q7m2xa",
headers=superuser_token_headers,
json=a_flow("f_k3q7m2xa"),
)
assert issued.status_code == 400
client.delete(f"{PREFIX}/identified", headers=superuser_token_headers)
def test_broken_node_is_reported_and_siblings_stay_active(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
client.put(f"{PREFIX}/demo", headers=superuser_token_headers, json=a_flow())
put_flow(client, superuser_token_headers, a_flow(), "demo")
client.put(
f"{PREFIX}/demo/nodes/sensor/source",
headers=superuser_token_headers,
@@ -143,7 +119,7 @@ def test_broken_node_is_reported_and_siblings_stay_active(
def test_running_a_flow_produces_values(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
client.put(f"{PREFIX}/demo", headers=superuser_token_headers, json=a_flow())
put_flow(client, superuser_token_headers, a_flow(), "demo")
client.put(
f"{PREFIX}/demo/nodes/sensor/source",
headers=superuser_token_headers,
@@ -165,9 +141,7 @@ def test_running_a_flow_produces_values(
def test_editing_does_not_deploy_until_published(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
saved = client.put(
f"{PREFIX}/staged", headers=superuser_token_headers, json=a_flow("staged")
).json()
saved = put_flow(client, superuser_token_headers, a_flow("staged"), "staged").json()
assert saved["has_draft"] is True
# Nothing is running yet, so the engine knows no nodes of this flow.
assert (
@@ -197,8 +171,8 @@ def test_editing_does_not_deploy_until_published(
def test_a_stale_save_is_refused(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
saved = client.put(
f"{PREFIX}/contested", headers=superuser_token_headers, json=a_flow("contested")
saved = put_flow(
client, superuser_token_headers, a_flow("contested"), "contested"
).json()
stale = saved["definition"]
@@ -222,8 +196,8 @@ def test_a_stale_save_is_refused(
def test_discarding_a_draft_restores_what_is_running(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
saved = client.put(
f"{PREFIX}/reverted", headers=superuser_token_headers, json=a_flow("reverted")
saved = put_flow(
client, superuser_token_headers, a_flow("reverted"), "reverted"
).json()
client.post(
f"{PREFIX}/reverted/publish",
@@ -232,10 +206,11 @@ def test_discarding_a_draft_restores_what_is_running(
)
published = client.get(f"{PREFIX}/reverted", headers=superuser_token_headers).json()
client.put(
f"{PREFIX}/reverted",
headers=superuser_token_headers,
json={**published["definition"], "title": "Scratch that"},
put_flow(
client,
superuser_token_headers,
{**published["definition"], "title": "Scratch that"},
"reverted",
)
response = client.post(
@@ -251,9 +226,7 @@ def test_discarding_a_draft_restores_what_is_running(
def test_stopping_a_flow_takes_it_off_the_engine(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
saved = client.put(
f"{PREFIX}/halted", headers=superuser_token_headers, json=a_flow("halted")
).json()
saved = put_flow(client, superuser_token_headers, a_flow("halted"), "halted").json()
client.post(
f"{PREFIX}/halted/publish",
headers=superuser_token_headers,
@@ -286,9 +259,7 @@ def test_stopping_a_flow_takes_it_off_the_engine(
def test_pausing_is_reported_back(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
saved = client.put(
f"{PREFIX}/held", headers=superuser_token_headers, json=a_flow("held")
).json()
saved = put_flow(client, superuser_token_headers, a_flow("held"), "held").json()
client.post(
f"{PREFIX}/held/publish",
headers=superuser_token_headers,
@@ -318,7 +289,7 @@ def test_unconnected_input_is_surfaced(
) -> None:
flow = a_flow()
flow["nodes"][0]["provides"] = [] # nothing produces "reading" any more
client.put(f"{PREFIX}/demo", headers=superuser_token_headers, json=flow)
put_flow(client, superuser_token_headers, flow, "demo")
issues = client.post(
f"{PREFIX}/demo/validate", headers=superuser_token_headers
@@ -329,7 +300,7 @@ def test_unconnected_input_is_surfaced(
def test_delete_flow(
client: TestClient, superuser_token_headers: dict[str, str], db: Session
) -> None:
client.put(f"{PREFIX}/demo", headers=superuser_token_headers, json=a_flow())
put_flow(client, superuser_token_headers, a_flow(), "demo")
# Finished: a flow with a live run refuses to be deleted, which is its own
# test below.
db.add(Run(id="run-1", flow="demo", status="ok", created_at=datetime.now(UTC)))
@@ -362,7 +333,7 @@ def test_delete_flow(
def test_delete_flow_is_refused_while_a_run_is_live(
client: TestClient, superuser_token_headers: dict[str, str], db: Session
) -> None:
client.put(f"{PREFIX}/demo", headers=superuser_token_headers, json=a_flow())
put_flow(client, superuser_token_headers, a_flow(), "demo")
db.add(
Run(id="run-live", flow="demo", status="running", created_at=datetime.now(UTC))
)
@@ -390,8 +361,8 @@ def test_a_node_that_raises_answers_with_its_error(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""A manual run fails the way a scheduled one does, not as a 500."""
saved = client.put(
f"{PREFIX}/failing", headers=superuser_token_headers, json=a_flow("failing")
saved = put_flow(
client, superuser_token_headers, a_flow("failing"), "failing"
).json()
client.put(
f"{PREFIX}/failing/nodes/sensor/source",
@@ -422,9 +393,7 @@ def test_acknowledging_a_failure_is_announced_on_the_bus(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""Another browser holds the same marker; the event is what clears it."""
saved = client.put(
f"{PREFIX}/acked", headers=superuser_token_headers, json=a_flow("acked")
).json()
saved = put_flow(client, superuser_token_headers, a_flow("acked"), "acked").json()
client.post(
f"{PREFIX}/acked/publish",
headers=superuser_token_headers,
@@ -505,9 +474,7 @@ async def test_the_live_socket_ends_when_its_client_goes(
def test_saving_a_header_moves_the_node_ports_in_the_draft(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
saved = client.put(
f"{PREFIX}/header", headers=superuser_token_headers, json=a_flow("header")
).json()
saved = put_flow(client, superuser_token_headers, a_flow("header"), "header").json()
response = client.put(
f"{PREFIX}/header/nodes/logger/source",
@@ -539,9 +506,7 @@ def test_saving_a_header_moves_the_node_ports_in_the_draft(
def test_a_shared_node_in_use_is_retired_only_with_detach(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
client.put(
f"{PREFIX}/shared", headers=superuser_token_headers, json=a_flow("shared")
)
put_flow(client, superuser_token_headers, a_flow("shared"), "shared")
client.put(
f"{PREFIX}/shared/nodes/sensor/source",
headers=superuser_token_headers,
@@ -571,9 +536,7 @@ def test_a_shared_node_only_the_published_flow_uses_is_kept(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""An unshare in the draft leaves the running flow on the source."""
client.put(
f"{PREFIX}/unshared", headers=superuser_token_headers, json=a_flow("unshared")
)
put_flow(client, superuser_token_headers, a_flow("unshared"), "unshared")
shared = client.post(
f"{PREFIX}/unshared/nodes/sensor/share",
headers=superuser_token_headers,
@@ -603,9 +566,7 @@ def test_a_shared_source_write_is_audited(
monkeypatch: pytest.MonkeyPatch,
) -> None:
"""It goes live at once, so it is recorded like a publish."""
client.put(
f"{PREFIX}/audited", headers=superuser_token_headers, json=a_flow("audited")
)
put_flow(client, superuser_token_headers, a_flow("audited"), "audited")
client.post(
f"{PREFIX}/audited/nodes/sensor/share",
headers=superuser_token_headers,
@@ -96,10 +96,10 @@ def test_a_flow_that_cannot_run_makes_the_summary_degraded(
controller = client.app.state.flow_controller
before = controller.issues
before_flows = controller.store.list_flows
before_flows = controller.store.key_index
# The looping flow has to be one the store lists, otherwise "running"
# counts nothing either way and the assertion below proves nothing.
controller.store.list_flows = lambda: ["looping"]
controller.store.key_index = lambda: {"looping": "f_looping"}
controller.issues = [
ValidationIssue(
code="cycle",
@@ -119,7 +119,7 @@ def test_a_flow_that_cannot_run_makes_the_summary_degraded(
body = client.get(f"{PREFIX}/summary", headers=superuser_token_headers).json()
finally:
controller.issues = before
controller.store.list_flows = before_flows
controller.store.key_index = before_flows
assert body["status"] == "degraded"
assert body["flows"]["invalid"] == 1
+21 -16
View File
@@ -7,6 +7,7 @@ from fastapi.testclient import TestClient
from fluksio.api.routes.search import MASK, setting_text
from fluksio.core.config import settings
from tests.utils.flows import put_dashboard, put_flow
PREFIX = f"{settings.API_V1_STR}/search"
FLOWS = f"{settings.API_V1_STR}/flows"
@@ -22,19 +23,20 @@ def test_index_reaches_inside_flows_and_dashboards(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""A node and a widget are the point: neither is on any list endpoint."""
client.put(
f"{FLOWS}/searchable",
headers=superuser_token_headers,
json={
put_flow(
client,
superuser_token_headers,
{
"name": "searchable",
"title": "Searchable",
"nodes": [{"id": "sensor", "type": "python", "title": "Hall sensor"}],
},
"searchable",
)
client.put(
f"{DASHBOARDS}/hall",
headers=superuser_token_headers,
json={
put_dashboard(
client,
superuser_token_headers,
{
"name": "hall",
"title": "Hall",
"widgets": [
@@ -48,6 +50,7 @@ def test_index_reaches_inside_flows_and_dashboards(
],
"version": 0,
},
"hall",
)
entries = client.get(f"{PREFIX}/", headers=superuser_token_headers).json()
@@ -69,15 +72,16 @@ def test_index_lists_a_flows_inputs_and_outputs(
client: TestClient, superuser_token_headers: dict[str, str]
) -> None:
"""Named by the qualified message, which is the label the canvas draws."""
client.put(
f"{FLOWS}/fit",
headers=superuser_token_headers,
json={
put_flow(
client,
superuser_token_headers,
{
"name": "fit",
"mode": "batch",
"inputs": [{"spec": {"name": "epochs", "dtype": "int"}}],
"outputs": ["accuracy"],
},
"fit",
)
entries = client.get(f"{PREFIX}/", headers=superuser_token_headers).json()
@@ -151,10 +155,10 @@ def test_index_lists_a_nodes_settings(
normal_user_token_headers: dict[str, str],
) -> None:
"""A setting is found by its node and name, with its value beside it."""
client.put(
f"{FLOWS}/tuned",
headers=superuser_token_headers,
json={
put_flow(
client,
superuser_token_headers,
{
"name": "tuned",
"nodes": [
{"id": "gain", "type": "python", "params": {"factor": 2.5}},
@@ -169,6 +173,7 @@ def test_index_lists_a_nodes_settings(
},
],
},
"tuned",
)
def settings_of(headers: dict[str, str]) -> tuple[dict[str, dict], str]:
+25 -15
View File
@@ -38,6 +38,13 @@ def api(client: TestClient, superuser_token_headers: dict[str, str]) -> Client:
return Client(http=client, token=superuser_token_headers["Authorization"][7:])
def flow_id(api: Client, key: str) -> str:
"""The id sync stored the flow with key *key* under."""
found = api.find_flow(key)
assert found is not None, key
return str(found["id"])
def commits() -> int:
"""How many commits the flow store has made."""
from fluksio.flow.store import FlowStore
@@ -62,14 +69,14 @@ def test_sync_stores_a_runnable_flow_with_its_origin(api, flows):
assert [r.flow for r in reports] == ["train"]
assert reports[0].created and reports[0].published
stored = api.get_flow("train")
stored = api.get_flow(flow_id(api, "train"))
definition = stored["definition"]
assert definition["origin"]["commit"] == "a1b2c3d4"
assert [n["id"] for n in definition["nodes"]] == ["prepare", "fit", "evaluate"]
assert not stored["has_draft"]
# The store holds a complete definition, and the bodies say where the real
# code is rather than being a copy of it.
source = api.get_source("train", "fit")
source = api.get_source(definition["id"], "fit")
assert source.startswith(MARKER)
assert "from myresearch.train import fit" in source
@@ -79,7 +86,7 @@ def test_a_flow_read_by_another_process_syncs_as_the_flow_does(api, flows):
carried = Declared(flows["train"].declaration())
sync([carried], api, origin=ORIGIN)
stored = api.get_flow("train")["definition"]
stored = api.get_flow(flow_id(api, "train"))["definition"]
assert stored["origin"]["declared_in"] == "myresearch/pipeline.py"
# Nothing differs from what the flow itself would have stored.
@@ -90,7 +97,8 @@ def test_a_node_carries_the_modules_its_code_reaches(api, flows):
"""The shim names one function; the cache has to key on what it calls."""
sync([flows["train"]], api, origin=ORIGIN)
nodes = {n["id"]: n for n in api.get_flow("train")["definition"]["nodes"]}
definition = api.get_flow(flow_id(api, "train"))["definition"]
nodes = {n["id"]: n for n in definition["nodes"]}
files = nodes["fit"]["code_files"]
# The module the function is in, and the package whose `__init__` runs on
@@ -156,14 +164,15 @@ def test_a_second_sync_changes_nothing_and_commits_nothing(api, flows):
def test_sync_refuses_to_overwrite_a_canvas_edit(api, flows):
sync([flows["train"]], api, origin=ORIGIN)
api.put_source("train", "evaluate", "def process(weights):\n return {}\n")
train = flow_id(api, "train")
api.put_source(train, "evaluate", "def process(weights):\n return {}\n")
with pytest.raises(SyncError, match="edited on the canvas"):
sync([flows["train"]], api, origin=ORIGIN)
reports = sync([flows["train"]], api, origin=ORIGIN, force=True)
assert "evaluate" in reports[0].changed
assert api.get_source("train", "evaluate").startswith(MARKER)
assert api.get_source(train, "evaluate").startswith(MARKER)
def test_an_interrupted_sync_finishes_on_the_next_one(api, flows):
@@ -177,23 +186,23 @@ def test_an_interrupted_sync_finishes_on_the_next_one(api, flows):
target = flows["train"]
target.name = "resumed"
try:
# Exactly what the document PUT leaves behind before any body is written.
api.put_flow(target.document(ORIGIN) | {"version": 1})
assert api.get_source_entry("resumed", "fit")["missing"]
# Exactly what creating the document leaves before any body is written.
resumed = api.create_flow(target.document(ORIGIN))["definition"]["id"]
assert api.get_source_entry(resumed, "fit")["missing"]
reports = sync([target], api, origin=ORIGIN)
assert "fit" in reports[0].changed
assert api.get_source("resumed", "fit").startswith(MARKER)
assert not api.get_source_entry("resumed", "fit")["missing"]
assert not api.get_flow("resumed")["has_draft"]
assert api.get_source(resumed, "fit").startswith(MARKER)
assert not api.get_source_entry(resumed, "fit")["missing"]
assert not api.get_flow(resumed)["has_draft"]
finally:
target.name = "train"
def test_sync_refuses_a_flow_it_did_not_create(api, flows):
api.put_flow({"name": "drawn", "version": 1, "nodes": [], "mode": "batch"})
api.publish("drawn", 1)
drawn = api.create_flow({"name": "drawn", "nodes": [], "mode": "batch"})
api.publish(drawn["definition"]["id"], 1)
theirs = flows["train"]
theirs.name = "drawn"
@@ -207,7 +216,8 @@ def test_sync_refuses_a_flow_it_did_not_create(api, flows):
def test_use_stores_the_rewiring_it_was_given(api, flows):
sync([flows["finetune"]], api, origin=ORIGIN)
nodes = {n["id"]: n for n in api.get_flow("finetune")["definition"]["nodes"]}
definition = api.get_flow(flow_id(api, "finetune"))["definition"]
nodes = {n["id"]: n for n in definition["nodes"]}
assert [p["name"] for p in nodes["fit"]["requires"]] == ["augmented", "lr"]
assert nodes["fit"]["params"] == {"epochs": 3}
+3 -4
View File
@@ -16,6 +16,7 @@ from fluksio.core.config import settings
from fluksio.core.db import engine as db_engine
from fluksio.models import Run, RunArtifact
from tests.flow.conftest import FakeWren
from tests.utils.flows import put_flow
FLOW = "wren_house"
PREFIX = f"{settings.API_V1_STR}/flows/{FLOW}/nodes"
@@ -70,10 +71,8 @@ def house(
{"id": "sensor", "type": "python"},
]
url = f"{settings.API_V1_STR}/flows/{FLOW}"
saved = client.put(
url, headers=superuser_token_headers, json={"name": FLOW, "nodes": nodes}
)
assert saved.status_code == 200, saved.text
saved = put_flow(client, superuser_token_headers, {"name": FLOW, "nodes": nodes})
assert saved.is_success, saved.text
yield
client.delete(url, headers=superuser_token_headers)