test: improve Go and FFI coverage

Signed-off-by: Will Killian <wkillian@nvidia.com>

Author: willkill07

crates/ffi/tests/integration/api/coverage_sweeps_tests.rs

@@ -245,6 +245,12 @@ fn test_llm_request_null_inputs_event_null_guards_and_free_nulls() {
     assert!(unsafe { nemo_relay_event_tool_call_id(std::ptr::null()) }.is_null());
     assert!(unsafe { nemo_relay_event_parent_uuid(std::ptr::null()) }.is_null());
     assert!(unsafe { nemo_relay_event_scope_type(std::ptr::null()) }.is_null());
+    assert!(unsafe { nemo_relay_event_atof_version(std::ptr::null()) }.is_null());
+    assert!(unsafe { nemo_relay_event_scope_category(std::ptr::null()) }.is_null());
+    assert!(unsafe { nemo_relay_event_category(std::ptr::null()) }.is_null());
+    assert!(unsafe { nemo_relay_event_attributes_json(std::ptr::null()) }.is_null());
+    assert!(unsafe { nemo_relay_event_category_profile(std::ptr::null()) }.is_null());
+    assert!(unsafe { nemo_relay_event_data_schema(std::ptr::null()) }.is_null());
 
     unsafe {
         nemo_relay_scope_handle_free(std::ptr::null_mut());
@@ -256,6 +262,7 @@ fn test_llm_request_null_inputs_event_null_guards_and_free_nulls() {
         nemo_relay_atif_exporter_free(std::ptr::null_mut());
         nemo_relay_otel_subscriber_free(std::ptr::null_mut());
         nemo_relay_openinference_subscriber_free(std::ptr::null_mut());
+        nemo_relay_adaptive_runtime_free(std::ptr::null_mut());
     }
 }
 
@@ -329,6 +336,9 @@ fn test_valid_free_functions_and_none_backed_accessors() {
         ),
     )));
     unsafe { nemo_relay_atif_exporter_free(exporter_ptr) };
+
+    let adaptive_ptr = Box::into_raw(Box::new(FfiAdaptiveRuntime(std::sync::Mutex::new(None))));
+    unsafe { nemo_relay_adaptive_runtime_free(adaptive_ptr) };
 }
 
 #[test]
@@ -386,10 +396,26 @@ fn test_llm_request_and_event_accessors() {
         take_string(unsafe { nemo_relay_event_scope_category(&ffi_event) }),
         Some("start".into())
     );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_atof_version(&ffi_event) }),
+        Some("0.1".into())
+    );
     assert_eq!(
         take_string(unsafe { nemo_relay_event_category(&ffi_event) }),
         Some("guardrail".into())
     );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_attributes_json(&ffi_event) }),
+        Some("[]".into())
+    );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_category_profile(&ffi_event) }),
+        None
+    );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_data_schema(&ffi_event) }),
+        None
+    );
     assert_eq!(
         take_string(unsafe { nemo_relay_event_uuid(&ffi_event) }),
         Some(scope_event.uuid().to_string())
@@ -464,6 +490,10 @@ fn test_llm_request_and_event_accessors() {
         take_string(unsafe { nemo_relay_event_model_name(&ffi_llm_event) }),
         Some("model".into())
     );
+    let llm_profile = take_string(unsafe { nemo_relay_event_category_profile(&ffi_llm_event) })
+        .expect("expected category profile");
+    let llm_profile: serde_json::Value = serde_json::from_str(&llm_profile).unwrap();
+    assert_eq!(llm_profile["model_name"], json!("model"));
     assert_eq!(
         take_string(unsafe { nemo_relay_event_scope_type(&ffi_llm_event) }),
         Some("llm".into())
@@ -507,6 +537,22 @@ fn test_llm_request_and_event_accessors() {
         take_string(unsafe { nemo_relay_event_scope_type(&ffi_mark_event) }),
         None
     );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_atof_version(&ffi_mark_event) }),
