refactor(go): more test cleanups

Author: fabriziodemaria

openfeature-provider/go/confidence/local_resolver_provider_resolve_test.go

@@ -210,5 +210,53 @@ func TestLocalResolverProvider_MissingMaterializations(t *testing.T) {
 
 		t.Logf("✓ Resolve succeeded for flag without materialization requirements")
 	})
-}
 
+	t.Run("Provider returns missing materializations error message", func(t *testing.T) {
+		// Create state with a flag that requires materializations
+		stickyState := createStateWithStickyFlag()
+		accountId := "test-account"
+
+		flagLogger := NewNoOpWasmFlagLogger()
+		swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, stickyState, accountId)
+		if err != nil {
+			t.Fatalf("Failed to create SwapWasmResolverApi: %v", err)
+		}
+		defer swap.Close(ctx)
+
+		factory := &LocalResolverFactory{
+			resolverAPI: swap,
+		}
+
+		provider := NewLocalResolverProvider(factory, "test-secret")
+
+		evalCtx := openfeature.FlattenedContext{
+			"user_id": "test-user-123",
+		}
+
+		// Try to evaluate a flag that requires materializations without providing them
+		defaultValue := false
+		result := provider.BooleanEvaluation(ctx, "sticky-test-flag.enabled", defaultValue, evalCtx)
+
+		// Should return the default value
+		if result.Value != defaultValue {
+			t.Errorf("Expected default value %v when materializations missing, got %v", defaultValue, result.Value)
+		}
+
+		// Should have ErrorReason
+		if result.Reason != openfeature.ErrorReason {
+			t.Errorf("Expected ErrorReason when materializations missing, got %v", result.Reason)
+		}
+
+		// Should have an error with the exact message "missing materializations"
+		if result.ResolutionError.Error() == "" {
+			t.Error("Expected ResolutionError when materializations missing")
+		}
+
+		expectedErrorMsg := "missing materializations"
+		if result.ResolutionError.Error() != "GENERAL: missing materializations" {
+			t.Errorf("Expected error message 'GENERAL: %s', got: %v", expectedErrorMsg, result.ResolutionError)
+		}
+
+		t.Logf("✓ Provider correctly returned default value with 'missing materializations' error message")
+	})
+}

openfeature-provider/go/confidence/swap_wasm_resolver_api_test.go

@@ -654,101 +654,6 @@ func TestSwapWasmResolverApi_ResolveWithSticky_NotProcessSticky(t *testing.T) {
 	t.Logf("✓ ResolveWithSticky works with NotProcessSticky enabled")
 }
 
-func TestSwapWasmResolverApi_ResolveWithSticky_AfterStateUpdate(t *testing.T) {
-	ctx := context.Background()
-	runtime := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfig())
-	defer runtime.Close(ctx)
-
-	flagLogger := NewNoOpWasmFlagLogger()
-	testState := loadTestResolverState(t)
-	testAcctID := loadTestAccountID(t)
-
-	swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, testState, testAcctID)
-	if err != nil {
-		t.Fatalf("Failed to create SwapWasmResolverApi: %v", err)
-	}
-	defer swap.Close(ctx)
-
-	// Update state
-	newState := loadTestResolverState(t)
-	err = swap.UpdateStateAndFlushLogs(newState, testAcctID)
-	if err != nil {
-		t.Fatalf("UpdateStateAndFlushLogs failed: %v", err)
-	}
-
-	// Test ResolveWithSticky after state update
-	request := &resolver.ResolveFlagsRequest{
-		Flags:        []string{"flags/tutorial-feature"},
-		Apply:        false,
-		ClientSecret: "mkjJruAATQWjeY7foFIWfVAcBWnci2YF",
-		EvaluationContext: &structpb.Struct{
-			Fields: map[string]*structpb.Value{
-				"visitor_id": structpb.NewStringValue("tutorial_visitor"),
-			},
-		},
-	}
-
-	stickyRequest := &resolver.ResolveWithStickyRequest{
-		ResolveRequest:          request,
-		MaterializationsPerUnit: make(map[string]*resolver.MaterializationMap),
-		FailFastOnSticky:        false,
-		NotProcessSticky:        false,
-	}
-
-	response, err := swap.ResolveWithSticky(stickyRequest)
-	if err != nil {
-		t.Fatalf("ResolveWithSticky failed after state update: %v", err)
-	}
-
-	if response == nil {
-		t.Fatal("Expected non-nil response")
-	}
-
-	// Verify we got a success result
-	successResult, ok := response.ResolveResult.(*resolver.ResolveWithStickyResponse_Success_)
-	if !ok {
-		t.Fatal("Expected success result from ResolveWithSticky")
-	}
-
-	if successResult.Success.Response == nil {
-		t.Fatal("Expected non-nil resolve response")
-	}
-
-	if len(successResult.Success.Response.ResolvedFlags) != 1 {
-		t.Errorf("Expected 1 resolved flag, got %d", len(successResult.Success.Response.ResolvedFlags))
-	}
-
-	// Verify the values are correct after state update
-	resolvedFlag := successResult.Success.Response.ResolvedFlags[0]
-	if resolvedFlag.Value == nil {
-		t.Fatal("Expected non-nil value in resolved flag")
-	}
-
-	fields := resolvedFlag.Value.GetFields()
-	if fields == nil {
-		t.Fatal("Expected fields in resolved value")
-	}
-
-	// Verify the correct variant values are present after update
-	expectedMessage := "We are very excited to welcome you to Confidence! This is a message from the tutorial flag."
-	messageValue, hasMessage := fields["message"]
-	if !hasMessage {
-		t.Error("Expected 'message' field in resolved value")
-	} else if messageValue.GetStringValue() != expectedMessage {
-		t.Errorf("Expected message '%s' after state update, got '%s'", expectedMessage, messageValue.GetStringValue())
-	}
-
-	expectedTitle := "Welcome to Confidence!"
-	titleValue, hasTitle := fields["title"]
-	if !hasTitle {
-		t.Error("Expected 'title' field in resolved value")
-	} else if titleValue.GetStringValue() != expectedTitle {
-		t.Errorf("Expected title '%s' after state update, got '%s'", expectedTitle, titleValue.GetStringValue())
-	}
-
-	t.Logf("✓ ResolveWithSticky works correctly after state update with correct values")
-}
-
 func TestSwapWasmResolverApi_ResolveWithSticky_NonExistentFlag(t *testing.T) {
 	ctx := context.Background()
 	runtime := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfig())
