Function start_fixture

tests/dashboard_api_test/lcm_fixes.rs:319–370

(external_payload: bool)

}

async fn start_fixture(external_payload: bool) -> DashboardFixture {
    let tmp = tempdir_or_panic();
    let project_root = tmp.path().join("project");
    let global_db_path = tmp.path().join("global").join("global.db");
    let env_guard = EnvVarGuard::set(GLOBAL_DB_ENV, &global_db_path);
    // Pre-create both GlobalDb-schema stores from the cached empty template
    // so seeding and dashboard startup open existing DBs instead of paying a
    // full schema creation each (slow on Windows).
    write_empty_global_db_schema(&global_db_path).await;

    let cg = setup_project(&project_root).await;
    let session_db_path = project_session_db_path(&project_root);
    write_empty_global_db_schema(&session_db_path).await;

    let global_db = match GlobalDb::open_at(&session_db_path).await {
        Some(db) => db,
        None => panic!(
            "failed to open temporary session DB at {}",
            session_db_path.display()
        ),
    };
    let storage_root = session_db_path
        .parent()
        .unwrap_or_else(|| panic!("session DB has no parent: {}", session_db_path.display()));
    if let Err(err) = std::fs::create_dir_all(storage_root) {
        panic!("failed to create LCM storage root: {err}");
    }
    let linked_node_id =
        seed_lcm_fixture(&global_db, storage_root, &project_root, external_payload).await;
    drop(global_db);

    if external_payload {
        plant_external_needle(&session_db_path).await;
    }
    let port = pick_free_port();
    let base_url = format!("http://127.0.0.1:{port}");
    let server = tokio::spawn(async move {
        let _ = dashboard::run(&cg, "127.0.0.1", port, false).await;
    });

    let agent = http_agent();
    wait_for_dashboard(&agent, &base_url).await;

    DashboardFixture {
        _tmp: tmp,
        _env_guard: env_guard,
        base_url,
        server,
        global_db_path: session_db_path,
        linked_node_id,
    }
}

fn as_array<'a>(value: &'a Value, what: &str) -> &'a Vec<Value> {
    value