+        Some("0.1".into())
+    );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_scope_category(&ffi_mark_event) }),
+        None
+    );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_category(&ffi_mark_event) }),
+        None
+    );
+    assert_eq!(
+        take_string(unsafe { nemo_relay_event_attributes_json(&ffi_mark_event) }),
+        None
+    );
     assert_eq!(unsafe { nemo_relay_event_attributes(&ffi_mark_event) }, 0);
 }
 

crates/ffi/tests/unit/api/coverage_sweeps_tests.rs

@@ -4,8 +4,9 @@
 package adaptive
 
 import (
-	nemo_relay "github.com/NVIDIA/NeMo-Relay/go/nemo_relay"
 	"testing"
+
+	nemo_relay "github.com/NVIDIA/NeMo-Relay/go/nemo_relay"
 )
 
 func TestConfigBuilders(t *testing.T) {
@@ -77,3 +78,31 @@ func TestRedisBackendAndComponentSpecBuilders(t *testing.T) {
 		t.Fatalf("expected wrapped config to preserve acg provider, got %#v", acgConfig["provider"])
 	}
 }
+
+func TestAdaptivePackageTelemetryAndLatencyHelpers(t *testing.T) {
+	promptTokens := uint64(40)
+	cacheReadTokens := uint64(10)
+	event, err := BuildCacheTelemetryEvent(CacheTelemetryEventInput{
+		Provider:  "openai",
+		RequestID: "00000000-0000-0000-0000-000000000501",
+		Usage: &CacheUsage{
+			PromptTokens:    &promptTokens,
+			CacheReadTokens: &cacheReadTokens,
+		},
+		AgentID:         "go-adaptive-wrapper",
+		TemplateVersion: "v1",
+		ToolsetHash:     "tools",
+		ModelFamily:     "gpt",
+		TenantScope:     "tenant",
+	})
+	if err != nil {
+		t.Fatalf("BuildCacheTelemetryEvent failed: %v", err)
+	}
+	if event == nil || event.HitRate != 0.25 {
+		t.Fatalf("unexpected cache telemetry event: %#v", event)
+	}
+
+	if err := SetLatencySensitivity(0); err == nil {
+		t.Fatal("expected SetLatencySensitivity to reject zero")
+	}
+}

crates/ffi/tests/unit/types_tests.rs

@@ -149,6 +149,18 @@ func TestAdaptiveRuntimeBuildCacheRequestFacts(t *testing.T) {
 	}
 }
 
