@browsersync/bslive 0.0.9 → 0.0.13

package/crates/bsnext_core/src/dto.rs

@@ -6,8 +6,67 @@ use std::path::Path;
 
 use crate::server::handler_change::{Change, ChangeKind};
 use bsnext_fs::Debounce;
+use bsnext_input::route::{DirRoute, ProxyRoute, Route, RouteKind};
 use typeshare::typeshare;
 
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct ServerDesc {
+    pub routes: Vec<RouteDTO>,
+    pub id: String,
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+pub struct RouteDTO {
+    pub path: String,
+    pub kind: RouteKindDTO,
+}
+
+impl From<Route> for RouteDTO {
+    fn from(value: Route) -> Self {
+        Self {
+            path: value.path.to_owned(),
+            kind: RouteKindDTO::from(value.kind),
+        }
+    }
+}
+impl From<&Route> for RouteDTO {
+    fn from(value: &Route) -> Self {
+        Self {
+            path: value.path.to_owned(),
+            kind: RouteKindDTO::from(value.kind.clone()),
+        }
+    }
+}
+
+#[typeshare]
+#[derive(Debug, serde::Serialize)]
+#[serde(tag = "kind", content = "payload")]
+pub enum RouteKindDTO {
+    Html { html: String },
+    Json { json_str: String },
+    Raw { raw: String },
+    Sse { sse: String },
+    Proxy { proxy: String },
+    Dir { dir: String },
+}
+
+impl From<RouteKind> for RouteKindDTO {
+    fn from(value: RouteKind) -> Self {
+        match value {
+            RouteKind::Html { html } => RouteKindDTO::Html { html },
+            RouteKind::Json { json } => RouteKindDTO::Json {
+                json_str: serde_json::to_string(&json).expect("unreachable"),
+            },
+            RouteKind::Raw { raw } => RouteKindDTO::Raw { raw },
+            RouteKind::Sse { sse } => RouteKindDTO::Sse { sse },
+            RouteKind::Proxy(ProxyRoute { proxy }) => RouteKindDTO::Proxy { proxy },
+            RouteKind::Dir(DirRoute { dir }) => RouteKindDTO::Dir { dir },
+        }
+    }
+}
+
 #[typeshare]
 #[derive(Debug, serde::Serialize)]
 pub struct ServersStarted {
@@ -157,12 +216,13 @@ pub struct ServerChangeSet {
 #[typeshare::typeshare]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, MessageResponse)]
 pub struct GetServersMessageResponse {
-    pub servers: Vec<ServersDTO>,
+    pub servers: Vec<ServerDTO>,
 }
 
 #[typeshare::typeshare]
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ServersDTO {
+pub struct ServerDTO {
+    pub id: String,
     pub identity: IdentityDTO,
     pub socket_addr: String,
 }

package/crates/bsnext_core/src/lib.rs

@@ -1,6 +1,7 @@
 pub mod server;
 pub mod servers_supervisor;
 
+pub mod common_layers;
 pub mod dir_loader;
 pub mod dto;
 pub mod handlers;

package/crates/bsnext_core/src/not_found/mod.rs

@@ -1,2 +1 @@
 pub mod not_found_service;
-pub mod route_list;

package/crates/bsnext_core/src/not_found/not_found_service.rs

@@ -1,6 +1,5 @@
-use axum::extract::{Request, State};
+use axum::extract::Request;
 use axum::middleware::Next;
-use std::sync::Arc;
 
 use axum::response::{IntoResponse, Response};
 
@@ -9,15 +8,11 @@ use http::{HeaderValue, StatusCode};
 use mime_guess::mime;
 
 use crate::handlers::proxy::AnyAppError;
-use crate::not_found::route_list::create_route_list_html;
-use crate::server::state::ServerState;
+
+use bsnext_client::html_with_base;
 use tracing::{span, Level};
 
-pub async fn not_found_loader(
-    State(state): State<Arc<ServerState>>,
-    req: Request,
-    next: Next,
-) -> Result<Response, AnyAppError> {
+pub async fn not_found_loader(req: Request, next: Next) -> Result<Response, AnyAppError> {
     let span = span!(parent: None, Level::INFO, "not_found", path = req.uri().path());
     let _guard = span.enter();
 
@@ -26,8 +21,7 @@ pub async fn not_found_loader(
         return Ok(r);
     };
 
-    let routes = state.routes.read().await;
-    let markup = create_route_list_html(&routes);
+    let markup = html_with_base("/__bs_assets/ui/");
 
     Ok((
         StatusCode::NOT_FOUND,

package/crates/bsnext_core/src/raw_loader.rs

@@ -11,17 +11,18 @@ use crate::meta::MetaData;
 use crate::server::state::ServerState;
 use axum::body::Body;
 use axum::response::sse::Event;
-use bsnext_input::route::{CorsOpts, DelayKind, DelayOpts, DirRoute, ProxyRoute, Route, RouteKind};
+use bsnext_input::route::{DirRoute, ProxyRoute, RouteKind};
 use bsnext_resp::response_modifications_layer;
 use bytes::Bytes;
 use http::StatusCode;
 use http_body_util::BodyExt;
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::time::sleep;
+
 use tokio_stream::StreamExt;
 use tower::ServiceExt;
-use tower_http::cors::CorsLayer;
+
+use crate::common_layers::add_route_layers;
 use tracing::{span, Level};
 
 // use futures_util::stream::{self, Stream};
@@ -145,37 +146,6 @@ async fn tag_raw(req: Request, next: Next) -> Result<impl IntoResponse, (StatusC
     Ok(Response::from_parts(parts, body))
 }
 
-pub fn add_route_layers(app: Router, route: &Route) -> Router {
-    let mut app = app;
-
-    if route
-        .cors_opts
-        .as_ref()
-        .is_some_and(|v| *v == CorsOpts::Cors(true))
-    {
-        tracing::trace!(to = route.path, "adding permissive cors");
-        app = app.layer(CorsLayer::permissive());
-    }
-
-    if let Some(DelayOpts::Delay(DelayKind::Ms(ms))) = route.delay_opts.as_ref() {
-        tracing::trace!(to = route.path, ?ms, "adding delay");
-        let ms = *ms;
-        app = app.layer(middleware::from_fn(
-            move |req: Request, next: Next| async move {
-                let res = next.run(req).await;
-                sleep(Duration::from_millis(ms)).await;
-                Ok::<_, Infallible>(res)
-            },
-        ));
-    }
-
-    // if route.opts.as_ref().is_some_and(|v| v.buff) {
-    // app = app.layer(middleware::from_fn(print_request_response));
-    // }
-
-    app
-}
-
 #[allow(dead_code)]
 async fn print_request_response(
     req: Request,

package/crates/bsnext_core/src/server/handler_listen.rs

@@ -2,7 +2,8 @@ use crate::server::actor::ServerActor;
 use crate::server::error::ServerError;
 use crate::server::router::make_router;
 use crate::server::state::ServerState;
-use actix::AsyncContext;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use actix::{Addr, AsyncContext};
 use actix_rt::Arbiter;
 use bsnext_input::server_config::Identity;
 use std::future::Future;
@@ -14,13 +15,15 @@ use tokio::sync::{oneshot, RwLock};
 
 #[derive(actix::Message)]
 #[rtype(result = "Result<(SocketAddr, actix::Addr<ServerActor>), ServerError>")]
-pub struct Listen;
+pub struct Listen {
+    pub(crate) parent: Addr<ServersSupervisor>,
+}
 
 impl actix::Handler<Listen> for ServerActor {
     type Result =
         Pin<Box<dyn Future<Output = Result<(SocketAddr, actix::Addr<ServerActor>), ServerError>>>>;
 
-    fn handle(&mut self, _msg: Listen, ctx: &mut Self::Context) -> Self::Result {
+    fn handle(&mut self, msg: Listen, ctx: &mut Self::Context) -> Self::Result {
         let identity = self.config.identity.clone();
         tracing::trace!("actor started for {:?}", identity);
         let (send_complete, handle, client_sender) = self.install_signals();
@@ -29,7 +32,10 @@ impl actix::Handler<Listen> for ServerActor {
         let h2 = handle.clone();
 
         let app_state = Arc::new(ServerState {
+            // parent: ,
             routes: Arc::new(RwLock::new(self.config.routes.clone())),
+            id: self.config.identity.as_id(),
+            parent: Some(msg.parent.clone()),
             client_sender: Arc::new(client_sender),
         });
 
@@ -103,7 +109,7 @@ impl actix::Handler<Listen> for ServerActor {
                 listening = h2.listening() => {
                     match listening {
                         Some(socket_addr) => {
-                            tracing::debug!("box::pin was listening...");
+                            tracing::debug!("{} listening...", socket_addr);
                             Ok((socket_addr, self_addr.clone()))
                         }
                         None => {

package/crates/bsnext_core/src/server/router/assets.rs

@@ -0,0 +1,39 @@
+use crate::server::state::ServerState;
+use axum::response::IntoResponse;
+use axum::routing::get;
+use axum::Router;
+use bsnext_client::{UI_CSS, UI_JS};
+use http::header::CONTENT_TYPE;
+use http::HeaderValue;
+use mime_guess::mime;
+use std::sync::Arc;
+
+pub fn pub_ui_assets(_: Arc<ServerState>) -> Router<Arc<ServerState>> {
+    Router::new()
+        .route(
+            "/dist/index.js",
+            get(|| async {
+                (
+                    [(
+                        CONTENT_TYPE,
+                        HeaderValue::from_static(mime::APPLICATION_JAVASCRIPT.as_ref()),
+                    )],
+                    UI_JS,
+                )
+                    .into_response()
+            }),
+        )
+        .route(
+            "/dist/index.css",
+            get(|| async {
+                (
+                    [(
+                        CONTENT_TYPE,
+                        HeaderValue::from_static(mime::TEXT_CSS.as_ref()),
+                    )],
+                    UI_CSS,
+                )
+                    .into_response()
+            }),
+        )
+}

package/crates/bsnext_core/src/server/router/mod.rs

@@ -21,15 +21,20 @@ use tower::ServiceBuilder;
 use tower_http::catch_panic::CatchPanicLayer;
 
 use crate::dir_loader::serve_dir_loader;
+use crate::dto::{RouteDTO, ServerDesc};
 use crate::meta::MetaData;
 use crate::not_found::not_found_service::not_found_loader;
-use crate::not_found::route_list::create_route_list_html;
 use crate::raw_loader::raw_loader;
+use crate::server::router::assets::pub_ui_assets;
+use crate::server::router::pub_api::pub_api;
 use crate::server::state::ServerState;
 use crate::ws::ws_handler;
+use bsnext_client::html_with_base;
 use tower_http::timeout::TimeoutLayer;
 use tower_http::trace::TraceLayer;
 
+mod assets;
+mod pub_api;
 mod tests;
 
 pub fn make_router(state: &Arc<ServerState>) -> Router {
@@ -49,7 +54,11 @@ pub fn built_ins(state: Arc<ServerState>) -> Router {
     async fn handler(State(app): State<Arc<ServerState>>, _uri: Uri) -> impl IntoResponse {
         // let v = app.lock().await;
         let routes = app.routes.read().await;
-        let markup = create_route_list_html(&routes);
+        let _dto = ServerDesc {
+            routes: routes.iter().map(RouteDTO::from).collect(),
+            id: app.id.to_string(),
+        };
+        let markup = html_with_base("/__bs_assets/ui/");
         (
             [(
                 CONTENT_TYPE,
@@ -60,7 +69,7 @@ pub fn built_ins(state: Arc<ServerState>) -> Router {
             .into_response()
     }
     async fn js_handler(_uri: Uri) -> impl IntoResponse {
-        let markup = include_str!("../../../../bsnext_client/dist/index.js");
+        let markup = include_str!("../../../../bsnext_client/inject/dist/index.js");
         (
             [(
                 CONTENT_TYPE,
@@ -71,8 +80,10 @@ pub fn built_ins(state: Arc<ServerState>) -> Router {
             .into_response()
     }
 
-    route("/__bsnext", get(handler))
+    route("/__bslive", get(handler))
         .route("/__bs_js", get(js_handler))
+        .nest("/__bs_api", pub_api(state.clone()))
+        .nest("/__bs_assets/ui", pub_ui_assets(state.clone()))
         .route("/__bs_ws", get(ws_handler))
         .with_state(state.clone())
 }

package/crates/bsnext_core/src/server/router/pub_api.rs

@@ -0,0 +1,39 @@
+use crate::dto::{RouteDTO, ServerDesc};
+use crate::server::state::ServerState;
+use crate::servers_supervisor::get_servers_handler::GetServersMessage;
+use axum::extract::State;
+use axum::response::IntoResponse;
+use axum::routing::get;
+use axum::{Json, Router};
+use http::{StatusCode, Uri};
+use std::sync::Arc;
+
+async fn all_servers_handler(State(app): State<Arc<ServerState>>, _uri: Uri) -> impl IntoResponse {
+    match &app.parent {
+        None => unreachable!("cannot get here"),
+        Some(parent) => match parent.send(GetServersMessage).await {
+            Ok(servers) => Json(servers).into_response(),
+            Err(err) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Could not fetch servers: {}", err),
+            )
+                .into_response(),
+        },
+    }
+}
+
+async fn get_current_server(State(app): State<Arc<ServerState>>, _uri: Uri) -> impl IntoResponse {
+    let routes = app.routes.read().await;
+    let dto = ServerDesc {
+        routes: routes.iter().map(RouteDTO::from).collect(),
+        id: app.id.to_string(),
+    };
+    Json(dto)
+}
+
+pub fn pub_api(state: Arc<ServerState>) -> Router<Arc<ServerState>> {
+    Router::new()
+        .route("/servers", get(all_servers_handler))
+        .route("/me", get(get_current_server))
+        .with_state(state.clone())
+}

package/crates/bsnext_core/src/server/router/snapshots/bsnext_core__server__router__tests__test__handlers.snap

@@ -0,0 +1,9 @@
+---
+source: crates/bsnext_core/src/server/router/tests.rs
+expression: res.headers()
+---
+{
+    "content-type": "text/html; charset=utf-8",
+    "content-length": "4",
+    "a": "b",
+}

package/crates/bsnext_core/src/server/router/tests.rs

@@ -1,6 +1,5 @@
 #[cfg(test)]
 mod test {
-
     use crate::dto::ClientEvent;
     use crate::server::router::make_router;
     use crate::server::state::ServerState;
@@ -10,6 +9,7 @@ mod test {
     use bsnext_input::route::{CorsOpts, Route, RouteKind};
     use bsnext_input::server_config::{Identity, ServerConfig};
     use http::HeaderValue;
+    use std::collections::BTreeMap;
     use std::sync::Arc;
     use tokio::sync::RwLock;
     use tower::ServiceExt;
@@ -19,6 +19,8 @@ mod test {
             let (sender, _) = tokio::sync::broadcast::channel::<ClientEvent>(10);
             ServerState {
                 routes: Arc::new(RwLock::new(val.routes.clone())),
+                id: val.identity.as_id(),
+                parent: None,
                 client_sender: Arc::new(sender),
             }
         }
@@ -35,6 +37,8 @@ mod test {
 
     #[tokio::test]
     async fn test_handlers() -> Result<(), anyhow::Error> {
+        let headers: BTreeMap<String, String> =
+            [("a".to_string(), "b".to_string())].into_iter().collect();
         let state: ServerState = ServerConfig {
             identity: Identity::Address {
                 bind_address: "127.0.0.1:3000".to_string(),
@@ -42,6 +46,7 @@ mod test {
             routes: vec![Route {
                 path: "/hello".to_string(),
                 kind: RouteKind::html("🐥"),
+                headers: Some(headers),
                 ..Default::default()
             }],
             ..Default::default()
@@ -52,7 +57,7 @@ mod test {
         let req = Request::get("/hello").body(Body::empty()).unwrap();
         let res = app.oneshot(req).await.unwrap();
 
-        assert_eq!(res.headers().get("content-length").unwrap(), "4");
+        insta::assert_debug_snapshot!(res.headers());
         assert_eq!(
             res.headers().get("content-type").unwrap(),
             "text/html; charset=utf-8"
@@ -164,7 +169,7 @@ mod test {
 
         let body = to_resp_body(res).await;
 
-        assert!(body.contains("<title>BSNEXT</title>"));
+        assert!(body.contains("<title>Browsersync LIVE</title>"));
         assert_eq!(status, 404);
         Ok(())
     }
@@ -185,7 +190,7 @@ mod test {
         .into();
 
         let app = make_router(&Arc::new(state));
-        let req = Request::get("/__bsnext").body(Body::empty()).unwrap();
+        let req = Request::get("/__bslive").body(Body::empty()).unwrap();
         let res = app.oneshot(req).await.unwrap();
         let status = res.status().as_u16();
 
@@ -196,8 +201,8 @@ mod test {
 
         let body = to_resp_body(res).await;
 
-        assert!(body.contains("<title>BSNEXT</title>"));
-        assert!(body.contains("<code>/abc</code>"));
+        assert!(body.contains("<title>Browsersync LIVE</title>"));
+        assert!(body.contains("<base href=\"/__bs_assets/ui/\" />"));
         assert_eq!(status, 200);
         Ok(())
     }

package/crates/bsnext_core/src/server/state.rs

@@ -1,4 +1,6 @@
 use crate::dto::ClientEvent;
+use crate::servers_supervisor::actor::ServersSupervisor;
+use actix::Addr;
 use bsnext_input::route::Route;
 use std::fmt::Formatter;
 use std::sync::Arc;
@@ -7,6 +9,8 @@ use tokio::sync::{broadcast, RwLock};
 #[derive(Clone)]
 pub struct ServerState {
     pub routes: Arc<RwLock<Vec<Route>>>,
+    pub id: u64,
+    pub parent: Option<Addr<ServersSupervisor>>,
     pub client_sender: Arc<broadcast::Sender<ClientEvent>>,
 }
 

package/crates/bsnext_core/src/servers_supervisor/get_servers_handler.rs

@@ -1,4 +1,4 @@
-use crate::dto::{GetServersMessageResponse, ServersDTO};
+use crate::dto::{GetServersMessageResponse, ServerDTO};
 use crate::servers_supervisor::actor::ServersSupervisor;
 
 #[derive(actix::Message)]
@@ -13,7 +13,8 @@ impl actix::Handler<GetServersMessage> for ServersSupervisor {
             servers: self
                 .handlers
                 .iter()
-                .map(|(identity, child_handler)| ServersDTO {
+                .map(|(identity, child_handler)| ServerDTO {
+                    id: identity.as_id().to_string(),
                     identity: identity.into(),
                     socket_addr: child_handler.socket_addr.to_string(),
                 })

package/crates/bsnext_core/src/servers_supervisor/start_handler.rs

@@ -31,7 +31,11 @@ impl actix::Handler<StartMessage> for ServersSupervisor {
                     let server = ServerActor::new_from_config(server_config.clone());
                     let actor_addr = server.start();
                     let c = server_config.clone();
-                    actor_addr.send(Listen).map(|r| (r, c))
+                    actor_addr
+                        .send(Listen {
+                            parent: self_addr.clone(),
+                        })
+                        .map(|r| (r, c))
                 })
                 .collect::<Vec<_>>();
 

package/crates/bsnext_fs/src/actor.rs

@@ -14,7 +14,7 @@ use tokio::sync::{broadcast, mpsc};
 use tokio_stream::wrappers::ReceiverStream;
 
 pub struct FsWatcher {
-    pub watcher: Option<notify::FsEventWatcher>,
+    pub watcher: Option<notify::RecommendedWatcher>,
     raw_fs_stream: Arc<broadcast::Sender<InnerChangeEvent>>,
     pub receivers: Vec<Recipient<FsEvent>>,
     pub ctx: FsEventContext,
@@ -50,6 +50,7 @@ impl FsWatcher {
     }
 
     pub fn with_filter(&mut self, f: Filter) {
+        tracing::debug!("adding filter {:?}", f);
         self.filters.push(f)
     }
 

package/crates/bsnext_fs/src/filter.rs

@@ -12,13 +12,22 @@ impl PathFilter for Filter {
     fn filter(&self, pd: &PathDescription) -> bool {
         match self {
             Filter::None => false,
-            Filter::Extension { ext } => pd
-                .absolute
-                .extension()
-                .is_some_and(|x| x.to_string_lossy() == *ext),
+            Filter::Extension { ext } => {
+                tracing::trace!("testing extension `{:?}` against `{}`", pd, ext);
+                pd.absolute
+                    .extension()
+                    .is_some_and(|x| x.to_string_lossy() == *ext)
+            }
             Filter::Glob { glob } => {
                 let target = pd.relative.unwrap_or(pd.absolute);
-                let did_match = glob_match(glob, target.to_string_lossy().to_string().as_str());
+                let compare = target.to_string_lossy().to_string();
+                let did_match = glob_match(glob, &compare);
+                tracing::trace!(
+                    "testing glob `{}` against `{}`: {}",
+                    glob,
+                    compare.as_str(),
+                    did_match
+                );
                 did_match
             }
         }

package/crates/bsnext_fs/src/test/mod.rs

@@ -131,7 +131,7 @@ async fn test_single_file_impl() -> Result<(), Box<dyn std::error::Error>> {
     let tc = TestCase::new(Debounce::trailing_ms(10), None);
     tc.watch().await;
     tc.write_file("test_file.txt").await;
-    let events = tc.get_events_after(Duration::from_millis(300)).await;
+    let events = tc.get_events_after(Duration::from_millis(500)).await;
     assert_eq!(events.len(), 2);
     assert_eq!(
         matches!(events.get(0).unwrap().kind, FsEventKind::PathAdded(..)),

package/crates/bsnext_fs/src/watch_path_handler.rs

@@ -29,7 +29,7 @@ impl Handler<RequestWatchPath> for FsWatcher {
 
                     tracing::debug!(path = ?msg.path, "👀 watching! {} receivers", self.receivers.len());
                     tracing::debug!(?self.cwd);
-                    tracing::debug!(?self.receivers);
+                    tracing::debug!("{} receivers", self.receivers.len());
 
                     let matched = msg.path == self.cwd;
 

package/crates/bsnext_fs/src/watcher.rs

@@ -13,7 +13,7 @@ use tokio::sync::broadcast;
 pub fn create_watcher(
     sender: Arc<broadcast::Sender<InnerChangeEvent>>,
     cwd: &Path,
-) -> notify::Result<notify::FsEventWatcher> {
+) -> notify::Result<notify::RecommendedWatcher> {
     let cwd_c = cwd.to_owned();
     notify::recommended_watcher(move |res: Result<notify::Event, _>| {
         let span = tracing::span!(tracing::Level::TRACE, "raw");
@@ -247,6 +247,7 @@ fn is_auto_excluded<P: AsRef<Path>>(cwd: &P, subject: &P) -> bool {
         ".vscode",
         ".idea",
         ".sass-cache",
+        "bslive.log",
     ]
     .into_iter()
     .map(OsStr::new)

package/crates/bsnext_input/Cargo.toml

@@ -20,3 +20,6 @@ tracing = { workspace = true }
 thiserror = { workspace = true }
 typeshare = { workspace = true }
 nom = "7.1.3"
+
+[dev-dependencies]
+insta = { workspace = true }

package/crates/bsnext_input/src/input_test/mod.rs

@@ -62,6 +62,40 @@ fn test_deserialize_cors_false() {
     assert_eq!(opts, CorsOpts::Cors(false));
 }
 
+#[test]
+fn test_deserialize_3_headers_control() {
+    #[derive(serde::Deserialize, serde::Serialize, Debug)]
+    struct Config {
+        pub items: Vec<Route>,
+    }
+
+    let input = r#"
+    items:
+      - path: /api
+        json: [1,2]
+        "#;
+    let c: Config = serde_yaml::from_str(input).unwrap();
+    insta::assert_debug_snapshot!(c)
+}
+
+#[test]
+fn test_deserialize_3_headers() {
+    #[derive(serde::Deserialize, serde::Serialize, Debug)]
+    struct Config {
+        pub items: Vec<Route>,
+    }
+
+    let input = r#"
+    items:
+      - path: /api
+        json: [1,2]
+        headers:
+            a: b
+        "#;
+    let c: Config = serde_yaml::from_str(input).unwrap();
+    insta::assert_debug_snapshot!(c)
+}
+
 #[test]
 fn test_deserialize_3() {
     let input = r#"

package/crates/bsnext_input/src/input_test/snapshots/bsnext_input__input_test__deserialize_3_headers.snap

@@ -0,0 +1,29 @@
+---
+source: crates/bsnext_input/src/input_test/mod.rs
+expression: c
+---
+Config {
+    items: [
+        Route {
+            path: "/api",
+            cors_opts: None,
+            delay_opts: None,
+            watch_opts: Bool(
+                true,
+            ),
+            kind: Json {
+                json: JsonWrapper(
+                    Array [
+                        Number(1),
+                        Number(2),
+                    ],
+                ),
+            },
+            headers: Some(
+                {
+                    "a": "b",
+                },
+            ),
+        },
+    ],
+}