minco-test 0.6.0

In-process HTTP clients, deterministic fixtures, and command evidence for Minco applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

# minco-test

Public plugin conformance, in-process HTTP utilities, deterministic fixtures,
and command evidence for Minco applications and extensions.

## Plugin conformance

`PluginConformance` reads the package's archive-visible
`minco-plugin.json`, checks its Cargo packaging and provider boundary, and can
compare a linked descriptor or exercise a concrete plugin through registration,
graph construction, configuration, composition, and bounded provenance.

```rust
use minco_test::{ConformanceStatus, PluginConformance};
# use minco_core::Plugin;
# fn check<P: Plugin>(plugin: P) {
let report = PluginConformance::for_package(env!("CARGO_MANIFEST_DIR"))
    .with_plugin(plugin)
    .run();

report.assert_passed();
assert_eq!(report.assurance.provider_live, ConformanceStatus::NotRun);
# }
```

Conformance evidence strings are inert labels and are never executed. A passed
report covers the plugin contract only. Application readiness, provider/live
integration, and production readiness remain separate evidence boundaries.

See the [conformance reference](../../docs/reference/plugin-conformance.md) and
the standalone
[`third-party-minimal`](../../examples/plugins/third-party-minimal) fixture.

## HTTP and fixtures

`TestClient` calls an `axum::Router` directly as a Tower service, avoiding a
socket while exercising the real router and middleware stack. The crate also
captures deterministic command evidence for quality and deployment gates.

`FixtureSequence` supplies stable test identities without an ORM, clock,
randomness or global state:

```rust
use minco_test::FixtureSequence;

let mut fixtures = FixtureSequence::new("orders")?;
let order_id = fixtures.next("order")?.stable_id;
assert_eq!(order_id, "orders:order:00000001");
# Ok::<(), minco_test::FixtureError>(())
```

```rust
use axum::{Router, routing::get};
use http::StatusCode;
use minco_test::TestClient;

# async fn check() {
let app = Router::new().route("/health", get(|| async { "ok" }));
let response = TestClient::new(app).get("/health").await;
response.assert_status(StatusCode::OK);
# }
```