Testing

Two Fireweave-provided tools mean unit and most integration tests never need a backend account:

mode: 'local' — seeded boolean map, no network, no credentials. registerTarget records in-process and traces.
InMemoryAdapter — fixture-driven adapter in every language. Use it when you need attribute match conditions, faults, or live mutation.

A third option when you need the real HTTP path: the protocol test server (test-server/).

The test server does not implement POST /v1/targets/register. InMemoryAdapter also does not persist registration (UnsupportedCapability). Use local mode when the test must assert registration.

There is no FireweaveProvider and no makeFireweaveLocalProvider. Bind FireweaveClient (or initFireweave) to an adapter.

Local mode

Present in all seven languages.

Key	Result
Present in the seeded map	Mapped boolean, reason `STATIC`
Absent	Caller default, reason `DEFAULT`

Reading a seeded key as a string or number is TypeMismatch. The map is boolean-only.

import { initFireweave } from '@fireweaveai/server-sdk';

const fireweave = await initFireweave({
  mode: 'local',
  local: { controlPoints: { 'new-checkout': true } },
});

const on = await fireweave.controlPoints.getBooleanValue('new-checkout', false, {
  targetingKey: 'u1',
});
// → true

await fireweave.registerTarget('user_42'); // recorded + traced; nothing sent
await fireweave.shutdown();

import { initFireweave } from '@fireweaveai/web-sdk';

const fireweave = await initFireweave({
  mode: 'local',
  local: { controlPoints: { 'new-checkout': true } },
});

const on = fireweave.controlPoints.getBooleanValue('new-checkout', false);
await fireweave.shutdown();

from fireweave import init_fireweave

client = init_fireweave(mode="local", local={"control_points": {"new-checkout": True}})
client.control_points.get_boolean_value("new-checkout", False)  # -> True
client.register_target("user_42")  # recorded in-process + traced
client.shutdown()

client, err := fireweave.Init(fireweave.Options{
    Mode:  fireweave.ModeLocal,
    Local: &fireweave.LocalOptions{ControlPoints: map[string]bool{"new-checkout": true}},
})
on := client.ControlPoints().GetBooleanValue("new-checkout", false, nil)
_ = on

FireweaveClient client = Fireweave.init(InitOptions.local(Map.of("new-checkout", true)));
boolean on = client.controlPoints().getBooleanValue(
    "new-checkout", false, EvaluationContext.empty());
client.close();

use fireweave::{init_fireweave, InitOptions};
use std::collections::HashMap;

let mut control_points = HashMap::new();
control_points.insert("new-checkout".to_string(), true);
let client = init_fireweave(InitOptions::local_with_control_points(control_points)).unwrap();
assert!(client.control_points.get_boolean_value("new-checkout", false, None));
client.register_target("user_42", None);
client.shutdown();

Call-site defaults stay false. Do not write getBooleanValue(key, true) to dogfood locally — that same true is the production fallback when a control point is absent.

InMemoryAdapter

Same conceptual fixture in every language: type, enabled, value, optional variant, and optional match conditions that gate on context attributes (no match → your default). Java: artifact ai.fireweave:fireweave-testing (never published; maven.deploy.skip=true). Web: InMemoryWebAdapter.

Node
Python
Go
Java
Rust

import { strict as assert } from 'node:assert';
import { test } from 'node:test';
import { FireweaveClient, FireweaveRuntime, InMemoryAdapter } from '@fireweaveai/server-sdk';

test('beta cohort gets the new checkout', async () => {
  const adapter = new InMemoryAdapter({
    flags: {
      'new-checkout': {
        type: 'boolean',
        enabled: true,
        value: true,
        variant: 'on',
        matchAttribute: { cohort: 'beta' },
      },
    },
  });
  const runtime = new FireweaveRuntime(adapter);
  await runtime.initialize();
  const client = new FireweaveClient(runtime);

  assert.equal(
    await client.controlPoints.getBooleanValue('new-checkout', false, {
      targetingKey: 'u1',
      cohort: 'beta',
    }),
    true,
  );
  assert.equal(
    await client.controlPoints.getBooleanValue('new-checkout', false, { targetingKey: 'u2' }),
    false,
  );
  await client.shutdown();
});

Node extras: fault: { kind: 'Timeout' } fails every resolve with that kind; initError: 'Configuration' fails initialize() (runtime → FATAL).

from fireweave import (
    EvaluationContext,
    FireweaveClient,
    FireweaveRuntime,
    InMemoryAdapter,
)

def test_beta_cohort_gets_new_checkout():
    adapter = InMemoryAdapter({
        "new-checkout": {
            "type": "boolean",
            "enabled": True,
            "value": True,
            "variant": "on",
            "matchAttribute": {"cohort": "beta"},
        },
    })
    runtime = FireweaveRuntime(adapter)
    runtime.initialize()
    client = FireweaveClient(runtime)
    assert client.control_points.get_boolean_value(
        "new-checkout", False, EvaluationContext("u1", {"cohort": "beta"})
    ) is True
    assert client.control_points.get_boolean_value(
        "new-checkout", False, EvaluationContext("u2", {})
    ) is False
    client.shutdown()

