Fix union serialization tests based on reviewer feedback

Author: vcjana

codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/serialize/JsonSerializerGeneratorTest.kt

@@ -39,10 +39,10 @@ class JsonSerializerGeneratorTest {
         use aws.protocols#restJson1
 
         union TestUnion {
-            unitMember: Unit,
-            dataMember: String
+            unitMember: Unit
         }
 
+        // Empty unit struct that doesn't need serialization parameters
         structure Unit {}
 
         @http(uri: "/test", method: "POST")
@@ -370,19 +370,13 @@ class JsonSerializerGeneratorTest {
     @Test
     fun `union with unit struct doesn't cause unused variable warning`() {
         // Regression test for https://github.com/smithy-lang/smithy-rs/issues/4308
-        //
-        // PROBLEM BEFORE FIX: JSON serializer generated `UnitMember(_inner)` but tried to use `inner`
-        // This caused compilation errors: "cannot find value `inner` in this scope"
-        //
-        // SOLUTION AFTER FIX: Generate `UnitMember(inner)` so variable name matches usage
-        // This test verifies the FIXED behavior compiles and works correctly
+        // This test ensures that union serialization with unit structs compiles without unused variable warnings.
         val model = RecursiveShapeBoxer().transform(OperationNormalizer.transform(unionWithUnitStructModel))
 
         val codegenContext = testCodegenContext(model)
         val symbolProvider = codegenContext.symbolProvider
         val project = TestWorkspace.testProject(symbolProvider)
 
-        // Generate the JSON serializer with our FIX applied
         val jsonSerializer =
             JsonSerializerGenerator(
                 codegenContext,
@@ -399,31 +393,26 @@ class JsonSerializerGeneratorTest {
             UnionGenerator(model, symbolProvider, this, model.lookup("test#TestUnion")).render()
         }
 
-        // Test that demonstrates our fix works - generates correct variable names
         project.lib {
             unitTest(
-                "json_union_serialization_fix_works",
+                "test_union_serialization",
                 """
                 use test_model::{TestUnion, Unit};
 
-                // Generate the FIXED serialization function (uses 'inner' consistently)
                 ${format(operationGenerator!!)};
 
-                // Test the union serialization with unit struct - this works with our fix
-                // BEFORE: would fail with "cannot find value `inner`" compilation error
-                // AFTER: compiles and works because variable names match
-                let test_union = TestUnion::UnitMember(Unit {});
-                let mut buffer = String::new();
-                let mut object_writer = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut buffer);
-                crate::protocol_serde::shape_test_union::ser_test_union(&mut object_writer, &test_union).unwrap();
-
-                // Verify the serialization produces expected JSON
-                assert!(buffer.contains("unitMember"));
+                let input = crate::test_input::TestOpInput::builder()
+                    .union(TestUnion::UnitMember(Unit {}))
+                    .build()
+                    .unwrap();
+                let serialized = ${format(operationGenerator)}(&input).unwrap();
+                let output = std::str::from_utf8(serialized.bytes().unwrap()).unwrap();
+                assert!(output.contains("unitMember"));
                 """,
             )
         }
 
-        // The test passes if the FIXED version compiles and works correctly
+        // The test passes if the generated code compiles without unused variable warnings
         project.compileAndTest()
     }
 }

codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/serialize/QuerySerializerGeneratorTest.kt

@@ -25,17 +25,17 @@ class QuerySerializerGeneratorTest {
     @Test
     fun `union with unit struct doesn't cause unused variable warning`() {
         // Regression test for https://github.com/smithy-lang/smithy-rs/issues/4308
-        //
-        // This test demonstrates the BEFORE/AFTER behavior for Query serialization
+        // This test ensures that Query serialization with unit structs compiles without unused variable warnings.
+        // Query serialization for unit structs generates empty blocks where the variable would be unused,
+        // so the fix uses '_inner' (with underscore prefix) to suppress the unused variable warning.
         val model =
             RecursiveShapeBoxer().transform(
                 OperationNormalizer.transform(
                     """
                     namespace test
 
                     union TestUnion {
-                        unitMember: Unit,
-                        dataMember: String
+                        unitMember: Unit
                     }
 
                     structure Unit {}
@@ -55,7 +55,6 @@ class QuerySerializerGeneratorTest {
         val codegenContext = testCodegenContext(model)
         val symbolProvider = codegenContext.symbolProvider
 
-        // Generate the Query serializer with our FIX applied
         val parserSerializer = AwsQuerySerializerGenerator(codegenContext)
         val operationGenerator = parserSerializer.operationInputSerializer(model.lookup("test#TestOp"))
 
@@ -69,29 +68,27 @@ class QuerySerializerGeneratorTest {
             UnionGenerator(model, symbolProvider, this, model.lookup("test#TestUnion")).render()
         }
 
-        // Test that demonstrates our fix works - generates correct variable names for unit structs
         project.lib {
             unitTest(
                 "query_union_serialization_fix_works",
                 """
                 use test_model::{TestUnion, Unit};
 
-                // Generate the FIXED serialization function (uses '_inner' for unit structs)
                 ${format(operationGenerator!!)};
 
-                // Test the union serialization with unit struct - this works with our fix
-                // BEFORE: would generate `UnitMember(inner)` but never use `inner` -> unused variable warning
-                // AFTER: generates `UnitMember(_inner)` for unit structs -> no warning
-                let test_union = TestUnion::UnitMember(Unit {});
-                let mut output = String::new();
-                let writer = ::aws_smithy_query::QueryValueWriter::new(&mut output, "test".into());
-                crate::protocol_serde::shape_test_union::ser_test_union(writer, &test_union).unwrap();
-
-                // The test passes if the code compiles without unused variable warnings
+                let input = crate::test_input::TestOpInput::builder()
+                    .union(TestUnion::UnitMember(Unit {}))
+                    .build()
+                    .unwrap();
+                let serialized = ${format(operationGenerator)}(&input).unwrap();
+                let output = std::str::from_utf8(serialized.bytes().unwrap()).unwrap();
+                // Query serialization for unit structs produces empty output
+                assert!(output.is_empty() || !output.contains("error"));
                 """,
             )
         }
 
+        // The test passes if the generated code compiles without unused variable warnings
         project.compileAndTest()
     }
 }