Add test for list and map of enums

Author: JordonPhillips

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/StructuredMemberWriter.java

@@ -313,32 +313,41 @@ private void writeShapeValidator(TypeScriptWriter writer, Shape shape, Collectio
                     "@aws-smithy/server-common");
             MemberShape collectionMemberShape = ((CollectionShape) shape).getMember();
             Shape collectionMemberTargetShape = model.expectShape(collectionMemberShape.getTarget());
-            writer.openBlock("new __CompositeCollectionValidator<$T>(", "),",
-                    symbolProvider.toSymbol(collectionMemberTargetShape),
-                    () -> {
-                        writeCompositeValidator(writer, shape, constraintTraits);
-                        writeShapeValidator(writer,
-                                            collectionMemberTargetShape,
-                                            getConstraintTraits(collectionMemberShape));
-                    });
+            if (collectionMemberTargetShape.hasTrait(EnumTrait.class)) {
+                // While there is a concrete type for enums, any string can be provided, and so we need
+                // to allow for that. The underlying validator will handle ensuring the values are correct.
+                writer.writeInline("new __CompositeCollectionValidator<string>");
+            } else {
+                writer.writeInline("new __CompositeCollectionValidator<$T>",
+                        symbolProvider.toSymbol(collectionMemberTargetShape));
+            }
+            writer.openBlock("(", "),", () -> {
+                writeCompositeValidator(writer, shape, constraintTraits);
+                writeShapeValidator(writer, collectionMemberTargetShape, getConstraintTraits(collectionMemberShape));
+            });
         } else if (shape.isMapShape()) {
             writer.addImport("CompositeMapValidator",
                     "__CompositeMapValidator",
                     "@aws-smithy/server-common");
             MapShape mapShape = (MapShape) shape;
             final MemberShape keyShape = mapShape.getKey();
             final MemberShape valueShape = mapShape.getValue();
-            writer.openBlock("new __CompositeMapValidator<$T>(", "),",
-                    symbolProvider.toSymbol(model.expectShape(valueShape.getTarget())),
-                    () -> {
-                        writeCompositeValidator(writer, mapShape, constraintTraits);
-                        writeShapeValidator(writer,
-                                            model.expectShape(keyShape.getTarget()),
-                                            getConstraintTraits(keyShape));
-                        writeShapeValidator(writer,
-                                            model.expectShape(valueShape.getTarget()),
-                                            getConstraintTraits(valueShape));
-                    });
+            if (valueShape.hasTrait(EnumTrait.class)) {
+                // While there is a concrete type for enums, any string can be provided, and so we need
+                // to allow for that. The underlying validator will handle ensuring the values are correct.
+                writer.writeInline("new __CompositeMapValidator<string>");
+            } else {
+                writer.writeInline("new __CompositeMapValidator<$T>", symbolProvider.toSymbol(valueShape));
+            }
+            writer.openBlock("(", "),", () -> {
+                writeCompositeValidator(writer, mapShape, constraintTraits);
+                writeShapeValidator(writer,
+                                    model.expectShape(keyShape.getTarget()),
+                                    getConstraintTraits(keyShape));
+                writeShapeValidator(writer,
+                                    model.expectShape(valueShape.getTarget()),
+                                    getConstraintTraits(valueShape));
+            });
         } else if (shape instanceof SimpleShape) {
             writeCompositeValidator(writer, shape, constraintTraits);
         } else {

smithy-typescript-integ-tests/codegen/.gitignore

@@ -0,0 +1 @@
+/.gradle

smithy-typescript-integ-tests/codegen/build.gradle

@@ -23,16 +23,16 @@ buildscript {
     dependencies {
         classpath 'software.amazon.smithy:smithy-typescript-codegen:0.3.0'
         classpath 'software.amazon.smithy:smithy-aws-typescript-codegen:0.3.0'
-        classpath "software.amazon.smithy:smithy-model:1.5.1"
+        classpath "software.amazon.smithy:smithy-model:1.7.2"
     }
 }
 
 plugins {
-    id 'software.amazon.smithy' version '0.5.2'
+    id 'software.amazon.smithy' version '0.5.3'
 }
 
 dependencies {
-    implementation "software.amazon.smithy:smithy-aws-traits:1.5.1"
+    implementation "software.amazon.smithy:smithy-aws-traits:1.7.2"
 }
 
 repositories {

smithy-typescript-integ-tests/codegen/model/validation.smithy

@@ -16,6 +16,8 @@ operation Test {
 
 structure TestInput {
     enum: Enum,
+    enumList: ListOfEnums,
+    enumMap: MapOfEnums,
     lengthTests: LengthTests,
     nestedTests: NestedUnionOne
 }
@@ -60,6 +62,15 @@ union NestedUnionThree {
 @enum([{"value" : "valueA"}, {"value": "valueB"}])
 string Enum
 
+list ListOfEnums {
+    member: Enum
+}
+
+map MapOfEnums {
+    key: String,
+    value: Enum,
+}
+
 @length(min: 2, max: 7)
 string MinMaxLengthString
 

smithy-typescript-integ-tests/src/enum.spec.ts

@@ -0,0 +1,69 @@
+/*
+ *  Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License").
+ *  You may not use this file except in compliance with the License.
+ *  A copy of the License is located at
+ *
+ *   http://aws.amazon.com/apache2.0
+ *
+ *  or in the "license" file accompanying this file. This file is distributed
+ *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ *  express or implied. See the License for the specific language governing
+ *  permissions and limitations under the License.
+ */
+
+import { TestInput, Enum } from "@aws-smithy/typescript-integ-test-types";
+
+describe("enum constraints", () => {
+  const validEnum: Enum = "valueA";
+  const invalidEnum: string = "invalidEnum";
+  const expectedFailureBase = {
+    constraintType: "enum",
+    constraintValues: ["valueA", "valueB"],
+    failureValue: invalidEnum,
+  };
+  it("handles bare enums", () => {
+    expect(TestInput.validate({ enum: validEnum })).toEqual([]);
+    expect(TestInput.validate({ enum: invalidEnum })).toEqual([
+      {
+        memberName: "enum",
+        ...expectedFailureBase,
+      },
+    ]);
+  });
+  it("handles enum lists", () => {
+    expect(TestInput.validate({ enumList: [validEnum] })).toEqual([]);
+    expect(TestInput.validate({ enumList: [invalidEnum] })).toEqual([
+      {
+        memberName: "enumList",
+        ...expectedFailureBase,
+      },
+    ]);
+    expect(TestInput.validate({ enumList: [validEnum, invalidEnum] })).toEqual([
+      {
+        memberName: "enumList",
+        ...expectedFailureBase,
+      },
+    ]);
+  });
+  it("handles enum maps", () => {
+    expect(TestInput.validate({ enumMap: { valid: validEnum } })).toEqual([]);
+    expect(TestInput.validate({ enumMap: { invalid: invalidEnum } })).toEqual([
+      {
+        memberName: "enumMap",
+        ...expectedFailureBase,
+      },
+    ]);
+    expect(
+      TestInput.validate({
+        enumMap: { valid: validEnum, invalid: invalidEnum },
+      })
+    ).toEqual([
+      {
+        memberName: "enumMap",
+        ...expectedFailureBase,
+      },
+    ]);
+  });
+});