mirror of
https://github.com/mountain-loop/yaak.git
synced 2026-11-20 07:21:35 +01:00
Since the plugin fix, every HTTP send versioned the stored row by reading it again in resolve_send_inputs. On the desktop that read runs after awaiting plugin startup, so an edit landing in between was versioned while the earlier copy was sent, and the response named content it never sent. Callers now say where their request came from. One that loaded the stored row and passes it on as is (the desktop send, the by-id sends, MCP) gets that same copy versioned, with no second read. One that may hold a rendered request (plugin sends) keeps the read-by-id fallback, so rendered values still never reach history. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
745 lines
28 KiB
Rust
745 lines
28 KiB
Rust
use crate::cli::McpArgs;
|
|
use crate::context::{CliContext, CliExecutionContext};
|
|
use crate::plugin_events::SendContexts;
|
|
use rand::RngExt;
|
|
use std::net::{Ipv4Addr, SocketAddr};
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
use yaak::send::{
|
|
SendHttpRequestWithPluginsParams, SendRequestSource, send_http_request_with_plugins,
|
|
};
|
|
use yaak_crypto::manager::EncryptionManager;
|
|
use yaak_http::manager::HttpConnectionManager;
|
|
use yaak_mcp::{HostResult, McpHost, WorkspaceInfo};
|
|
use yaak_models::blob_manager::BlobManager;
|
|
use yaak_models::models::{Folder, HttpRequest, HttpResponse};
|
|
use yaak_models::query_manager::QueryManager;
|
|
use yaak_models::util::UpdateSource;
|
|
use yaak_plugins::events::{PluginContext, ShowToastRequest};
|
|
use yaak_plugins::manager::PluginManager;
|
|
|
|
enum Transport {
|
|
Stdio,
|
|
Http { port: u16, token: Option<String> },
|
|
}
|
|
|
|
impl From<McpArgs> for Transport {
|
|
fn from(args: McpArgs) -> Self {
|
|
if args.http {
|
|
Transport::Http { port: args.port, token: args.token }
|
|
} else {
|
|
Transport::Stdio
|
|
}
|
|
}
|
|
}
|
|
|
|
pub async fn run(
|
|
ctx: &CliContext,
|
|
args: McpArgs,
|
|
environment: Option<&str>,
|
|
cookie_jar_id: Option<&str>,
|
|
) -> i32 {
|
|
let host = CliMcpHost {
|
|
query_manager: ctx.query_manager().clone(),
|
|
blob_manager: ctx.blob_manager().clone(),
|
|
plugin_manager: ctx.plugin_manager(),
|
|
encryption_manager: ctx.encryption_manager.clone(),
|
|
connection_manager: ctx.connection_manager().clone(),
|
|
response_dir: ctx.data_dir().join("responses"),
|
|
send_contexts: ctx.send_contexts().await,
|
|
environment_id: environment.map(str::to_string),
|
|
cookie_jar_id: cookie_jar_id.map(str::to_string),
|
|
};
|
|
let result = match Transport::from(args) {
|
|
Transport::Stdio => yaak_mcp::serve_stdio(host).await,
|
|
Transport::Http { port, token } => serve_http(host, port, token).await,
|
|
};
|
|
match result {
|
|
Ok(()) => 0,
|
|
Err(error) => {
|
|
eprintln!("Error: {error}");
|
|
1
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn serve_http(host: CliMcpHost, port: u16, token: Option<String>) -> Result<(), String> {
|
|
let token = token.unwrap_or_else(generate_token);
|
|
let addr = SocketAddr::from((Ipv4Addr::LOCALHOST, port));
|
|
let server = yaak_mcp::http::serve(Arc::new(host), addr, token.clone())
|
|
.await
|
|
.map_err(|e| format!("Failed to start MCP server on {addr}: {e}"))?;
|
|
eprintln!("Yaak MCP server listening on http://{}{}", server.addr, yaak_mcp::http::PATH);
|
|
eprintln!("Token: {token}");
|
|
eprintln!("Clients must send it as \"Authorization: Bearer <token>\". Press Ctrl+C to stop.");
|
|
tokio::signal::ctrl_c().await.map_err(|e| format!("Failed to wait for Ctrl+C: {e}"))?;
|
|
server.stop().await;
|
|
Ok(())
|
|
}
|
|
|
|
fn generate_token() -> String {
|
|
hex::encode(rand::rng().random::<[u8; 32]>())
|
|
}
|
|
|
|
/// Every workspace in the database is "open", and the global `--environment`
|
|
/// and `--cookie-jar` flags stand in for a window's selection.
|
|
struct CliMcpHost {
|
|
query_manager: QueryManager,
|
|
blob_manager: BlobManager,
|
|
plugin_manager: Arc<PluginManager>,
|
|
encryption_manager: Arc<EncryptionManager>,
|
|
connection_manager: Arc<HttpConnectionManager>,
|
|
response_dir: PathBuf,
|
|
send_contexts: SendContexts,
|
|
environment_id: Option<String>,
|
|
cookie_jar_id: Option<String>,
|
|
}
|
|
|
|
/// Registers a send's execution context for as long as the send runs.
|
|
struct SendContextGuard<'a> {
|
|
send_contexts: &'a SendContexts,
|
|
id: String,
|
|
}
|
|
|
|
impl<'a> SendContextGuard<'a> {
|
|
fn new(send_contexts: &'a SendContexts, id: &str, context: CliExecutionContext) -> Self {
|
|
send_contexts.lock().expect("send contexts lock").insert(id.to_string(), context);
|
|
Self { send_contexts, id: id.to_string() }
|
|
}
|
|
}
|
|
|
|
impl Drop for SendContextGuard<'_> {
|
|
fn drop(&mut self) {
|
|
self.send_contexts.lock().expect("send contexts lock").remove(&self.id);
|
|
}
|
|
}
|
|
|
|
impl McpHost for CliMcpHost {
|
|
fn list_workspaces(&self) -> HostResult<Vec<WorkspaceInfo>> {
|
|
let workspaces =
|
|
self.query_manager.connect().list_workspaces().map_err(|e| e.to_string())?;
|
|
Ok(workspaces.into_iter().map(|w| WorkspaceInfo { id: w.id, name: w.name }).collect())
|
|
}
|
|
|
|
fn active_environment_id(&self, workspace_id: &str) -> HostResult<Option<String>> {
|
|
let Some(environment_id) = &self.environment_id else {
|
|
return Ok(None);
|
|
};
|
|
Ok(self
|
|
.query_manager
|
|
.connect()
|
|
.get_environment_for_workspace(workspace_id, environment_id)
|
|
.ok()
|
|
.map(|e| e.id))
|
|
}
|
|
|
|
fn list_http_requests(&self, workspace_id: &str) -> HostResult<Vec<HttpRequest>> {
|
|
self.query_manager.connect().list_http_requests(workspace_id).map_err(|e| e.to_string())
|
|
}
|
|
|
|
fn get_http_request(&self, id: &str) -> HostResult<Option<HttpRequest>> {
|
|
Ok(self.query_manager.connect().get_http_request(id).ok())
|
|
}
|
|
|
|
fn upsert_http_request(&self, request: &HttpRequest) -> HostResult<HttpRequest> {
|
|
self.query_manager
|
|
.with_tx(|tx| tx.upsert_http_request(request, &UpdateSource::Sync))
|
|
.map_err(|e| format!("Failed to upsert HTTP request: {e}"))
|
|
}
|
|
|
|
fn delete_http_request(&self, id: &str) -> HostResult<HttpRequest> {
|
|
self.query_manager
|
|
.with_tx(|tx| tx.delete_http_request_by_id(id, &UpdateSource::Sync))
|
|
.map_err(|e| format!("Failed to delete HTTP request: {e}"))
|
|
}
|
|
|
|
fn list_folders(&self, workspace_id: &str) -> HostResult<Vec<Folder>> {
|
|
self.query_manager.connect().list_folders(workspace_id).map_err(|e| e.to_string())
|
|
}
|
|
|
|
fn upsert_folder(&self, folder: &Folder) -> HostResult<Folder> {
|
|
self.query_manager
|
|
.with_tx(|tx| tx.upsert_folder(folder, &UpdateSource::Sync))
|
|
.map_err(|e| format!("Failed to upsert folder: {e}"))
|
|
}
|
|
|
|
fn delete_folder(&self, id: &str) -> HostResult<Folder> {
|
|
self.query_manager
|
|
.with_tx(|tx| tx.delete_folder_by_id(id, &UpdateSource::Sync))
|
|
.map_err(|e| format!("Failed to delete folder: {e}"))
|
|
}
|
|
|
|
async fn send_http_request(
|
|
&self,
|
|
workspace_id: &str,
|
|
request: HttpRequest,
|
|
environment_id: Option<String>,
|
|
) -> HostResult<HttpResponse> {
|
|
let environment_id = match environment_id {
|
|
Some(environment_id) => {
|
|
if request.workspace_id != workspace_id {
|
|
return Err("HTTP request does not belong to the selected workspace".into());
|
|
}
|
|
let environment = self
|
|
.query_manager
|
|
.connect()
|
|
.get_environment_for_workspace(&request.workspace_id, &environment_id)
|
|
.map_err(|e| e.to_string())?;
|
|
Some(environment.id)
|
|
}
|
|
None => self.active_environment_id(&request.workspace_id)?,
|
|
};
|
|
let cookie_jar_id = match &self.cookie_jar_id {
|
|
Some(id) => Some(id.clone()),
|
|
None => self
|
|
.query_manager
|
|
.connect()
|
|
.list_cookie_jars(&request.workspace_id)
|
|
.map_err(|e| format!("Failed to list cookie jars: {e}"))?
|
|
.into_iter()
|
|
.min_by_key(|jar| jar.created_at)
|
|
.map(|jar| jar.id),
|
|
};
|
|
let plugin_context =
|
|
PluginContext::new(Some("cli".to_string()), Some(request.workspace_id.clone()));
|
|
let _send_context = SendContextGuard::new(
|
|
&self.send_contexts,
|
|
&plugin_context.id,
|
|
CliExecutionContext {
|
|
request_id: Some(request.id.clone()),
|
|
workspace_id: Some(request.workspace_id.clone()),
|
|
environment_id: environment_id.clone(),
|
|
cookie_jar_id: cookie_jar_id.clone(),
|
|
},
|
|
);
|
|
|
|
let result = send_http_request_with_plugins(SendHttpRequestWithPluginsParams {
|
|
query_manager: &self.query_manager,
|
|
blob_manager: &self.blob_manager,
|
|
request,
|
|
// The MCP server loads the request by id and passes the row on as it is
|
|
request_source: SendRequestSource::Stored,
|
|
environment_id: environment_id.as_deref(),
|
|
update_source: UpdateSource::Sync,
|
|
cookie_jar_id,
|
|
response_dir: &self.response_dir,
|
|
emit_events_to: None,
|
|
emit_response_body_chunks_to: None,
|
|
existing_response: None,
|
|
plugin_manager: self.plugin_manager.clone(),
|
|
encryption_manager: self.encryption_manager.clone(),
|
|
plugin_context: &plugin_context,
|
|
cancelled_rx: None,
|
|
connection_manager: &self.connection_manager,
|
|
})
|
|
.await
|
|
.map_err(|e| e.to_string())?;
|
|
Ok(result.response)
|
|
}
|
|
|
|
fn show_toast(&self, toast: ShowToastRequest) -> HostResult<()> {
|
|
// stdout carries the protocol
|
|
eprintln!("[mcp] {}", toast.message);
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use rmcp::model::{CallToolRequestParams, CallToolResult};
|
|
use rmcp::service::RunningService;
|
|
use rmcp::{RoleClient, ServiceExt};
|
|
use serde_json::{Value, json};
|
|
use tempfile::TempDir;
|
|
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
|
use tokio::net::TcpListener;
|
|
use tokio::sync::mpsc::UnboundedReceiver;
|
|
use yaak_mcp::YaakMcpServer;
|
|
use yaak_models::models::{Environment, EnvironmentVariable, HttpRequestHeader, Workspace};
|
|
|
|
struct Fixture {
|
|
client: RunningService<RoleClient, ()>,
|
|
query_manager: QueryManager,
|
|
plugin_manager: Arc<PluginManager>,
|
|
workspace_id: String,
|
|
request_id: String,
|
|
environments: [String; 3],
|
|
received: UnboundedReceiver<String>,
|
|
_dir: TempDir,
|
|
}
|
|
|
|
impl Fixture {
|
|
async fn new(active_environment: Option<&str>) -> Self {
|
|
let dir = TempDir::new().unwrap();
|
|
let (query_manager, blob_manager, _rx) = yaak_models::init_standalone(
|
|
dir.path().join("db.sqlite"),
|
|
dir.path().join("blobs.sqlite"),
|
|
)
|
|
.unwrap();
|
|
let (url, received) = echo_server().await;
|
|
let (workspace_id, request_id, environments) = seed(&query_manager, &url);
|
|
|
|
let plugin_dir = dir.path().join("plugins");
|
|
std::fs::create_dir_all(&plugin_dir).unwrap();
|
|
let plugin_manager = Arc::new(
|
|
PluginManager::new(
|
|
plugin_dir.clone(),
|
|
plugin_dir,
|
|
PathBuf::from("node"),
|
|
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join(
|
|
"../../crates-tauri/yaak-app-client/vendored/plugin-runtime/index.cjs",
|
|
),
|
|
&query_manager,
|
|
&PluginContext::new_empty(),
|
|
false,
|
|
)
|
|
.await
|
|
.unwrap(),
|
|
);
|
|
let environment_id = active_environment.map(|name| match name {
|
|
"a" => environments[1].clone(),
|
|
other => other.to_string(),
|
|
});
|
|
let host = CliMcpHost {
|
|
encryption_manager: Arc::new(EncryptionManager::new(
|
|
query_manager.clone(),
|
|
"yaak-test",
|
|
)),
|
|
query_manager: query_manager.clone(),
|
|
blob_manager,
|
|
plugin_manager: plugin_manager.clone(),
|
|
connection_manager: Arc::new(HttpConnectionManager::new()),
|
|
response_dir: dir.path().join("responses"),
|
|
send_contexts: SendContexts::default(),
|
|
environment_id,
|
|
cookie_jar_id: None,
|
|
};
|
|
|
|
let (client_io, server_io) = tokio::io::duplex(64 * 1024);
|
|
tokio::spawn(async move {
|
|
let server = YaakMcpServer::new(host).serve(server_io).await.unwrap();
|
|
let _ = server.waiting().await;
|
|
});
|
|
let client = ().serve(client_io).await.unwrap();
|
|
|
|
Self {
|
|
client,
|
|
query_manager,
|
|
plugin_manager,
|
|
workspace_id,
|
|
request_id,
|
|
environments,
|
|
received,
|
|
_dir: dir,
|
|
}
|
|
}
|
|
|
|
async fn call(&self, name: &'static str, arguments: Value) -> CallToolResult {
|
|
let Value::Object(arguments) = arguments else {
|
|
panic!("arguments must be an object")
|
|
};
|
|
self.client
|
|
.call_tool(CallToolRequestParams::new(name).with_arguments(arguments))
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
async fn ok(&self, name: &'static str, arguments: Value) -> String {
|
|
let result = self.call(name, arguments).await;
|
|
assert_ne!(result.is_error, Some(true), "{name} failed: {}", text(&result));
|
|
text(&result)
|
|
}
|
|
|
|
async fn err(&self, name: &'static str, arguments: Value) -> String {
|
|
let result = self.call(name, arguments).await;
|
|
assert_eq!(result.is_error, Some(true), "{name} should fail: {}", text(&result));
|
|
text(&result)
|
|
}
|
|
|
|
async fn json(&self, name: &'static str, arguments: Value) -> Value {
|
|
serde_json::from_str(&self.ok(name, arguments).await).unwrap()
|
|
}
|
|
|
|
async fn next_marker(&mut self) -> String {
|
|
let request = self.received.recv().await.unwrap().to_lowercase();
|
|
let line = request.lines().find(|l| l.starts_with("x-environment:")).unwrap();
|
|
line["x-environment:".len()..].trim().to_string()
|
|
}
|
|
|
|
async fn finish(self) {
|
|
assert!(self.received.is_empty(), "unexpected requests reached the server");
|
|
self.client.cancel().await.unwrap();
|
|
self.plugin_manager.terminate().await;
|
|
}
|
|
}
|
|
|
|
fn text(result: &CallToolResult) -> String {
|
|
result.content.iter().filter_map(|c| c.as_text()).map(|t| t.text.clone()).collect()
|
|
}
|
|
|
|
async fn echo_server() -> (String, UnboundedReceiver<String>) {
|
|
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
|
|
let url = format!("http://{}/echo", listener.local_addr().unwrap());
|
|
let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
|
|
tokio::spawn(async move {
|
|
loop {
|
|
let (mut socket, _) = listener.accept().await.unwrap();
|
|
let mut request = Vec::new();
|
|
while !request.windows(4).any(|w| w == b"\r\n\r\n") {
|
|
let mut chunk = [0u8; 1024];
|
|
let n = socket.read(&mut chunk).await.unwrap();
|
|
if n == 0 {
|
|
break;
|
|
}
|
|
request.extend_from_slice(&chunk[..n]);
|
|
}
|
|
tx.send(String::from_utf8(request).unwrap()).unwrap();
|
|
socket
|
|
.write_all(
|
|
b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok",
|
|
)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
});
|
|
(url, rx)
|
|
}
|
|
|
|
/// A workspace with base environment "global", sub-environments "a" and
|
|
/// "b", and a request that echoes its environment's marker in a header.
|
|
fn seed(query_manager: &QueryManager, url: &str) -> (String, String, [String; 3]) {
|
|
query_manager
|
|
.with_tx(|db| {
|
|
let source = &UpdateSource::Background;
|
|
let workspace = db.upsert_workspace(
|
|
&Workspace { name: "Test".into(), ..Default::default() },
|
|
source,
|
|
)?;
|
|
let vars = |value: &str| {
|
|
vec![EnvironmentVariable {
|
|
enabled: true,
|
|
name: "marker".into(),
|
|
value: value.into(),
|
|
..Default::default()
|
|
}]
|
|
};
|
|
let base = db.ensure_base_environment(&workspace.id)?;
|
|
let base = db.upsert_environment(
|
|
&Environment { variables: vars("global"), ..base },
|
|
source,
|
|
)?;
|
|
let sub = |name: &str| {
|
|
db.upsert_environment(
|
|
&Environment {
|
|
name: name.into(),
|
|
workspace_id: workspace.id.clone(),
|
|
parent_model: "environment".into(),
|
|
parent_id: Some(base.id.clone()),
|
|
variables: vars(name),
|
|
..Default::default()
|
|
},
|
|
source,
|
|
)
|
|
};
|
|
let a = sub("a")?;
|
|
let b = sub("b")?;
|
|
let request = db.upsert_http_request(
|
|
&HttpRequest {
|
|
workspace_id: workspace.id.clone(),
|
|
name: "Echo".into(),
|
|
url: url.to_string(),
|
|
method: "GET".into(),
|
|
headers: vec![HttpRequestHeader {
|
|
enabled: true,
|
|
name: "X-Environment".into(),
|
|
value: "${[ marker ]}".into(),
|
|
..Default::default()
|
|
}],
|
|
..Default::default()
|
|
},
|
|
source,
|
|
)?;
|
|
Ok::<_, yaak_models::error::Error>((
|
|
workspace.id,
|
|
request.id,
|
|
[base.id, a.id, b.id],
|
|
))
|
|
})
|
|
.unwrap()
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn advertises_the_plugin_tools() {
|
|
let fx = Fixture::new(None).await;
|
|
let tools = fx.client.list_all_tools().await.unwrap();
|
|
let mut names = tools.iter().map(|t| t.name.to_string()).collect::<Vec<_>>();
|
|
names.sort();
|
|
assert_eq!(
|
|
names,
|
|
[
|
|
"create_folder",
|
|
"create_http_request",
|
|
"delete_folder",
|
|
"delete_http_request",
|
|
"get_environment_id",
|
|
"get_folder",
|
|
"get_http_request",
|
|
"get_workspace_id",
|
|
"list_folders",
|
|
"list_http_requests",
|
|
"list_workspaces",
|
|
"send_http_request",
|
|
"show_toast",
|
|
"update_folder",
|
|
"update_http_request",
|
|
]
|
|
);
|
|
let send = tools.iter().find(|t| t.name == "send_http_request").unwrap();
|
|
let properties = send.input_schema["properties"].as_object().unwrap();
|
|
assert!(properties.contains_key("environmentId"), "{properties:?}");
|
|
assert_eq!(send.input_schema["required"], json!(["id"]));
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_uses_the_given_environment() {
|
|
let mut fx = Fixture::new(Some("a")).await;
|
|
let response = fx
|
|
.json(
|
|
"send_http_request",
|
|
json!({ "id": fx.request_id, "workspaceId": fx.workspace_id, "environmentId": fx.environments[2] }),
|
|
)
|
|
.await;
|
|
assert_eq!(response["status"], 200);
|
|
assert!(response.get("bodyPath").is_none(), "{response}");
|
|
assert_eq!(fx.next_marker().await, "b");
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_without_an_environment_uses_the_active_one() {
|
|
let mut fx = Fixture::new(Some("a")).await;
|
|
fx.ok("send_http_request", json!({ "id": fx.request_id })).await;
|
|
assert_eq!(fx.next_marker().await, "a");
|
|
fx.finish().await;
|
|
|
|
let mut fx = Fixture::new(None).await;
|
|
fx.ok("send_http_request", json!({ "id": fx.request_id })).await;
|
|
assert_eq!(fx.next_marker().await, "global");
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_does_not_send_a_missing_request() {
|
|
let fx = Fixture::new(None).await;
|
|
let error = fx.err("send_http_request", json!({ "id": "rq_missing" })).await;
|
|
assert_eq!(error, "HTTP request with ID rq_missing not found");
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn send_returns_host_environment_errors() {
|
|
let fx = Fixture::new(None).await;
|
|
let expected = fx
|
|
.query_manager
|
|
.connect()
|
|
.get_environment_for_workspace(&fx.workspace_id, "ev_missing")
|
|
.unwrap_err()
|
|
.to_string();
|
|
let error = fx
|
|
.err("send_http_request", json!({ "id": fx.request_id, "environmentId": "ev_missing" }))
|
|
.await;
|
|
assert_eq!(error, expected);
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn concurrent_sends_keep_their_environments() {
|
|
let mut fx = Fixture::new(None).await;
|
|
let (a, b) = (fx.environments[1].clone(), fx.environments[2].clone());
|
|
tokio::join!(
|
|
fx.ok("send_http_request", json!({ "id": fx.request_id, "environmentId": a })),
|
|
fx.ok("send_http_request", json!({ "id": fx.request_id, "environmentId": b })),
|
|
);
|
|
let mut markers = vec![fx.next_marker().await, fx.next_marker().await];
|
|
markers.sort();
|
|
assert_eq!(markers, ["a", "b"]);
|
|
let responses =
|
|
fx.query_manager.connect().list_http_responses_for_request(&fx.request_id, None);
|
|
assert_eq!(responses.unwrap().len(), 2);
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn workspace_and_environment_tools() {
|
|
let fx = Fixture::new(Some("a")).await;
|
|
assert_eq!(
|
|
fx.json("list_workspaces", json!({})).await,
|
|
json!([{ "id": fx.workspace_id, "name": "Test" }])
|
|
);
|
|
assert_eq!(fx.ok("get_workspace_id", json!({})).await, fx.workspace_id);
|
|
assert_eq!(fx.ok("get_environment_id", json!({})).await, fx.environments[1]);
|
|
|
|
let error = fx.err("list_http_requests", json!({ "workspaceId": "wk_missing" })).await;
|
|
assert!(error.starts_with("Workspace with ID \"wk_missing\" not found."), "{error}");
|
|
|
|
fx.query_manager
|
|
.with_tx(|db| {
|
|
db.upsert_workspace(
|
|
&Workspace { name: "Other".into(), ..Default::default() },
|
|
&UpdateSource::Background,
|
|
)
|
|
})
|
|
.unwrap();
|
|
let error = fx.err("get_workspace_id", json!({})).await;
|
|
assert!(error.starts_with("Multiple workspaces are open."), "{error}");
|
|
let error = fx.err("list_http_requests", json!({})).await;
|
|
assert!(error.contains(&format!("Test (ID: {})", fx.workspace_id)), "{error}");
|
|
let requests =
|
|
fx.json("list_http_requests", json!({ "workspaceId": fx.workspace_id })).await;
|
|
assert_eq!(requests.as_array().unwrap().len(), 1);
|
|
fx.finish().await;
|
|
|
|
let fx = Fixture::new(None).await;
|
|
assert_eq!(fx.ok("get_environment_id", json!({})).await, "No environment selected");
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn http_request_tools() {
|
|
let fx = Fixture::new(None).await;
|
|
let created = fx
|
|
.json(
|
|
"create_http_request",
|
|
json!({
|
|
"name": "Created",
|
|
"url": "https://example.com/items",
|
|
"headers": [{ "name": "Accept", "value": "application/json" }],
|
|
"bodyType": "application/json",
|
|
"body": { "text": "{}" },
|
|
}),
|
|
)
|
|
.await;
|
|
let id = created["id"].as_str().unwrap().to_string();
|
|
assert!(id.starts_with("rq_"), "{created}");
|
|
assert_eq!(created["workspaceId"], fx.workspace_id);
|
|
assert_eq!(created["method"], "GET");
|
|
assert_eq!(created["headers"][0]["enabled"], true);
|
|
assert_eq!(fx.json("get_http_request", json!({ "id": id })).await, created);
|
|
|
|
let updated = fx
|
|
.json(
|
|
"update_http_request",
|
|
json!({ "id": id, "url": "https://example.com/v2", "method": "POST" }),
|
|
)
|
|
.await;
|
|
assert_eq!(updated["id"], id);
|
|
assert_eq!(updated["url"], "https://example.com/v2");
|
|
assert_eq!(updated["method"], "POST");
|
|
assert_eq!(updated["name"], "Created");
|
|
assert_eq!(updated["body"], json!({ "text": "{}" }));
|
|
|
|
let error = fx.err("update_http_request", json!({ "id": "rq_missing", "name": "x" })).await;
|
|
assert_eq!(error, "HTTP request with ID rq_missing not found");
|
|
|
|
let listed = fx.json("list_http_requests", json!({})).await;
|
|
assert_eq!(listed.as_array().unwrap().len(), 2);
|
|
|
|
assert_eq!(
|
|
fx.ok("delete_http_request", json!({ "id": id })).await,
|
|
format!("Deleted: Created ({id})")
|
|
);
|
|
assert_eq!(
|
|
fx.err("get_http_request", json!({ "id": id })).await,
|
|
format!("HTTP request with ID {id} not found")
|
|
);
|
|
fx.finish().await;
|
|
}
|
|
|
|
/// QA sweep bug 6: `get_http_request` with a `wr_` ID or `rq_bogus` answered `"null"`
|
|
/// with `isError: false`, and `delete_http_request` on a `wr_` ID failed obscurely.
|
|
#[tokio::test]
|
|
async fn http_request_tools_reject_unknown_and_non_http_ids() {
|
|
let fx = Fixture::new(None).await;
|
|
let websocket = fx
|
|
.query_manager
|
|
.with_tx(|db| {
|
|
db.upsert_websocket_request(
|
|
&yaak_models::models::WebsocketRequest {
|
|
workspace_id: fx.workspace_id.clone(),
|
|
name: "Socket".into(),
|
|
..Default::default()
|
|
},
|
|
&UpdateSource::Background,
|
|
)
|
|
})
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
fx.err("get_http_request", json!({ "id": "rq_bogus" })).await,
|
|
"HTTP request with ID rq_bogus not found"
|
|
);
|
|
let expected = format!(
|
|
"{} is a WebSocket request, and these tools only work with HTTP requests. Use the Yaak app or the `yaak request` CLI commands for it.",
|
|
websocket.id
|
|
);
|
|
assert_eq!(fx.err("get_http_request", json!({ "id": websocket.id })).await, expected);
|
|
assert_eq!(fx.err("delete_http_request", json!({ "id": websocket.id })).await, expected);
|
|
assert!(fx.query_manager.connect().get_websocket_request(&websocket.id).is_ok());
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn folder_tools() {
|
|
let fx = Fixture::new(None).await;
|
|
let parent = fx.json("create_folder", json!({ "name": "Parent" })).await;
|
|
let parent_id = parent["id"].as_str().unwrap().to_string();
|
|
assert!(parent_id.starts_with("fl_"), "{parent}");
|
|
let child = fx
|
|
.json(
|
|
"create_folder",
|
|
json!({
|
|
"name": "Child",
|
|
"folderId": parent_id,
|
|
"sortPriority": 2.5,
|
|
"authenticationType": "bearer",
|
|
"authentication": { "token": "abc" },
|
|
}),
|
|
)
|
|
.await;
|
|
let child_id = child["id"].as_str().unwrap().to_string();
|
|
assert_eq!(child["folderId"], parent_id);
|
|
assert_eq!(child["authentication"]["token"], "abc");
|
|
assert_eq!(fx.json("get_folder", json!({ "id": child_id })).await, child);
|
|
assert_eq!(fx.json("list_folders", json!({})).await.as_array().unwrap().len(), 2);
|
|
|
|
let updated =
|
|
fx.json("update_folder", json!({ "id": child_id, "description": "Nested" })).await;
|
|
assert_eq!(updated["description"], "Nested");
|
|
assert_eq!(updated["name"], "Child");
|
|
assert_eq!(updated["folderId"], parent_id);
|
|
|
|
let error = fx.err("update_folder", json!({ "id": "fl_missing" })).await;
|
|
assert_eq!(error, "Folder with ID fl_missing not found");
|
|
|
|
assert_eq!(
|
|
fx.ok("delete_folder", json!({ "id": child_id })).await,
|
|
format!("Deleted: Child ({child_id})")
|
|
);
|
|
assert_eq!(fx.json("get_folder", json!({ "id": child_id })).await, Value::Null);
|
|
fx.finish().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn show_toast_reports_the_message() {
|
|
let fx = Fixture::new(None).await;
|
|
assert_eq!(
|
|
fx.ok("show_toast", json!({ "message": "Hello", "icon": "info", "color": "success" }))
|
|
.await,
|
|
"✓ Toast shown: \"Hello\""
|
|
);
|
|
fx.finish().await;
|
|
}
|
|
}
|