Compare commits
11 changed files with 33 additions and 349 deletions
|
|
@ -204,17 +204,14 @@ counts as an agent.
|
|||
**The API.** The router answers two NATS requests from swarm-controller, which
|
||||
serves them next to `GET /api/notify/flows`:
|
||||
|
||||
| Route | Router subject | Answers |
|
||||
| ---------------------------- | ------------------------------ | -------------------------------------------------------------------------------------------- |
|
||||
| `GET /api/notify/deliveries` | `$SWARM.router.api.deliveries` | the newest rows, newest first; `?limit=` up to 500, 100 by default |
|
||||
| `GET /api/notify/dry-run` | `$SWARM.router.api.dry-run` | the saved flows document, run over the newest 50 events |
|
||||
| `POST /api/notify/dry-run` | `$SWARM.router.api.dry-run` | the body's draft flows document, checked as a `PUT` checks it, run over the newest 50 events |
|
||||
| Route | Router subject | Answers |
|
||||
| ---------------------------- | ------------------------------ | ------------------------------------------------------------------ |
|
||||
| `GET /api/notify/deliveries` | `$SWARM.router.api.deliveries` | the newest rows, newest first; `?limit=` up to 500, 100 by default |
|
||||
| `GET /api/notify/dry-run` | `$SWARM.router.api.dry-run` | the saved flows document, run over the newest 50 events |
|
||||
|
||||
The dry-run request carries a whole document. The `GET` sends the saved one;
|
||||
the `POST` takes a `PUT` body (it ignores a `revision`), answers 400
|
||||
with the `PUT` error for a document that fails the check, and forwards a valid one.
|
||||
[`/notifications`](ui.md#notification-flows) shows both: the recent deliveries,
|
||||
and the counts beside each node.
|
||||
The dry-run request carries a whole document, so a draft runs the same way.
|
||||
The controller sends the saved one. [`/notifications`](ui.md#notification-flows)
|
||||
shows both: the recent deliveries, and the counts beside each node.
|
||||
|
||||
**Deploying in any order.** A router that predates these subjects doesn't
|
||||
subscribe to them, and the queue answers the controller's request at once with
|
||||
|
|
|
|||
|
|
@ -296,12 +296,6 @@ editor offers to reload and drop your edits, or to keep them and replace this
|
|||
flow's latest version with them. For any other refusal the editor shows the
|
||||
controller's own message. The router runs a saved flow from its next event.
|
||||
|
||||
**preview** runs the draft, saved or not, over the newest forge events and
|
||||
shows on each box how many of them reached it, as a dry run does for the saved
|
||||
flows in the list. It needs no save, so you can try a half-built flow. The
|
||||
numbers go as soon as you edit the flow. If the draft would not save, or the
|
||||
router can't run a dry run yet, the controller's own message shows instead.
|
||||
|
||||
Leaving the page with unsaved edits asks first, whether you close or reload the
|
||||
tab, follow a link in the app, or press the browser's back button. Choose
|
||||
**leave and drop edits** to go on, or cancel to stay and save.
|
||||
|
|
|
|||
|
|
@ -10,14 +10,6 @@ import { NODE_HEIGHT, NODE_WIDTH } from "./FlowLayout.js";
|
|||
|
||||
const PAD = 10;
|
||||
|
||||
// The long kind name would run into the aside beside it.
|
||||
const SHORT_KIND: Record<string, string> = { request_reviewer: "reviewer" };
|
||||
|
||||
// "1 hit", "0 hits": how the box says how many events reached it.
|
||||
export function hitsText(hits: number): string {
|
||||
return `${hits} ${hits === 1 ? "hit" : "hits"}`;
|
||||
}
|
||||
|
||||
export function BoxFace({
|
||||
kind,
|
||||
text,
|
||||
|
|
@ -31,14 +23,17 @@ export function BoxFace({
|
|||
// The events of the last dry run that reached the node, when one covers it.
|
||||
hits?: number;
|
||||
}) {
|
||||
const aside = [order, hits === undefined ? undefined : hitsText(hits)]
|
||||
const aside = [
|
||||
order,
|
||||
hits === undefined ? undefined : `${hits} ${hits === 1 ? "hit" : "hits"}`,
|
||||
]
|
||||
.filter((part) => part !== undefined)
|
||||
.join(" · ");
|
||||
return (
|
||||
<>
|
||||
<rect width={NODE_WIDTH} height={NODE_HEIGHT} rx="6" />
|
||||
<text class="notify-box-kind" x={PAD} y="17">
|
||||
{SHORT_KIND[kind] ?? kind}
|
||||
{kind}
|
||||
</text>
|
||||
{aside ? (
|
||||
<text
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ import {
|
|||
type Edit,
|
||||
type Limits,
|
||||
} from "./FlowDraft.js";
|
||||
import { BoxFace, hitsText } from "./FlowBox.js";
|
||||
import { BoxFace } from "./FlowBox.js";
|
||||
import { layoutFlow, neighbour, nodeAt } from "./FlowLayout.js";
|
||||
import { describeNode, ordinal, type Flow } from "./FlowTypes.js";
|
||||
|
||||
|
|
@ -66,15 +66,12 @@ export function FlowCanvas({
|
|||
selected,
|
||||
limits,
|
||||
palette,
|
||||
hits,
|
||||
...edits
|
||||
}: {
|
||||
flow: Flow;
|
||||
selected: string | null;
|
||||
limits: Limits;
|
||||
palette: PaletteKind[];
|
||||
// The events of a preview that reached each node, when one is showing.
|
||||
hits?: Map<string, number>;
|
||||
} & CanvasEdits) {
|
||||
const layout = layoutFlow(flow);
|
||||
const byId = new Map(flow.nodes.map((n) => [n.id, n]));
|
||||
|
|
@ -341,7 +338,7 @@ export function FlowCanvas({
|
|||
tabIndex={p.id === tabStop ? 0 : -1}
|
||||
role="button"
|
||||
aria-pressed={p.id === selected}
|
||||
aria-label={`${node.kind} ${p.id}: ${text}${order}${hits ? `, ${hitsText(hits.get(p.id) ?? 0)}` : ""}`}
|
||||
aria-label={`${node.kind} ${p.id}: ${text}${order}`}
|
||||
onPointerDown={(e) => {
|
||||
if (node.kind === "source") {
|
||||
// The source cannot move; a press just picks it.
|
||||
|
|
@ -362,7 +359,6 @@ export function FlowCanvas({
|
|||
order={
|
||||
pos.count > 1 ? `runs ${ordinal(pos.index + 1)}` : undefined
|
||||
}
|
||||
hits={hits ? (hits.get(p.id) ?? 0) : undefined}
|
||||
/>
|
||||
</g>
|
||||
);
|
||||
|
|
|
|||
|
|
@ -429,19 +429,6 @@ export function saveRequest(
|
|||
};
|
||||
}
|
||||
|
||||
// The `POST /api/notify/dry-run` request for the draft: the same document a
|
||||
// save sends, without a revision since nothing is stored.
|
||||
export function previewRequest(
|
||||
flows: Flow[],
|
||||
disabledBuiltins: string[],
|
||||
): { method: "POST"; headers: Record<string, string>; body: string } {
|
||||
return {
|
||||
method: "POST",
|
||||
headers: { "content-type": "application/json" },
|
||||
body: JSON.stringify({ disabled_builtins: disabledBuiltins, flows }),
|
||||
};
|
||||
}
|
||||
|
||||
export type SaveOutcome = "saved" | "conflict" | "invalid" | "error";
|
||||
|
||||
// What a save's HTTP status means to the editor: 409 is a stale revision (read
|
||||
|
|
|
|||
|
|
@ -38,7 +38,6 @@ import {
|
|||
reparent,
|
||||
savedAs,
|
||||
saveOutcome,
|
||||
previewRequest,
|
||||
saveRequest,
|
||||
seedFlow,
|
||||
parentOf,
|
||||
|
|
@ -49,7 +48,6 @@ import {
|
|||
import { useLeaveGuard } from "./useLeaveGuard.js";
|
||||
import { NodeInspector } from "./NodeInspector.js";
|
||||
import { FALLBACK_SCHEMA, type Flow, type FlowsView } from "./FlowTypes.js";
|
||||
import { DRY_RUN_URL, hitsOf, type DryRun } from "./RouterLive.js";
|
||||
import "./NotificationsPage.css";
|
||||
|
||||
const FLOWS_URL = "/api/notify/flows";
|
||||
|
|
@ -77,14 +75,6 @@ export function FlowEditorPage({
|
|||
const [saveError, setSaveError] = useState<ProblemDetails | null>(null);
|
||||
const [stale, setStale] = useState(false);
|
||||
const [notice, setNotice] = useState<string | null>(null);
|
||||
// The last preview and the draft it ran, which stops counting once the
|
||||
// draft is edited.
|
||||
const [preview, setPreview] = useState<{
|
||||
draft: Flow;
|
||||
flowId: string;
|
||||
dry: DryRun;
|
||||
} | null>(null);
|
||||
const [previewError, setPreviewError] = useState<ProblemDetails | null>(null);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [confirmDelete, setConfirmDelete] = useState(false);
|
||||
|
||||
|
|
@ -158,32 +148,6 @@ export function FlowEditorPage({
|
|||
return false;
|
||||
}
|
||||
|
||||
// Run the draft, saved or not, over the newest forge events, and put the
|
||||
// number each node would have caught on its box.
|
||||
async function runPreview() {
|
||||
if (!view || !draft) return;
|
||||
const flow = isNew ? savedAs(view, draft) : draft;
|
||||
setBusy(true);
|
||||
setPreviewError(null);
|
||||
try {
|
||||
const r = await fetch(
|
||||
DRY_RUN_URL,
|
||||
previewRequest(withFlow(view.flows, flow), view.disabled_builtins),
|
||||
);
|
||||
if (r.ok) {
|
||||
setPreview({ draft, flowId: flow.id, dry: (await r.json()) as DryRun });
|
||||
} else {
|
||||
setPreview(null);
|
||||
setPreviewError(await readApiError(r));
|
||||
}
|
||||
} catch (err) {
|
||||
setPreview(null);
|
||||
setPreviewError({ detail: String(err) });
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
function onEdit(result: Edit, select?: string) {
|
||||
if (!result.ok) {
|
||||
setNotice(result.reason);
|
||||
|
|
@ -253,8 +217,6 @@ export function FlowEditorPage({
|
|||
const schema = view.schema ?? FALLBACK_SCHEMA;
|
||||
const limits = limitsOf(view.schema);
|
||||
const node = draft.nodes.find((n) => n.id === selected) ?? null;
|
||||
const shown = preview?.draft === draft ? preview : null;
|
||||
const hits = shown ? hitsOf(shown.dry, shown.flowId) : undefined;
|
||||
|
||||
return (
|
||||
<Panel
|
||||
|
|
@ -279,12 +241,6 @@ export function FlowEditorPage({
|
|||
{saveError ? (
|
||||
<ApiErrorPanel context="the flow was not saved" problem={saveError} />
|
||||
) : null}
|
||||
{previewError ? (
|
||||
<ApiErrorPanel
|
||||
context="the preview did not run"
|
||||
problem={previewError}
|
||||
/>
|
||||
) : null}
|
||||
{notice ? (
|
||||
<p class="notify-notice" role="status">
|
||||
{notice}
|
||||
|
|
@ -332,9 +288,6 @@ export function FlowEditorPage({
|
|||
>
|
||||
discard edits
|
||||
</Button>
|
||||
<Button disabled={busy} onClick={() => void runPreview()}>
|
||||
preview
|
||||
</Button>
|
||||
{isNew ? null : (
|
||||
<Button disabled={busy} onClick={() => setConfirmDelete(true)}>
|
||||
delete flow
|
||||
|
|
@ -342,13 +295,6 @@ export function FlowEditorPage({
|
|||
)}
|
||||
</div>
|
||||
</div>
|
||||
{shown ? (
|
||||
<p class="notify-hint" role="status">
|
||||
{hits
|
||||
? `Preview: each box shows how many of the newest ${shown.dry.events} forge events reached it. Edit the flow and the numbers go.`
|
||||
: "The preview skipped this flow because it is off."}
|
||||
</p>
|
||||
) : null}
|
||||
|
||||
<div class="notify-editor-body">
|
||||
<FlowCanvas
|
||||
|
|
@ -356,7 +302,6 @@ export function FlowEditorPage({
|
|||
selected={selected}
|
||||
limits={limits}
|
||||
palette={paletteKinds(schema)}
|
||||
hits={hits}
|
||||
onSelect={setSelected}
|
||||
onAdd={(kind, parentId) => {
|
||||
const added = blankNode(draft, kind);
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
// Wire types and helpers for what the notification router reports about
|
||||
// itself: its deliveries log and a dry run of the saved flows, or with
|
||||
// `POST` of a draft. Backed by swarm-controller's
|
||||
// `GET /api/notify/deliveries` and `GET`/`POST /api/notify/dry-run`, which
|
||||
// answer 503 while the running router predates them.
|
||||
// itself: its deliveries log and a dry run of the saved flows. Backed by
|
||||
// swarm-controller's `GET /api/notify/deliveries` and
|
||||
// `GET /api/notify/dry-run`, which answer 503 while the running router
|
||||
// predates them.
|
||||
import type { ProblemDetails } from "@hive/shared/api-error.js";
|
||||
|
||||
export const DELIVERIES_URL = "/api/notify/deliveries";
|
||||
|
|
|
|||
|
|
@ -21,7 +21,6 @@ import {
|
|||
replaceNode,
|
||||
savedAs,
|
||||
saveOutcome,
|
||||
previewRequest,
|
||||
saveRequest,
|
||||
seedFlow,
|
||||
siblingPosition,
|
||||
|
|
@ -247,15 +246,6 @@ test("saveRequest sends the whole document at the revision read", () => {
|
|||
assert.equal("builtins" in body, false, "built-ins are never sent");
|
||||
});
|
||||
|
||||
test("previewRequest posts the document without a revision", () => {
|
||||
const req = previewRequest([flow()], ["b1"]);
|
||||
assert.equal(req.method, "POST");
|
||||
const body = JSON.parse(req.body);
|
||||
assert.deepEqual(body.disabled_builtins, ["b1"]);
|
||||
assert.equal(body.flows[0].id, "f");
|
||||
assert.equal("revision" in body, false, "nothing is stored, so no revision");
|
||||
});
|
||||
|
||||
test("saveOutcome tells a stale revision from a refused document", () => {
|
||||
assert.equal(saveOutcome(200), "saved");
|
||||
assert.equal(saveOutcome(409), "conflict");
|
||||
|
|
|
|||
|
|
@ -165,20 +165,6 @@ pub(crate) fn unreadable(why: &DecodeError) -> ProblemDetails {
|
|||
)
|
||||
}
|
||||
|
||||
/// The document a body describes, or the first way it fails
|
||||
/// [`Document::check`].
|
||||
pub(crate) fn checked_document(
|
||||
disabled_builtins: Vec<String>,
|
||||
flows: Vec<Flow>,
|
||||
) -> Result<Document, String> {
|
||||
let doc = Document {
|
||||
version: notify_flows::VERSION,
|
||||
disabled_builtins,
|
||||
flows,
|
||||
};
|
||||
doc.check().map(|()| doc)
|
||||
}
|
||||
|
||||
/// Replace the flows.
|
||||
#[utoipa::path(
|
||||
put,
|
||||
|
|
@ -210,7 +196,12 @@ pub(crate) async fn put_flows(
|
|||
body: Result<Json<PutFlows>, JsonRejection>,
|
||||
) -> Result<Json<FlowsView>, ProblemDetails> {
|
||||
let Json(put) = body.map_err(|e| error_problem(StatusCode::BAD_REQUEST, &e.body_text()))?;
|
||||
let doc = checked_document(put.disabled_builtins, put.flows)
|
||||
let doc = Document {
|
||||
version: notify_flows::VERSION,
|
||||
disabled_builtins: put.disabled_builtins,
|
||||
flows: put.flows,
|
||||
};
|
||||
doc.check()
|
||||
.map_err(|why| error_problem(StatusCode::BAD_REQUEST, &why))?;
|
||||
let client = queue(&state).map_err(refused)?;
|
||||
let store = open(&client).await.map_err(|e| queue_problem(&e))?;
|
||||
|
|
|
|||
|
|
@ -1,32 +1,28 @@
|
|||
//! `GET /api/notify/deliveries`, `GET /api/notify/dry-run` and
|
||||
//! `POST /api/notify/dry-run`: what the
|
||||
//! notification router has delivered, and what the saved flows, or a draft,
|
||||
//! would do with
|
||||
//! `GET /api/notify/deliveries` and `GET /api/notify/dry-run`: what the
|
||||
//! notification router has delivered, and what the saved flows would do with
|
||||
//! the newest forge events.
|
||||
//!
|
||||
//! The router keeps the log and the events, so each is a NATS request to it
|
||||
//! (`swarm_wire::router_api`). A router that predates them, or none at all,
|
||||
//! has no subscriber: the queue answers "no responders" at once and these
|
||||
//! answer 503 saying so, as they do when it hears the request and stays
|
||||
//! silent. The saved document is what `GET /api/notify/flows` shows; the `POST`
|
||||
//! sends the same request with the body's document, checked as a `PUT` checks
|
||||
//! it.
|
||||
//! silent. The saved document is what `GET /api/notify/flows` shows; a draft
|
||||
//! is run by sending the same request with another document.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::rejection::JsonRejection;
|
||||
use axum::extract::{Query, State};
|
||||
use axum::http::StatusCode;
|
||||
use problem_details::ProblemDetails;
|
||||
use serde::Deserialize;
|
||||
use serde::de::DeserializeOwned;
|
||||
use swarm_wire::notify_flows::{Document, Flow};
|
||||
use swarm_wire::notify_flows::Document;
|
||||
use swarm_wire::router_api::{
|
||||
DELIVERIES_SUBJECT, DRY_RUN_SUBJECT, Deliveries, DeliveriesRequest, DryRun, DryRunRequest,
|
||||
REPLY_DEADLINE, Refused,
|
||||
};
|
||||
use utoipa::{IntoParams, ToSchema};
|
||||
use utoipa::IntoParams;
|
||||
|
||||
use crate::notify_flows::{Stored, checked_document, open, queue_problem, stored, unreadable};
|
||||
use crate::notify_flows::{Stored, open, queue_problem, stored, unreadable};
|
||||
use crate::routes::{AppState, error_problem};
|
||||
use crate::schedules::{queue, refused};
|
||||
|
||||
|
|
@ -140,56 +136,8 @@ pub(crate) async fn get_dry_run(
|
|||
ask(&client, DRY_RUN_SUBJECT, body).await.map(Json)
|
||||
}
|
||||
|
||||
/// The body of `POST /api/notify/dry-run`: the document of a `PUT`, whose
|
||||
/// `revision` may be present and is ignored.
|
||||
#[derive(Debug, Clone, Deserialize, ToSchema)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub(crate) struct DraftFlows {
|
||||
/// Ignored.
|
||||
#[serde(default, rename = "revision")]
|
||||
_revision: u64,
|
||||
/// The ids of the built-in flows to switch off.
|
||||
#[serde(default)]
|
||||
disabled_builtins: Vec<String>,
|
||||
/// The custom flows.
|
||||
#[serde(default)]
|
||||
flows: Vec<Flow>,
|
||||
}
|
||||
|
||||
/// A draft flows document run over the newest 50 forge events, delivering and
|
||||
/// saving nothing: how many events reached each node.
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/api/notify/dry-run",
|
||||
request_body = DraftFlows,
|
||||
responses(
|
||||
(status = 200, description = "per flow that would run, the number of the newest 50 \
|
||||
events that reached each node", body = DryRun),
|
||||
(status = 400, description = "not JSON or not this shape, or the document fails the \
|
||||
check `PUT /api/notify/flows` applies (problem+json)", body = String),
|
||||
(status = 502, description = "the router refused, or its answer did not decode \
|
||||
(problem+json)", body = String),
|
||||
(status = 503, description = "no swarm queue is configured or connected here, or the \
|
||||
router does not answer: it is not running, or it predates the dry run \
|
||||
(problem+json)", body = String),
|
||||
),
|
||||
tag = "notify"
|
||||
)]
|
||||
pub(crate) async fn post_dry_run(
|
||||
State(state): State<AppState>,
|
||||
body: Result<Json<DraftFlows>, JsonRejection>,
|
||||
) -> Result<Json<DryRun>, ProblemDetails> {
|
||||
let Json(draft) = body.map_err(|e| error_problem(StatusCode::BAD_REQUEST, &e.body_text()))?;
|
||||
let document = checked_document(draft.disabled_builtins, draft.flows)
|
||||
.map_err(|why| error_problem(StatusCode::BAD_REQUEST, &why))?;
|
||||
let client = queue(&state).map_err(refused)?;
|
||||
let body = serde_json::to_vec(&DryRunRequest { document }).expect("a request encodes");
|
||||
ask(&client, DRY_RUN_SUBJECT, body).await.map(Json)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use axum::extract::rejection::MissingJsonContentType;
|
||||
use futures_util::StreamExt as _;
|
||||
use swarm_wire::notify_flows::{self, Document};
|
||||
use swarm_wire::router_api::{FlowHits, NodeHits};
|
||||
|
|
@ -384,160 +332,4 @@ mod tests {
|
|||
let unreadable = get_dry_run(State(state)).await.expect_err("version 2");
|
||||
assert_eq!(unreadable.status, Some(StatusCode::CONFLICT));
|
||||
}
|
||||
|
||||
fn draft(flows: &serde_json::Value) -> Json<DraftFlows> {
|
||||
Json(
|
||||
serde_json::from_value(serde_json::json!({
|
||||
"revision": 7,
|
||||
"disabled_builtins": ["closed"],
|
||||
"flows": flows,
|
||||
}))
|
||||
.expect("a draft"),
|
||||
)
|
||||
}
|
||||
|
||||
fn sink_flow(id: &str) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"id": id, "name": "n", "enabled": true,
|
||||
"nodes": [
|
||||
{"id": "source", "kind": "source", "events": ["issues"]},
|
||||
{"id": "sink", "kind": "todo", "to": {"agent": "triage"}, "op": "upsert",
|
||||
"key": "k", "prefix": false, "text": "t"},
|
||||
],
|
||||
"edges": [{"from": "source", "to": "sink"}],
|
||||
})
|
||||
}
|
||||
|
||||
/// A valid draft reaches the router as the request's document, with the
|
||||
/// body's `revision` dropped, and the router's counts come back.
|
||||
#[tokio::test]
|
||||
async fn a_valid_draft_is_forwarded_and_the_counts_come_back() {
|
||||
let nats = TestNats::start();
|
||||
let client = nats.client().await;
|
||||
let state = crate::agent_limits::tests::state(&client);
|
||||
let reply = DryRun {
|
||||
events: 2,
|
||||
flows: vec![FlowHits {
|
||||
flow: "mine".to_owned(),
|
||||
nodes: vec![NodeHits {
|
||||
node: "source".to_owned(),
|
||||
hits: 2,
|
||||
}],
|
||||
}],
|
||||
};
|
||||
let router = answer(
|
||||
&client,
|
||||
DRY_RUN_SUBJECT,
|
||||
serde_json::to_vec(&reply).unwrap(),
|
||||
)
|
||||
.await;
|
||||
let Json(got) = post_dry_run(
|
||||
State(state),
|
||||
Ok(draft(&serde_json::json!([sink_flow("mine")]))),
|
||||
)
|
||||
.await
|
||||
.expect("answered");
|
||||
assert_eq!(got, reply);
|
||||
let sent: DryRunRequest =
|
||||
serde_json::from_slice(&router.await.expect("task")).expect("a request");
|
||||
assert_eq!(sent.document.disabled_builtins, ["closed"]);
|
||||
assert_eq!(sent.document.flows.len(), 1);
|
||||
assert_eq!(sent.document.flows[0].id, "mine");
|
||||
}
|
||||
|
||||
/// A tree that fails the check is 400 with `PUT`'s message and never
|
||||
/// reaches the router; a body that is not a document is 400 too. The
|
||||
/// control is the valid draft above, which the same router subscription
|
||||
/// would have received.
|
||||
#[tokio::test]
|
||||
async fn an_invalid_draft_is_400_and_never_forwarded() {
|
||||
let nats = TestNats::start();
|
||||
let client = nats.client().await;
|
||||
let state = crate::agent_limits::tests::state(&client);
|
||||
let mut requests = client.subscribe(DRY_RUN_SUBJECT).await.expect("subscribed");
|
||||
client.flush().await.expect("flushed");
|
||||
|
||||
let mut orphan = sink_flow("orphan");
|
||||
orphan["edges"] = serde_json::json!([]);
|
||||
let refused = post_dry_run(
|
||||
State(state.clone()),
|
||||
Ok(draft(&serde_json::json!([orphan]))),
|
||||
)
|
||||
.await
|
||||
.expect_err("an orphan node");
|
||||
assert_eq!(refused.status, Some(StatusCode::BAD_REQUEST));
|
||||
let put = checked_document(
|
||||
Vec::new(),
|
||||
serde_json::from_value(serde_json::json!([{
|
||||
"id": "orphan", "name": "n", "enabled": true,
|
||||
"nodes": [
|
||||
{"id": "source", "kind": "source", "events": ["issues"]},
|
||||
{"id": "sink", "kind": "todo", "to": {"agent": "triage"}, "op": "upsert",
|
||||
"key": "k", "prefix": false, "text": "t"},
|
||||
],
|
||||
"edges": [],
|
||||
}]))
|
||||
.unwrap(),
|
||||
)
|
||||
.expect_err("the same check");
|
||||
assert_eq!(
|
||||
refused.detail.as_deref(),
|
||||
Some(put.as_str()),
|
||||
"PUT's message"
|
||||
);
|
||||
|
||||
let typo: Result<Json<DraftFlows>, JsonRejection> = Err(
|
||||
JsonRejection::MissingJsonContentType(MissingJsonContentType::default()),
|
||||
);
|
||||
let refused = post_dry_run(State(state.clone()), typo)
|
||||
.await
|
||||
.expect_err("not json");
|
||||
assert_eq!(refused.status, Some(StatusCode::BAD_REQUEST));
|
||||
|
||||
// Nothing was forwarded: the next request on the subject is the
|
||||
// control's, not either refusal's.
|
||||
let control = post_dry_run(
|
||||
State(state),
|
||||
Ok(draft(&serde_json::json!([sink_flow("ok")]))),
|
||||
);
|
||||
let (sent, got) = tokio::join!(
|
||||
async {
|
||||
let m = requests.next().await.expect("the control's request");
|
||||
let sent: DryRunRequest = serde_json::from_slice(&m.payload).expect("request");
|
||||
client
|
||||
.publish(
|
||||
m.reply.expect("reply"),
|
||||
serde_json::to_vec(&DryRun {
|
||||
events: 0,
|
||||
flows: Vec::new(),
|
||||
})
|
||||
.unwrap()
|
||||
.into(),
|
||||
)
|
||||
.await
|
||||
.expect("answered");
|
||||
sent
|
||||
},
|
||||
control
|
||||
);
|
||||
assert_eq!(sent.document.flows[0].id, "ok");
|
||||
assert!(got.is_ok());
|
||||
}
|
||||
|
||||
/// With no router the draft is 503; with no queue it is 503 too.
|
||||
#[tokio::test]
|
||||
async fn a_draft_without_a_router_is_unavailable() {
|
||||
let nats = TestNats::start();
|
||||
let client = nats.client().await;
|
||||
let state = crate::agent_limits::tests::state(&client);
|
||||
let b = post_dry_run(State(state), Ok(draft(&serde_json::json!([]))))
|
||||
.await
|
||||
.expect_err("nobody answers");
|
||||
assert_eq!(b.status, Some(StatusCode::SERVICE_UNAVAILABLE));
|
||||
let (state, _) = crate::routes::tests::state_with_roster();
|
||||
let b = post_dry_run(State(state), Ok(draft(&serde_json::json!([]))))
|
||||
.await
|
||||
.expect_err("no queue");
|
||||
assert_eq!(b.status, Some(StatusCode::SERVICE_UNAVAILABLE));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -645,10 +645,7 @@ pub(crate) fn build_app(state: AppState) -> axum::Router {
|
|||
))
|
||||
.routes(routes!(notify_flows::get_flows, notify_flows::put_flows))
|
||||
.routes(routes!(notify_router_api::get_deliveries))
|
||||
.routes(routes!(
|
||||
notify_router_api::get_dry_run,
|
||||
notify_router_api::post_dry_run
|
||||
))
|
||||
.routes(routes!(notify_router_api::get_dry_run))
|
||||
.routes(routes!(webhook::post_webhook_forge))
|
||||
.split_for_parts();
|
||||
// Just the JSON, not the UI — Swagger UI itself is nginx-hosted from
|
||||
|
|
|
|||
Loading…
Reference in a new issue