+func TestAdaptiveRuntimeBindScopeRejectsNilScope(t *testing.T) {
+	runtime, err := NewAdaptiveRuntime(testAdaptiveRuntimeConfig("openai"))
+	if err != nil {
+		t.Fatalf("NewAdaptiveRuntime failed: %v", err)
+	}
+	defer runtime.Shutdown()
+
+	if err := runtime.BindScope(nil); err == nil {
+		t.Fatal("expected BindScope to reject nil scope")
+	}
+}
+
 func TestSetLatencySensitivityRejectsInvalidValue(t *testing.T) {
 	if SetLatencySensitivity(0) == nil {
 		t.Fatal("expected SetLatencySensitivity(0) to fail")

go/nemo_relay/adaptive/optimizer_test.go

@@ -23,3 +23,17 @@ func TestPiiRedactionShorthandHelpers(t *testing.T) {
 		t.Fatalf("unexpected diagnostics: %#v", report.Diagnostics)
 	}
 }
+
+func TestPiiRedactionComponentSpecAndLocalModelHelpers(t *testing.T) {
+	config := NewConfig()
+	local := NewLocalModelConfig()
+	local.Backend = "local"
+	local.ModelID = "pii-model"
+	config.Mode = "local"
+	config.Local = &local
+
+	spec := NewComponentSpec(config)
+	if !spec.Enabled || spec.Config.Local == nil || spec.Config.Local.ModelID != "pii-model" {
+		t.Fatalf("unexpected PII redaction component spec: %#v", spec)
+	}
+}

go/nemo_relay/adaptive_runtime_test.go

@@ -3,7 +3,10 @@
 
 package pricing
 
-import "testing"
+import (
+	"encoding/json"
+	"testing"
+)
 
 func TestPricingPackageHelpers(t *testing.T) {
 	entry := NewModelPricing("test", "priced-model")
@@ -29,3 +32,45 @@ func TestPricingPackageHelpers(t *testing.T) {
 		t.Fatalf("expected clean report, got %#v", report.Diagnostics)
 	}
 }
+
+func TestPricingPackageSourceAndRateHelpers(t *testing.T) {
+	fileSource := NewFileSource("/tmp/pricing.json")
+	payload, err := json.Marshal(fileSource)
+	if err != nil {
+		t.Fatalf("marshal file source: %v", err)
+	}
+	var parsedSource map[string]any
+	if err := json.Unmarshal(payload, &parsedSource); err != nil {
+		t.Fatalf("unmarshal file source: %v", err)
+	}
+	if parsedSource["type"] != "file" || parsedSource["path"] != "/tmp/pricing.json" {
+		t.Fatalf("unexpected file source: %#v", parsedSource)
+	}
+
+	promptCache := NewPromptCacheConfig()
+	if promptCache.ReadAccounting != CacheReadIncludedInPromptTokens {
+		t.Fatalf("unexpected prompt cache defaults: %#v", promptCache)
+	}
+
+	minTokens := uint64(256)
+	tier := NewTokenRateTier(NewTokenRates(3, 4))
+	tier.MinPromptTokens = &minTokens
+	schedule := NewPromptTokenThresholdRateSchedule(tier)
+	schedulePayload, err := json.Marshal(schedule)
+	if err != nil {
+		t.Fatalf("marshal rate schedule: %v", err)
+	}
+	var parsedSchedule map[string]any
+	if err := json.Unmarshal(schedulePayload, &parsedSchedule); err != nil {
+		t.Fatalf("unmarshal rate schedule: %v", err)
+	}
+	if parsedSchedule["type"] != "prompt_token_threshold" || parsedSchedule["applies_to"] != "full_request" {
+		t.Fatalf("unexpected rate schedule: %#v", parsedSchedule)
+	}
+
+	config := NewConfig()
+	component := Component(config)
+	if component.Kind != PluginKind || !component.Enabled {
+		t.Fatalf("unexpected pricing component: %#v", component)
+	}
+}

go/nemo_relay/pii_redaction/pii_redaction_test.go

@@ -36,8 +36,8 @@ func countScopedMarks(t *testing.T, handle *nemo_relay.ScopeHandle) int {
 	if err := nemo_relay.EmitEvent("first-mark"); err != nil {
 		t.Fatalf("EmitEvent failed: %v", err)
 	}
-	if err := nemo_relay.FlushSubscribers(); err != nil {
-		t.Fatalf("FlushSubscribers failed: %v", err)
+	if err := subscriberspkg.Flush(); err != nil {
+		t.Fatalf("Flush failed: %v", err)
 	}
 	if err := subscriberspkg.ScopeDeregister(handle.UUID(), "subs_local"); err != nil {
 		t.Fatalf("ScopeDeregister failed: %v", err)
@@ -75,8 +75,8 @@ func TestSubscriberShorthands(t *testing.T) {
 	if err := subscriberspkg.Deregister("subs_global"); err != nil {
 		t.Fatalf("Deregister failed: %v", err)
 	}
-	if err := nemo_relay.FlushSubscribers(); err != nil {
-		t.Fatalf("FlushSubscribers failed: %v", err)
+	if err := subscriberspkg.Flush(); err != nil {
+		t.Fatalf("Flush failed: %v", err)
 	}
 
 	mu.Lock()