adapter := inmemory.New(inmemory.WithFlags(map[string]inmemory.Flag{
    "new-checkout": {
        Type:            fireweave.FlagTypeBoolean,
        Enabled:         true,
        Value:           true,
        Variant:         "on",
        MatchAttributes: map[string]any{"cohort": "beta"},
    },
}))
runtime := fireweave.NewRuntime(adapter, fireweave.Config{})
if err := runtime.Initialize(context.Background()); err != nil {
    t.Fatal(err)
}
client := fireweave.NewClient(runtime)
evalCtx := fireweave.NewEvaluationContext("u1", map[string]any{"cohort": "beta"})
if !client.ControlPoints().GetBooleanValue("new-checkout", false, &evalCtx) {
    t.Fatal("expected true for beta cohort")
}

Import github.com/FireWeave-HQ/fireweave-sdk/sdks/go/v2/infrastructure/adapters/inmemory.

InMemoryAdapter.FlagDefinition def = new InMemoryAdapter.FlagDefinition();
def.type = FlagType.BOOLEAN;
def.enabled = true;
def.variant = "on";
def.value = JsonValue.of(true);

InMemoryAdapter adapter = new InMemoryAdapter(Map.of("new-checkout", def));
FireweaveRuntime runtime = new FireweaveRuntime(FireweaveConfig.builder().build(), adapter);
runtime.initialize();
FireweaveClient client = new FireweaveClient(runtime);

boolean enabled = client.controlPoints().getBooleanValue(
    "new-checkout", false, EvaluationContext.builder().targetingKey("u1").build());

use fireweave::{FireweaveClient, FireweaveRuntime, InMemoryAdapter, RuntimeConfig};
use std::sync::Arc;

let adapter = InMemoryAdapter::new(
    serde_json::json!({
        "new-checkout": { "type": "boolean", "enabled": true, "variant": "on", "value": true }
    })
    .as_object()
    .unwrap()
    .clone(),
);
let runtime = Arc::new(FireweaveRuntime::new(Box::new(adapter), RuntimeConfig::default()));
runtime.initialize().unwrap();
let client = FireweaveClient::new(runtime);
assert!(client.control_points.get_boolean_value("new-checkout", false, None));

cohort: 'beta' in these snippets is an example attribute name, not an SDK type. See Targeting.

Protocol test server

Zero-dependency Node stub, loopback-only by default:

node test-server/implementation/server.mjs            # http://127.0.0.1:3901
node test-server/implementation/server.mjs --port 4000

Routes that exist

Method	Path	Role
`POST`	`/v1/flags/evaluate`	Evaluate
`POST`	`/v1/capture`	Capture batch
`GET`	`/health`	`{ "ok": true }`

Not implemented: POST /v1/targets/register. The stub also still serves legacy vendor routes (POST /flags?v=2, definitions poll, /batch/) for historical harnesses. No shipped SDK talks those paths. Auth on Fireweave routes: Authorization: Bearer <key>. Any non-empty key is accepted unless you configure one. Use obviously fake keys (project-api-key_dev). The stub serves its own fixture keys (fw-bool-on, and others from test-server/fixtures/flags-v2-success.json). Keys your app expects resolve FlagNotFound → default unless you replace fixtures. Point initFireweave({ mode: 'remote', apiUrl, apiKey }) at http://127.0.0.1:3901. Your application reads FW_API_URL if you want; the SDK does not.

Faults and assertions

Call	Effect
`POST /_test/fault`	Inject `delay`, `401`, `429`, `500`, `invalid_json`, `truncated`, `quota_limited`
`POST /_test/reset`	Restore fixtures, clear faults/events
`GET /_test/events`	`{ fwEvents }` from `POST /v1/capture`
`GET /_test/requests`	Which routes the adapter called

Per-request: header X-Fw-Test-Fault: <mode> or query ?fault=<mode>.

What to assert

On / off / no-match → value, variant, reason.
Missing key on remote → default + FlagNotFound (never a throw).
Missing key on local → default + DEFAULT (never an error).
Type mismatch → default + TypeMismatch.
Missing targetingKey with requireTargetingKey → default + TARGETING_KEY_MISSING.
Before init / after shutdown → default + NotReady / AlreadyClosed.
Local registerTarget → { ok: true } and a readable recorded set.
Do not assert target registration against InMemory or the test-server stub.

CI

Cross-language fixtures live in contracts/. Surface parity is conformance/surface/control-points.surface.json. That suite is for SDK contributors — application tests should use local mode or InMemoryAdapter (or the stub for HTTP).

Adapters

InMemory vs remote vs local

Troubleshooting

Defaults, fixtures, and install mismatches

Get Started

SDKs

Concepts

Production

CLI

Terraform

Troubleshooting

Migration

Reference

Testing

Local mode

InMemoryAdapter

Protocol test server

Routes that exist

Faults and assertions

What to assert

CI

Next

Adapters

Troubleshooting

​Local mode

​InMemoryAdapter

​Protocol test server

​Routes that exist

​Faults and assertions

​What to assert

​CI

​Next

Adapters

Troubleshooting

Local mode

InMemoryAdapter

Protocol test server

Routes that exist

Faults and assertions

What to assert

CI

Next