CLI: handle gRPC and WebSocket requests, keep IDs on Yaak import (#816)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Gregory SchierandClaude Opus 5.5 authored and GitHub committed 2026-11-10 13:47:25 -07:00
1 parent c0bfe7a97a
commit eba8dd5864
13 files changed
+1947 -197

No files matched your search

@@ -1,6 +1,6 @@
mod common;
use common::{cli_cmd, parse_created_id, query_manager, seed_request};
use common::{cli_cmd, parse_created_id, query_manager, seed_folder, seed_request, seed_workspace};
use predicates::str::contains;
use serde_json::Value;
use tempfile::TempDir;
@@ -322,3 +322,249 @@ fn re_import_leaves_deleted_resources_alone() {
assert_eq!(requests.len(), 1, "a deleted request must not come back: {requests:?}");
assert_eq!(requests[0].name, "Request A");
}
fn path_str(path: &std::path::Path) -> &str {
path.to_str().expect("path is utf-8")
}
fn created_id(data_dir: &std::path::Path, args: &[&str]) -> String {
let assert = cli_cmd(data_dir).args(args).assert().success();
parse_created_id(&assert.get_output().stdout, &args.join(" "))
}
/// A workspace made the way the skill describes: base and Staging environments and a request.
/// Returns the workspace, base environment, Staging environment, and request IDs.
fn cli_made_workspace(data_dir: &std::path::Path) -> (String, String, String, String) {
let workspace_id = created_id(data_dir, &["workspace", "create", "--name", "CI WS"]);
let list = cli_cmd(data_dir).args(["environment", "list", &workspace_id]).assert().success();
let base_id = String::from_utf8_lossy(&list.get_output().stdout)
.lines()
.find(|l| l.ends_with("(workspace)"))
.and_then(|l| l.split_whitespace().next())
.expect("base environment listed")
.to_string();
let staging_id =
created_id(data_dir, &["environment", "create", &workspace_id, "--name", "Staging"]);
let request_id = created_id(
data_dir,
&[
"request",
"create",
&workspace_id,
"--name",
"Health",
"--url",
"https://example.com",
],
);
(workspace_id, base_id, staging_id, request_id)
}
fn read_json(path: &std::path::Path) -> Value {
serde_json::from_str(&std::fs::read_to_string(path).expect("read file")).expect("JSON")
}
/// QA sweep bug 2: `yaak import req_in_existing_folder.json --workspace-id <W>` put requests
/// that name an existing folder of W at the workspace root.
#[test]
fn import_keeps_a_folder_id_that_names_an_existing_folder() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
let import_path = temp_dir.path().join("req_in_existing_folder.json");
seed_workspace(data_dir, "wk_target");
seed_folder(data_dir, "wk_target", "fl_existing");
std::fs::write(
&import_path,
r#"{"yaakVersion":"test","yaakSchema":4,"resources":{"workspaces":[],"environments":[],"folders":[],
"httpRequests":[{"model":"http_request","id":"rq_newinfold1","workspaceId":"wk_target","folderId":"fl_existing","name":"Into existing","method":"GET","url":"http://127.0.0.1/x"}],
"grpcRequests":[{"model":"grpc_request","id":"gr_newinfold1","workspaceId":"wk_target","folderId":"fl_existing","name":"gRPC into existing","url":"127.0.0.1:50051"}],
"websocketRequests":[]}}"#,
)
.expect("write fixture");
cli_cmd(data_dir)
.args([
"import",
path_str(&import_path),
"--workspace-id",
"wk_target",
])
.assert()
.success()
.stdout(contains("Imported 1 HTTP request, 1 gRPC request"));
let query_manager = query_manager(data_dir);
let db = query_manager.connect();
let http = db.list_http_requests("wk_target").expect("list HTTP");
let grpc = db.list_grpc_requests("wk_target").expect("list gRPC");
assert_eq!(http[0].folder_id.as_deref(), Some("fl_existing"), "{http:?}");
assert_eq!(grpc[0].folder_id.as_deref(), Some("fl_existing"), "{grpc:?}");
}
/// QA sweep bug 3: `yaak export e.json <W>`, edit the file, `yaak import e.json --workspace-id
/// <W>` made copies with new IDs, a second base environment, and "(Imported)" environments.
#[test]
fn re_importing_an_edited_export_updates_the_workspace_in_place() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
let export_path = temp_dir.path().join("exp.json");
let (workspace_id, base_id, staging_id, request_id) = cli_made_workspace(data_dir);
cli_cmd(data_dir)
.args([
"export",
path_str(&export_path),
&workspace_id,
"--include-private",
])
.assert()
.success();
let mut exported = read_json(&export_path);
exported["resources"]["httpRequests"][0]["name"] = "Health (edited)".into();
std::fs::write(&export_path, exported.to_string()).expect("write edited export");
cli_cmd(data_dir)
.args([
"import",
path_str(&export_path),
"--workspace-id",
&workspace_id,
])
.assert()
.success()
.stdout(contains("Imported 1 HTTP request"));
let query_manager = query_manager(data_dir);
let db = query_manager.connect();
let requests = db.list_http_requests(&workspace_id).expect("list requests");
assert_eq!(requests.len(), 1, "no copies: {requests:?}");
assert_eq!(requests[0].id, request_id);
assert_eq!(requests[0].name, "Health (edited)");
let mut environment_ids =
db.list_environments(&workspace_id).expect("list environments").into_iter().map(|e| e.id);
let mut expected = vec![base_id.clone(), staging_id];
expected.sort();
let mut actual = environment_ids.by_ref().collect::<Vec<_>>();
actual.sort();
assert_eq!(actual, expected, "no second base environment and no Imported copies");
assert_eq!(db.get_base_environment(&workspace_id).expect("base").id, base_id);
}
/// QA sweep bug 7: the skill's CI recipe, `yaak export` then `yaak import` into a fresh
/// `--data-dir`, gave every model a new ID, so the IDs in the recipe no longer worked.
#[test]
fn import_into_a_fresh_data_dir_keeps_the_ids() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path().join("dev");
let ci_dir = temp_dir.path().join("ci");
let export_path = temp_dir.path().join("ci-export.json");
let (workspace_id, base_id, staging_id, request_id) = cli_made_workspace(&data_dir);
cli_cmd(&data_dir)
.args([
"export",
path_str(&export_path),
&workspace_id,
"--include-private",
])
.assert()
.success();
cli_cmd(&ci_dir).args(["import", path_str(&export_path)]).assert().success();
let query_manager = query_manager(&ci_dir);
let db = query_manager.connect();
assert_eq!(db.get_workspace(&workspace_id).expect("workspace keeps its ID").name, "CI WS");
assert_eq!(db.get_http_request(&request_id).expect("request keeps its ID").name, "Health");
assert_eq!(db.get_base_environment(&workspace_id).expect("base").id, base_id);
assert_eq!(db.get_environment(&staging_id).expect("Staging keeps its ID").name, "Staging");
}
/// QA sweep bug 8: there was no `--include-private`, so the environments the CLI makes, which
/// are private like the app's, could not be exported without the long flag.
#[test]
fn export_includes_cli_made_environments_only_with_include_private() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
let export_path = temp_dir.path().join("export.json");
let (workspace_id, base_id, staging_id, _) = cli_made_workspace(data_dir);
let exported_ids = |args: &[&str]| {
cli_cmd(data_dir).args(["export", path_str(&export_path)]).args(args).assert().success();
let mut ids = read_json(&export_path)["resources"]["environments"]
.as_array()
.expect("environments")
.iter()
.map(|e| e["id"].as_str().expect("id").to_string())
.collect::<Vec<_>>();
ids.sort();
ids
};
assert!(exported_ids(&[&workspace_id]).is_empty(), "CLI-made environments are private");
let mut all = vec![base_id, staging_id];
all.sort();
assert_eq!(exported_ids(&[&workspace_id, "--include-private"]), all);
assert_eq!(exported_ids(&[&workspace_id, "--include-private-environments"]), all);
}
/// QA sweep bug 15: the planner's warnings, such as IDs taken by another workspace, were
/// computed and then never printed.
#[test]
fn import_prints_the_plan_warnings_after_the_counts() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
let export_path = temp_dir.path().join("e9.json");
let (workspace_id, ..) = cli_made_workspace(data_dir);
let other_id = created_id(data_dir, &["workspace", "create", "--name", "Other WS"]);
cli_cmd(data_dir)
.args([
"export",
path_str(&export_path),
&workspace_id,
"--include-private",
])
.assert()
.success();
cli_cmd(data_dir)
.args(["import", path_str(&export_path), "--workspace-id", &other_id])
.assert()
.success()
.stdout(contains("Imported 2 environments, 1 HTTP request"))
.stderr(contains(
"Warning: New IDs assigned: 3 resources already exist in CI WS, so the imported copies get new IDs",
))
.stderr(contains("Warning: Base environment kept separate:"));
cli_cmd(data_dir)
.args(["import", path_str(&export_path)])
.assert()
.success()
.stderr(contains("Warning: New IDs assigned: 4 resources already exist in CI WS"));
}
/// QA sweep bug 16: `yaak import e_two.json --workspace-id <W>` merged both workspaces of the
/// file into W.
#[test]
fn import_with_workspace_id_refuses_a_file_with_several_workspaces() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
let export_path = temp_dir.path().join("e_two.json");
let first = created_id(data_dir, &["workspace", "create", "--name", "First"]);
let second = created_id(data_dir, &["workspace", "create", "--name", "Second"]);
seed_request(data_dir, &first, "rq_first");
cli_cmd(data_dir).args(["export", path_str(&export_path), &first, &second]).assert().success();
let target = created_id(data_dir, &["workspace", "create", "--name", "Target"]);
cli_cmd(data_dir)
.args(["import", path_str(&export_path), "--workspace-id", &target])
.assert()
.failure()
.stderr(contains("contains 2 workspaces"))
.stderr(contains("without --workspace-id to import each as its own workspace"));
let query_manager = query_manager(data_dir);
assert!(query_manager.connect().list_http_requests(&target).expect("list").is_empty());
}
+45 -2
View File
@@ -223,6 +223,47 @@ async fn mcp_send_settings_reach_template_functions() {
assert!(child.wait().await.unwrap().success());
}
/// QA sweep bug 6: the CLI has no window, so `show_toast` prints the toast to stderr (stdout is
/// the protocol channel) the way the CLI prints plugin toasts, and reports it as shown.
#[tokio::test]
async fn mcp_show_toast_prints_the_message_to_stderr() {
use tokio::io::AsyncReadExt;
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
seed_workspace(data_dir, "wk_test");
let mut child = Command::new(env!("CARGO_BIN_EXE_yaak"))
.arg("--data-dir")
.arg(data_dir)
.arg("mcp")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true)
.spawn()
.unwrap();
let mut stderr = child.stderr.take().unwrap();
let io = (child.stdout.take().unwrap(), child.stdin.take().unwrap());
let client = ().serve(io).await.unwrap();
let arguments = json!({ "message": "Build finished" });
let Value::Object(arguments) = arguments else {
unreachable!()
};
let result = client
.call_tool(CallToolRequestParams::new("show_toast").with_arguments(arguments))
.await
.unwrap();
assert_ne!(result.is_error, Some(true), "{result:?}");
assert_eq!(result.content[0].as_text().unwrap().text, "✓ Toast shown: \"Build finished\"");
client.cancel().await.unwrap();
child.kill().await.unwrap();
let mut output = String::new();
stderr.read_to_string(&mut output).await.unwrap();
assert!(output.lines().any(|l| l == "[mcp] Build finished"), "stderr: {output}");
}
/// Spawns `yaak mcp --http` with `args` and returns the child, the URL it
/// printed, and the token it printed or was given.
async fn spawn_http(data_dir: &std::path::Path, args: &[&str]) -> (tokio::process::Child, String, String) {
@@ -283,7 +324,9 @@ async fn post(
.last()
.map(str::trim)
.unwrap_or(text.trim());
(status, headers, serde_json::from_str(message).ok())
// A plain-text body, such as the reason for a 500, comes back as a string to show
let body = serde_json::from_str(message).unwrap_or_else(|_| Value::String(text.clone()));
(status, headers, Some(body))
}
#[tokio::test]
@@ -309,7 +352,7 @@ async fn mcp_http_requires_the_token() {
let auth = Some("Bearer s3cret");
let (status, headers, body) = post(&client, &url, auth, None, initialize).await;
assert_eq!(status, reqwest::StatusCode::OK);
assert_eq!(status, reqwest::StatusCode::OK, "initialize answered {body:?}");
let session = headers["mcp-session-id"].to_str().unwrap().to_string();
assert_eq!(body.unwrap()["result"]["serverInfo"]["name"], "yaak-mcp-server");
@@ -289,3 +289,81 @@ fn request_send_websocket_returns_explicit_nyi_error() {
.code(1)
.stderr(contains("WebSocket request send is not implemented yet in yaak-cli"));
}
/// QA sweep bug 1: `request list`, `show`, `update` and `delete` were HTTP-only, so gRPC and
/// WebSocket requests were missing from the list and failed everywhere else.
#[test]
fn request_commands_handle_grpc_and_websocket_requests() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
seed_workspace(data_dir, "wk_test");
seed_request(data_dir, "wk_test", "rq_types");
seed_grpc_request(data_dir, "wk_test", "gr_types");
seed_websocket_request(data_dir, "wk_test", "wr_types");
cli_cmd(data_dir)
.args(["request", "list", "wk_test"])
.assert()
.success()
.stdout(contains("rq_types - GET Seeded Request"))
.stdout(contains("gr_types - gRPC Seeded gRPC Request"))
.stdout(contains("wr_types - WebSocket Seeded WebSocket Request"));
cli_cmd(data_dir)
.args(["request", "show", "gr_types"])
.assert()
.success()
.stdout(contains("\"model\": \"grpc_request\""));
cli_cmd(data_dir)
.args(["request", "show", "wr_types"])
.assert()
.success()
.stdout(contains("\"model\": \"websocket_request\""));
cli_cmd(data_dir)
.args([
"request",
"update",
r#"{"id":"wr_types","name":"Renamed Socket"}"#,
])
.assert()
.success()
.stdout(contains("Updated request: wr_types"));
cli_cmd(data_dir)
.args([
"request",
"update",
r#"{"id":"gr_types","service":"pkg.Greeter"}"#,
])
.assert()
.success();
cli_cmd(data_dir)
.args([
"request",
"update",
r#"{"id":"gr_types","method":"GET","bodyType":"other"}"#,
])
.assert()
.failure()
.stderr(contains("not part of a gRPC request: bodyType"));
{
let query_manager = query_manager(data_dir);
let db = query_manager.connect();
assert_eq!(db.get_websocket_request("wr_types").unwrap().name, "Renamed Socket");
assert_eq!(
db.get_grpc_request("gr_types").unwrap().service.as_deref(),
Some("pkg.Greeter")
);
}
cli_cmd(data_dir).args(["request", "delete", "gr_types", "--yes"]).assert().success();
cli_cmd(data_dir).args(["request", "delete", "wr_types", "--yes"]).assert().success();
cli_cmd(data_dir)
.args(["request", "show", "wr_types"])
.assert()
.failure()
.stderr(contains("Request wr_types not found"));
let query_manager = query_manager(data_dir);
assert!(query_manager.connect().get_grpc_request("gr_types").is_err());
assert!(query_manager.connect().get_websocket_request("wr_types").is_err());
}
@@ -0,0 +1,202 @@
mod common;
use common::{
cli_cmd, query_manager, seed_grpc_request, seed_request, seed_websocket_request, seed_workspace,
};
use predicates::prelude::PredicateBooleanExt;
use predicates::str::contains;
use serde_json::json;
use tempfile::TempDir;
use yaak_models::models::{
GrpcConnection, GrpcEvent, GrpcEventType, HttpResponse, WebsocketConnection, WebsocketEvent,
WebsocketEventType,
};
use yaak_models::util::UpdateSource;
/// QA sweep bug 4: `response list/show/body/delete` given a `gr_` or `wr_` ID could not
/// find the request, so its connections were unreachable.
#[test]
fn response_commands_handle_grpc_and_websocket_connections() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
seed_workspace(data_dir, "wk_test");
seed_grpc_request(data_dir, "wk_test", "gr_conn");
seed_websocket_request(data_dir, "wk_test", "wr_conn");
query_manager(data_dir)
.with_tx(|tx| {
let source = &UpdateSource::Sync;
let ws = tx.upsert_websocket_connection(
&WebsocketConnection {
id: "wc_conn".into(),
workspace_id: "wk_test".into(),
request_id: "wr_conn".into(),
url: "wss://example.com/socket".into(),
status: 101,
..Default::default()
},
source,
)?;
for (is_server, message) in [(false, "ping me"), (true, "hello"), (true, "world")] {
tx.upsert_websocket_event(
&WebsocketEvent {
workspace_id: "wk_test".into(),
request_id: "wr_conn".into(),
connection_id: ws.id.clone(),
is_server,
message: message.as_bytes().to_vec(),
message_type: WebsocketEventType::Text,
..Default::default()
},
source,
)?;
}
let grpc = tx.upsert_grpc_connection(
&GrpcConnection {
id: "gc_conn".into(),
workspace_id: "wk_test".into(),
request_id: "gr_conn".into(),
url: "https://example.com".into(),
..Default::default()
},
source,
)?;
tx.upsert_grpc_event(
&GrpcEvent {
workspace_id: "wk_test".into(),
request_id: "gr_conn".into(),
connection_id: grpc.id.clone(),
content: "{\"message\":\"hi\"}".into(),
event_type: GrpcEventType::ServerMessage,
..Default::default()
},
source,
)
})
.expect("seed connections");
cli_cmd(data_dir)
.args(["response", "list", "wr_conn"])
.assert()
.success()
.stdout(contains("wc_conn - 101 wss://example.com/socket"));
cli_cmd(data_dir)
.args(["response", "list", "gr_conn"])
.assert()
.success()
.stdout(contains("gc_conn - gRPC status 0 https://example.com"));
cli_cmd(data_dir)
.args(["response", "show", "wr_conn"])
.assert()
.success()
.stdout(contains("\"model\": \"websocket_connection\""));
cli_cmd(data_dir)
.args(["response", "show", "gc_conn"])
.assert()
.success()
.stdout(contains("\"model\": \"grpc_connection\""));
cli_cmd(data_dir)
.args(["response", "body", "wr_conn"])
.assert()
.success()
.stdout("hello\nworld\n");
cli_cmd(data_dir)
.args(["response", "body", "gr_conn"])
.assert()
.success()
.stdout("{\"message\":\"hi\"}\n");
cli_cmd(data_dir)
.args(["response", "delete", "wr_conn", "--yes"])
.assert()
.success()
.stdout(contains("Deleted 1 responses for request wr_conn"));
cli_cmd(data_dir)
.args(["response", "delete", "gr_conn", "--yes"])
.assert()
.success()
.stdout(contains("Deleted 1 responses for request gr_conn"));
let query_manager = query_manager(data_dir);
assert!(query_manager.connect().get_websocket_connection("wc_conn").is_err());
assert!(query_manager.connect().get_grpc_connection("gc_conn").is_err());
}
/// `response list <workspace>` and `response delete <workspace>` cover HTTP responses and
/// gRPC and WebSocket connections together, newest first, with `--limit` applied to the
/// merged history.
#[test]
fn workspace_response_commands_cover_every_kind() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
seed_workspace(data_dir, "wk_test");
seed_request(data_dir, "wk_test", "rq_mixed");
seed_grpc_request(data_dir, "wk_test", "gr_mixed");
seed_websocket_request(data_dir, "wk_test", "wr_mixed");
let at = |second: u32| format!("2026-01-01T00:00:{second:02}");
let (seed_db, blob_manager, _rx) =
yaak_models::init_standalone(data_dir.join("db.sqlite"), data_dir.join("blobs.sqlite"))
.expect("open database");
seed_db
.with_tx(|tx| {
let source = &UpdateSource::Sync;
tx.upsert_http_response(
&serde_json::from_value::<HttpResponse>(json!({
"id": "rs_oldest", "workspaceId": "wk_test", "requestId": "rq_mixed",
"createdAt": at(1), "updatedAt": at(1), "status": 200,
"url": "https://example.com/oldest",
}))
.unwrap(),
source,
&blob_manager,
)?;
tx.upsert_websocket_connection(
&serde_json::from_value::<WebsocketConnection>(json!({
"id": "wc_middle", "workspaceId": "wk_test", "requestId": "wr_mixed",
"createdAt": at(2), "updatedAt": at(2), "status": 101,
"url": "wss://example.com/socket",
}))
.unwrap(),
source,
)?;
tx.upsert_grpc_connection(
&serde_json::from_value::<GrpcConnection>(json!({
"id": "gc_newest", "workspaceId": "wk_test", "requestId": "gr_mixed",
"createdAt": at(3), "updatedAt": at(3), "url": "https://example.com",
}))
.unwrap(),
source,
)?;
Ok::<_, yaak_models::error::Error>(())
})
.expect("seed history");
drop(seed_db);
let listed = cli_cmd(data_dir).args(["response", "list", "wk_test"]).assert().success();
let ids = String::from_utf8_lossy(&listed.get_output().stdout)
.lines()
.map(|l| l.split_whitespace().next().unwrap_or_default().to_string())
.collect::<Vec<_>>();
assert_eq!(ids, ["gc_newest", "wc_middle", "rs_oldest"]);
cli_cmd(data_dir)
.args(["response", "list", "wk_test", "--limit", "2"])
.assert()
.success()
.stdout(contains("gc_newest"))
.stdout(contains("wc_middle"))
.stdout(contains("rs_oldest").not());
cli_cmd(data_dir)
.args(["response", "delete", "wk_test", "--yes"])
.assert()
.success()
.stdout(contains("Deleted 3 responses for workspace wk_test"));
let query_manager = query_manager(data_dir);
let db = query_manager.connect();
assert!(db.list_http_responses("wk_test", None).unwrap().is_empty());
assert!(db.list_grpc_connections("wk_test").unwrap().is_empty());
assert!(db.list_websocket_connections("wk_test").unwrap().is_empty());
}
+58 -1
View File
@@ -4,7 +4,7 @@ use common::http_server::TestHttpServer;
use common::{cli_cmd, query_manager, seed_folder, seed_workspace};
use predicates::str::contains;
use tempfile::TempDir;
use yaak_models::models::HttpRequest;
use yaak_models::models::{GrpcRequest, HttpRequest, WebsocketRequest};
use yaak_models::util::UpdateSource;
#[test]
@@ -48,3 +48,60 @@ fn top_level_send_unknown_id_fails_with_clear_error() {
.code(1)
.stderr(contains("Could not resolve ID 'does_not_exist' as request, folder, or workspace"));
}
/// QA sweep bug 5: `yaak send <folder>` with a gRPC and a WebSocket request in the folder
/// reported them as failures and exited 1, though every HTTP request succeeded.
#[test]
fn folder_send_skips_grpc_and_websocket_requests() {
let temp_dir = TempDir::new().expect("Failed to create temp dir");
let data_dir = temp_dir.path();
seed_workspace(data_dir, "wk_test");
seed_folder(data_dir, "wk_test", "fl_test");
let server = TestHttpServer::spawn_ok("mixed folder");
query_manager(data_dir)
.with_tx(|tx| {
let source = &UpdateSource::Sync;
tx.upsert_http_request(
&HttpRequest {
id: "rq_mixed".to_string(),
workspace_id: "wk_test".to_string(),
folder_id: Some("fl_test".to_string()),
name: "HTTP One".to_string(),
url: server.url.clone(),
..Default::default()
},
source,
)?;
tx.upsert_grpc_request(
&GrpcRequest {
id: "gr_mixed".to_string(),
workspace_id: "wk_test".to_string(),
folder_id: Some("fl_test".to_string()),
name: "Greeter".to_string(),
..Default::default()
},
source,
)?;
tx.upsert_websocket_request(
&WebsocketRequest {
id: "wr_mixed".to_string(),
workspace_id: "wk_test".to_string(),
folder_id: Some("fl_test".to_string()),
name: "Socket".to_string(),
..Default::default()
},
source,
)
})
.expect("Failed to seed folder requests");
cli_cmd(data_dir)
.args(["send", "fl_test"])
.assert()
.success()
.stdout(contains("mixed folder"))
.stdout(contains("Send summary: 1 succeeded, 0 failed, 2 skipped"))
.stdout(contains("gr_mixed - gRPC Greeter"))
.stdout(contains("wr_mixed - WebSocket Socket"));
}