@@ -802,116 +707,6 @@ func TestSwapWasmResolverApi_ResolveWithSticky_NonExistentFlag(t *testing.T) {
 	t.Logf("✓ ResolveWithSticky works with minimal state (no test data required)")
 }
 
-func TestSwapWasmResolverApi_ResolveWithSticky_InstanceClosing(t *testing.T) {
-	ctx := context.Background()
-	runtime := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfig())
-	defer runtime.Close(ctx)
-
-	flagLogger := NewNoOpWasmFlagLogger()
-	initialState := createMinimalResolverState()
-	accountId := "test-account"
-
-	// Initialize host functions and compile module
-	compiledModule, err := InitializeWasmRuntime(ctx, runtime, defaultWasmBytes)
-	if err != nil {
-		t.Fatalf("Failed to initialize WASM runtime: %v", err)
-	}
-
-	// Create resolver API instance
-	resolverApi := NewResolverApiFromCompiled(ctx, runtime, compiledModule, flagLogger)
-
-	// Set state
-	err = resolverApi.SetResolverState(initialState, accountId)
-	if err != nil {
-		t.Fatalf("Failed to set resolver state: %v", err)
-	}
-
-	// Mark instance as closing
-	resolverApi.mu.Lock()
-	resolverApi.isClosing = true
-	resolverApi.mu.Unlock()
-
-	// Try to resolve - should get ErrInstanceClosed
-	request := &resolver.ResolveWithStickyRequest{
-		ResolveRequest: &resolver.ResolveFlagsRequest{
-			Flags:        []string{"flags/test"},
-			Apply:        false,
-			ClientSecret: "test-secret",
-		},
-		MaterializationsPerUnit: make(map[string]*resolver.MaterializationMap),
-	}
-
-	_, err = resolverApi.ResolveWithSticky(request)
-	if !errors.Is(err, ErrInstanceClosed) {
-		t.Errorf("Expected ErrInstanceClosed, got %v", err)
-	}
-
-	t.Logf("✓ ResolveWithSticky correctly returns ErrInstanceClosed when instance is closing")
-}
-
-func TestSwapWasmResolverApi_ResolveWithSticky_DirectInstanceCall(t *testing.T) {
-	ctx := context.Background()
-	runtime := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfig())
-	defer runtime.Close(ctx)
-
-	flagLogger := NewNoOpWasmFlagLogger()
-	initialState := createMinimalResolverState()
-	accountId := "test-account"
-
-	// Initialize host functions and compile module
-	compiledModule, err := InitializeWasmRuntime(ctx, runtime, defaultWasmBytes)
-	if err != nil {
-		t.Fatalf("Failed to initialize WASM runtime: %v", err)
-	}
-
-	// Create resolver API instance
-	resolverApi := NewResolverApiFromCompiled(ctx, runtime, compiledModule, flagLogger)
-
-	// Set state
-	err = resolverApi.SetResolverState(initialState, accountId)
-	if err != nil {
-		t.Fatalf("Failed to set resolver state: %v", err)
-	}
-
-	// Create a basic ResolveWithSticky request
-	request := &resolver.ResolveWithStickyRequest{
-		ResolveRequest: &resolver.ResolveFlagsRequest{
-			Flags:        []string{"flags/test-flag"},
-			Apply:        false,
-			ClientSecret: "test-secret",
-			EvaluationContext: &structpb.Struct{
-				Fields: map[string]*structpb.Value{
-					"user_id": structpb.NewStringValue("test-user"),
-				},
-			},
-		},
-		MaterializationsPerUnit: make(map[string]*resolver.MaterializationMap),
-		FailFastOnSticky:        false,
-		NotProcessSticky:        false,
-	}
-
-	response, err := resolverApi.ResolveWithSticky(request)
-	// The WASM module may return an error if client secret not found or flag doesn't exist
-	// This is acceptable as it proves the method is working
-	if err != nil {
-		// Log the error and verify the method executed
-		t.Logf("Got expected error (client secret/flag validation): %v", err)
-		// This is actually a pass - the method executed and returned an error from WASM
-		resolverApi.Close(ctx)
-		t.Logf("✓ Direct instance ResolveWithSticky call test passed - method executed successfully")
-		return
-	}
-
-	if response == nil {
-		t.Fatal("Expected non-nil response")
-	}
-
-	// Close the instance
-	resolverApi.Close(ctx)
-
-	t.Logf("✓ Direct instance ResolveWithSticky call test passed")
-}
-
 func TestSwapWasmResolverApi_ResolveWithSticky_MissingMaterializations(t *testing.T) {
 	ctx := context.Background()
 	runtime := wazero.NewRuntimeWithConfig(ctx, wazero.NewRuntimeConfig())