conformance

func RunSensorSuite ¶ added in v0.16.0

func RunSensorSuite(t *testing.T, start StartSensor, opts SuiteOptions)

RunSensorSuite checks a sensor against the platform contract every sensor must keep, whatever tools it runs, so a third-party sensor can prove it in its own tests:

func TestConformance(t *testing.T) {
	httpsec.AllowLoopback = true // the fake listens on 127.0.0.1
	conformance.RunSensorSuite(t, func(t *testing.T, p conformance.SensorEndpoint) func() {
		kit, err := sensorkit.New(sensorkit.Options{Name: "my-sensor", Version: "1.0.0",
			APIURL: p.URL, APIKey: p.APIKey, StateDir: t.TempDir(),
			Outbox: sensorkit.OutboxSettings{Dir: t.TempDir()}})
		if err != nil {
			t.Fatal(err)
		}
		kit.AddScanner(myScanner)
		ctx, cancel := context.WithCancel(context.Background())
		done := make(chan error, 1)
		go func() { done <- kit.Run(ctx) }()
		return func() { cancel(); <-done }
	}, conformance.SuiteOptions{ScanPayload: json.RawMessage(`{"scanner":"my-tool","target":"..."}`)})
}

Each check runs against its own FakePlatform (protocol v2, control plane and manifest on):

• Heartbeat: the sensor heartbeats and names the SDK it is built on.
• Manifest: a sensor that announces a manifest digest registers the manifest when the platform asks for it.
• UnknownCommand: a command of a type the sensor does not handle is left pending for a sensor that does (or failed), never claimed and abandoned, and the sensor keeps polling.
• ForwardCompatible: the same with every answer carrying a JSON member no SDK knows (FutureMember), as a newer platform's would: the sensor ignores it and keeps working (and runs its own command, with ScanPayload).
• Command (with ScanPayload): the command completes, and every report sent for it is committed before the command is completed.

func RunToolSuite ¶ added in v0.18.0

func RunToolSuite(t T, manifestPath string, opts ToolSuiteOptions)

RunToolSuite checks a tool that runs as its own program (a tool.yaml with a run section, any language) against adapter protocol v1, the way the sensor's runtime will run it:

• Manifest: the tool.yaml loads strictly and validates, and has a run section.
• Handshake: the program answers the runtime's hello with protocol 1, ignores a message type it does not know, and answers describe with exactly its tool.yaml (the run section aside).
• Validate: a configuration with an unknown key is refused.
• StdoutIsProtocol: everything it writes to standard output is a protocol message (diagnostics belong on standard error).
• ExitsOnEOF: it exits, with status 0, when its input ends.
• Cancel: after run and cancel it sends its result, or exits, within the 10-second grace.
• Fixtures: each self-test fixture (manifest selftest: a task file and the CTIS it must produce) runs through the runtime's own host, with every runtime check, and produces exactly the expected normalized report, with no invalid message.

Use it from go test (conformance.RunToolSuite(t, "tool.yaml", conformance.ToolSuiteOptions{})) or with the command cmd/openctem-conformance.