Dump S3 model in integ, fix build (?), fix test

Author: mtdowling

smithy-aws-endpoints/build.gradle.kts

@@ -26,7 +26,7 @@ dependencies {
 }
 
 // Integration test source set for tests that require the S3 model
-// These tests require JDK 21+ due to the S3 model dependency
+// These tests require JDK 17+ due to the S3 model dependency
 sourceSets {
     create("it") {
         compileClasspath += sourceSets["main"].output + sourceSets["test"].output
@@ -38,15 +38,15 @@ configurations["itImplementation"].extendsFrom(configurations["testImplementatio
 configurations["itRuntimeOnly"].extendsFrom(configurations["testRuntimeOnly"])
 configurations["itImplementation"].extendsFrom(s3Model)
 
-// Configure IT source set to compile with JDK 21
+// Configure IT source set to compile with JDK 17
 tasks.named<JavaCompile>("compileItJava") {
     javaCompiler.set(
         javaToolchains.compilerFor {
-            languageVersion.set(JavaLanguageVersion.of(21))
+            languageVersion.set(JavaLanguageVersion.of(17))
         },
     )
-    sourceCompatibility = "21"
-    targetCompatibility = "21"
+    sourceCompatibility = "17"
+    targetCompatibility = "17"
 }
 
 val integrationTest by tasks.registering(Test::class) {
@@ -57,10 +57,18 @@ val integrationTest by tasks.registering(Test::class) {
     dependsOn(tasks.jar)
     shouldRunAfter(tasks.test)
 
-    // Run with JDK 21
+    // Pass build directory to tests
+    systemProperty(
+        "buildDir",
+        layout.buildDirectory
+            .get()
+            .asFile.absolutePath,
+    )
+
+    // Run with JDK 17
     javaLauncher.set(
         javaToolchains.launcherFor {
-            languageVersion.set(JavaLanguageVersion.of(21))
+            languageVersion.set(JavaLanguageVersion.of(17))
         },
     )
 }

smithy-aws-endpoints/src/it/java/software/amazon/smithy/rulesengine/aws/language/functions/S3BddTest.java

@@ -6,10 +6,16 @@
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.List;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.node.Node;
+import software.amazon.smithy.model.shapes.ModelSerializer;
 import software.amazon.smithy.model.shapes.ServiceShape;
 import software.amazon.smithy.model.shapes.ShapeId;
 import software.amazon.smithy.rulesengine.aws.s3.S3TreeRewriter;
@@ -25,18 +31,20 @@
 
 class S3BddTest {
     private static final ShapeId S3_SERVICE_ID = ShapeId.from("com.amazonaws.s3#AmazonS3");
+    private static Model model;
+    private static ServiceShape s3Service;
     private static EndpointRuleSet originalRules;
     private static EndpointRuleSet rules;
     private static List<EndpointTestCase> testCases;
 
     @BeforeAll
     static void loadS3Model() {
-        Model model = Model.assembler()
+        model = Model.assembler()
                 .discoverModels()
                 .assemble()
                 .unwrap();
 
-        ServiceShape s3Service = model.expectShape(S3_SERVICE_ID, ServiceShape.class);
+        s3Service = model.expectShape(S3_SERVICE_ID, ServiceShape.class);
         originalRules = s3Service.expectTrait(EndpointRuleSetTrait.class).getEndpointRuleSet();
         rules = S3TreeRewriter.transform(originalRules);
         testCases = s3Service.expectTrait(EndpointTestsTrait.class).getTestCases();
@@ -83,5 +91,42 @@ void compileToBddWithOptimizations() {
         }
 
         System.out.println(sb);
+
+        // Write model with BDD trait to build directory
+        writeModelWithBddTrait(optimizedTrait);
+    }
+
+    private void writeModelWithBddTrait(EndpointBddTrait bddTrait) {
+        String buildDir = System.getProperty("buildDir");
+        if (buildDir == null) {
+            System.out.println("buildDir system property not set, skipping model output");
+            return;
+        }
+
+        // Create updated service with BDD trait instead of RuleSet trait
+        ServiceShape updatedService = s3Service.toBuilder()
+                .removeTrait(EndpointRuleSetTrait.ID)
+                .addTrait(bddTrait)
+                .build();
+
+        // Build updated model
+        Model updatedModel = model.toBuilder()
+                .removeShape(s3Service.getId())
+                .addShape(updatedService)
+                .build();
+
+        // Serialize to JSON
+        ModelSerializer serializer = ModelSerializer.builder().build();
+        String json = Node.prettyPrintJson(serializer.serialize(updatedModel));
+
+        // Write to build directory
+        Path outputPath = Paths.get(buildDir, "s3-bdd-model.json");
+        try {
+            Files.createDirectories(outputPath.getParent());
+            Files.writeString(outputPath, json);
+            System.out.println("Wrote S3 BDD model to: " + outputPath);
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to write S3 BDD model", e);
+        }
     }
 }

smithy-rules-engine/src/test/java/software/amazon/smithy/rulesengine/logic/cfg/CfgBuilderTest.java

@@ -202,15 +202,21 @@ void createConditionReferenceHandlesBooleanEqualsCanonicalizations() {
     }
 
     @Test
-    void createConditionReferenceDoesNotCanonicalizeWithoutDefault() {
-        // Test that booleanEquals(region, false) is not canonicalized (no default)
+    void createConditionReferenceCanonicalizesEvenWithoutDefault() {
+        // booleanEquals(X, false) -> booleanEquals(X, true) with negation is a valid
+        // algebraic transformation regardless of whether the parameter has a default
         Expression ref = Expression.getReference(Identifier.of("region"));
         Condition cond = Condition.builder().fn(BooleanEquals.ofExpressions(ref, false)).build();
 
         ConditionReference condRef = builder.createConditionReference(cond);
 
-        assertFalse(condRef.isNegated());
-        assertEquals(cond.getFunction(), condRef.getCondition().getFunction());
+        // Should be canonicalized to booleanEquals(region, true) with negation
+        assertTrue(condRef.isNegated());
+        assertInstanceOf(BooleanEquals.class, condRef.getCondition().getFunction());
+
+        BooleanEquals fn = (BooleanEquals) condRef.getCondition().getFunction();
+        assertEquals(ref, fn.getArguments().get(0));
+        assertEquals(Literal.booleanLiteral(true), fn.getArguments().get(1));
     }
 
     @Test