Fix test API usage and add clear problem documentation

- Fix JsonObjectWriter and QueryValueWriter API calls
- Remove unused TestInput imports
- Add comments explaining what each fix addresses

Author: vcjana

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

@@ -370,13 +370,19 @@ 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
         val model = RecursiveShapeBoxer().transform(OperationNormalizer.transform(unionWithUnitStructModel))
 
         val codegenContext = testCodegenContext(model)
         val symbolProvider = codegenContext.symbolProvider
         val project = TestWorkspace.testProject(symbolProvider)
 
-        // Generate the JSON serializer that will create the union serialization code
+        // Generate the JSON serializer with our FIX applied
         val jsonSerializer =
             JsonSerializerGenerator(
                 codegenContext,
@@ -393,23 +399,31 @@ class JsonSerializerGeneratorTest {
             UnionGenerator(model, symbolProvider, this, model.lookup("test#TestUnion")).render()
         }
 
-        // Generate the actual protocol_serde module with union serialization
+        // Test that demonstrates our fix works - generates correct variable names
         project.lib {
             unitTest(
-                "json_union_serialization",
+                "json_union_serialization_fix_works",
                 """
-                use test_model::{TestInput, TestUnion, Unit};
+                use test_model::{TestUnion, Unit};
 
-                // Generate the serialization function that contains union match arms with (inner)
+                // Generate the FIXED serialization function (uses 'inner' consistently)
                 ${format(operationGenerator!!)};
 
-                // Test that the code compiles - this validates our fix works
-                let _test_passed = true;
+                // 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"));
                 """,
             )
         }
 
-        // The test passes if the generated code compiles without unused variable warnings
+        // The test passes if the FIXED version compiles and works correctly
         project.compileAndTest()
     }
 }

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

@@ -25,6 +25,8 @@ 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
         val model =
             RecursiveShapeBoxer().transform(
                 OperationNormalizer.transform(
@@ -52,6 +54,8 @@ 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"))
 
@@ -65,16 +69,24 @@ class QuerySerializerGeneratorTest {
             UnionGenerator(model, symbolProvider, this, model.lookup("test#TestUnion")).render()
         }
 
-        // Generate the serialization module that will contain the union serialization code
+        // Test that demonstrates our fix works - generates correct variable names for unit structs
         project.lib {
             unitTest(
-                "query_union_serialization",
+                "query_union_serialization_fix_works",
                 """
-                use test_model::{TestInput, TestUnion, Unit};
+                use test_model::{TestUnion, Unit};
 
-                // This will generate the serialization code that should not have unused variable warnings
+                // 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
                 """,
             )