Merge pull request #285 from JordonPhillips/ssdk-response-tests

Add ssdk response tests

Author: JordonPhillips

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

@@ -177,6 +177,12 @@ private void generateServerOperationTests(OperationShape operation, OperationInd
                     onlyIfProtocolMatches(testCase, () -> generateServerRequestTest(operation, testCase));
                 }
             });
+            // 2. Generate test cases for each response.
+            operation.getTrait(HttpResponseTestsTrait.class).ifPresent(trait -> {
+                for (HttpResponseTestCase testCase : trait.getTestCasesFor(AppliesTo.SERVER)) {
+                    onlyIfProtocolMatches(testCase, () -> generateServerResponseTest(operation, testCase));
+                }
+            });
         }
     }
 
@@ -242,7 +248,7 @@ private void generateClientRequestTest(OperationShape operation, HttpRequestTest
                        + "  }\n"
                        + "  const r = err.request;")
                     .indent()
-                    .call(() -> writeRequestAssertions(operation, testCase))
+                    .call(() -> writeHttpRequestAssertions(testCase))
                     .dedent()
                     .write("}");
         });
@@ -349,16 +355,22 @@ private ObjectNode buildQueryBag(HttpRequestTestCase testCase) {
     }
 
     // Ensure that the serialized request matches the expected request.
-    private void writeRequestAssertions(OperationShape operation, HttpRequestTestCase testCase) {
+    private void writeHttpRequestAssertions(HttpRequestTestCase testCase) {
         writer.write("expect(r.method).toBe($S);", testCase.getMethod());
         writer.write("expect(r.path).toBe($S);", testCase.getUri());
 
-        writeRequestHeaderAssertions(testCase);
-        writeRequestQueryAssertions(testCase);
-        writeRequestBodyAssertions(operation, testCase);
+        writeHttpHeaderAssertions(testCase);
+        writeHttpQueryAssertions(testCase);
+        writeHttpBodyAssertions(testCase);
+    }
+
+    private void writeHttpResponseAssertions(HttpResponseTestCase testCase) {
+        writer.write("expect(r.statusCode).toBe($L);", testCase.getCode());
+        writeHttpHeaderAssertions(testCase);
+        writeHttpBodyAssertions(testCase);
     }
 
-    private void writeRequestQueryAssertions(HttpRequestTestCase testCase) {
+    private void writeHttpQueryAssertions(HttpRequestTestCase testCase) {
         testCase.getRequireQueryParams().forEach(requiredQueryParam ->
                 writer.write("expect(r.query[$S]).toBeDefined();", requiredQueryParam));
         writer.write("");
@@ -380,7 +392,7 @@ private void writeRequestQueryAssertions(HttpRequestTestCase testCase) {
         writer.write("");
     }
 
-    private void writeRequestHeaderAssertions(HttpRequestTestCase testCase) {
+    private void writeHttpHeaderAssertions(HttpMessageTestCase testCase) {
         testCase.getRequireHeaders().forEach(requiredHeader -> {
             writer.write("expect(r.headers[$S]).toBeDefined();", requiredHeader.toLowerCase());
         });
@@ -398,7 +410,7 @@ private void writeRequestHeaderAssertions(HttpRequestTestCase testCase) {
         writer.write("");
     }
 
-    private void writeRequestBodyAssertions(OperationShape operation, HttpRequestTestCase testCase) {
+    private void writeHttpBodyAssertions(HttpMessageTestCase testCase) {
         testCase.getBody().ifPresent(body -> {
             // If we expect an empty body, expect it to be falsy.
             if (body.isEmpty()) {
@@ -413,6 +425,17 @@ private void writeRequestBodyAssertions(OperationShape operation, HttpRequestTes
             String mediaType = testCase.getBodyMediaType().orElse("UNKNOWN");
             String comparatorInvoke = registerBodyComparatorStub(mediaType);
 
+            // If this is a request case then we know we're generating a client test,
+            // because a request case for servers would be comparing parsed objects. We
+            // need to know which is which here to be able to grab the utf8Encoder from
+            // the right place.
+            if (testCase instanceof HttpRequestTestCase) {
+                writer.write("const utf8Encoder = client.config.utf8Encoder;");
+            } else {
+                writer.addImport("toUtf8", "__utf8Encoder", "@aws-sdk/util-utf8-node");
+                writer.write("const utf8Encoder = __utf8Encoder;");
+            }
+
             // Handle escaping strings with quotes inside them.
             writer.write("const bodyString = `$L`;", body.replace("\"", "\\\""));
             writer.write("const unequalParts: any = $L;", comparatorInvoke);
@@ -436,19 +459,83 @@ private String registerBodyComparatorStub(String mediaType) {
                 additionalStubs.add("protocol-test-xml-stub.ts");
                 return "compareEquivalentXmlBodies(bodyString, r.body.toString())";
             case "application/octet-stream":
+                writer.addImport("Encoder", "__Encoder", "@aws-sdk/types");
                 additionalStubs.add("protocol-test-octet-stream-stub.ts");
-                return "compareEquivalentOctetStreamBodies(client.config, bodyString, r.body)";
+                return "compareEquivalentOctetStreamBodies(utf8Encoder, bodyString, r.body)";
             case "text/plain":
                 additionalStubs.add("protocol-test-text-stub.ts");
                 return "compareEquivalentTextBodies(bodyString, r.body)";
             default:
                 LOGGER.warning("Unable to compare bodies with unknown media type `" + mediaType
                         + "`, defaulting to direct comparison.");
+                writer.addImport("Encoder", "__Encoder", "@aws-sdk/types");
                 additionalStubs.add("protocol-test-unknown-type-stub.ts");
-                return "compareEquivalentUnknownTypeBodies(client.config, bodyString, r.body)";
+                return "compareEquivalentUnknownTypeBodies(utf8Encoder, bodyString, r.body)";
         }
     }
 
+    public void generateServerResponseTest(OperationShape operation, HttpResponseTestCase testCase) {
+        Symbol serviceSymbol = serverSymbolProvider.toSymbol(service);
+        Symbol operationSymbol = serverSymbolProvider.toSymbol(operation);
+        Symbol handlerSymbol = serviceSymbol.expectProperty("handler", Symbol.class);
+        Symbol serviceOperationsSymbol = serviceSymbol.expectProperty("operations", Symbol.class);
+        testCase.getDocumentation().ifPresent(writer::writeDocs);
+        String testName = testCase.getId() + ":ServerResponse";
+        writer.openBlock("it($S, async () => {", "});\n", testName, () -> {
+            Symbol outputType = operationSymbol.expectProperty("outputType", Symbol.class);
+            writer.openBlock("class TestService implements Partial<$T> {", "}", serviceSymbol, () -> {
+                writer.openBlock("$L(input: any, request: HttpRequest): $T {", "}",
+                        operationSymbol.getName(), outputType, () -> {
+                    Optional<ShapeId> outputOptional = operation.getOutput();
+                    if (outputOptional.isPresent()) {
+                        StructureShape outputShape = model.expectShape(outputOptional.get(), StructureShape.class);
+                        writer.writeInline("let response = ");
+                        testCase.getParams().accept(new CommandInputNodeVisitor(outputShape, true));
+                        writer.write("return { ...response, '$$metadata': {} };");
+                    } else {
+                        writer.write("return { '$$metadata': {} };");
+                    }
+                });
+            });
+
+            writer.write("const service: any = new TestService()");
+
+            // There's a lot of setup here, including creating our own mux, serializers list, and ultimately
+            // our own service handler. This is largely in service of avoiding having to go through the
+            // request deserializer
+            writer.addImport("httpbinding", null, "@aws-smithy/server-common");
+            writer.openBlock("const testMux = new httpbinding.HttpBindingMux<$S, keyof $T>([", "]);",
+                service.getId().getName(), serviceSymbol, () -> {
+                    writer.openBlock("new httpbinding.UriSpec<$S, $S>('POST', [], [], {", "}),",
+                        service.getId().getName(), operation.getId().getName(), () -> {
+                            writer.write("service: $S,", service.getId().getName());
+                            writer.write("operation: $S,", operation.getId().getName());
+                        });
+                });
+
+            writer.write("const request = new HttpRequest({method: 'POST', hostname: 'example.com'});");
+
+            String serializerName = ProtocolGenerator.getGenericSerFunctionName(operationSymbol) + "Response";
+            writer.addImport(serializerName, serializerName,
+                    "./protocols/" + ProtocolGenerator.getSanitizedName(protocolGenerator.getName()));
+
+            writer.addImport("OperationSerializer", "__OperationSerializer", "@aws-smithy/server-common");
+            writer.openBlock("const serFn: (op: $1T) => __OperationSerializer<$2T, $1T> = (op) => {", "};",
+                    serviceOperationsSymbol, serviceSymbol, () -> {
+                writer.openBlock("return {", "};", () -> {
+                    writer.write("serialize: $L,", serializerName);
+                    writer.openBlock("deserialize: (output: any, context: any): Promise<any> => {", "},", () -> {
+                        writer.write("return Promise.resolve({});");
+                    });
+                });
+            });
+
+            writer.write("const handler = new $T(service, testMux, serFn);", handlerSymbol);
+            writer.write("let r = await handler.handle(request)").write("");
+            writeHttpResponseAssertions(testCase);
+        });
+    }
+
     private void generateResponseTest(OperationShape operation, HttpResponseTestCase testCase) {
         testCase.getDocumentation().ifPresent(writer::writeDocs);
         String testName = testCase.getId() + ":Response";
@@ -657,10 +744,16 @@ private void writeParamAssertions(
     private final class CommandInputNodeVisitor implements NodeVisitor<Void> {
         private final StructureShape inputShape;
         private Shape workingShape;
+        private boolean appendSemicolon;
 
         private CommandInputNodeVisitor(StructureShape inputShape) {
+            this(inputShape, false);
+        }
+
+        private CommandInputNodeVisitor(StructureShape inputShape, boolean appendSemicolon) {
             this.inputShape = inputShape;
             this.workingShape = inputShape;
+            this.appendSemicolon = appendSemicolon;
         }
 
         @Override
@@ -716,10 +809,25 @@ public Void objectNode(ObjectNode node) {
 
             // Both objects and maps can use a majority of the same logic.
             // Use "as any" to have TS complain less about undefined entries.
-            writer.openBlock("{", "} as any,\n", () -> {
+            String suffix = "} as any";
+
+            // When generating a server response test, we need the top level structure to have a semicolon
+            // rather than a comma.
+            if (appendSemicolon) {
+                suffix += ";";
+                appendSemicolon = false;
+            } else {
+                suffix += ",\n";
+            }
+
+            writer.openBlock("{", suffix, () -> {
                 Shape wrapperShape = this.workingShape;
                 node.getMembers().forEach((keyNode, valueNode) -> {
-                    writer.writeInline("$L: ", keyNode.getValue());
+                    if (keyNode.getValue().matches("[^\\w]+")) {
+                        writer.writeInline("$L: ", keyNode.getValue());
+                    } else {
+                        writer.writeInline("$S: ", keyNode.getValue());
+                    }
 
                     // Grab the correct member related to the node member we have.
                     MemberShape memberShape;

smithy-typescript-codegen/src/main/resources/software/amazon/smithy/typescript/codegen/base-package.json

@@ -33,7 +33,7 @@
     "downlevel-dts": "0.7.0",
     "jest": "^26.1.0",
     "rimraf": "^3.0.0",
-    "typedoc": "^0.19.2",
+    "typedoc": "^0.20.0",
     "typescript": "~4.1.2"
   },
   "engines": {

smithy-typescript-codegen/src/main/resources/software/amazon/smithy/typescript/codegen/protocol-test-octet-stream-stub.ts

@@ -3,12 +3,12 @@
  * discrepancies between the components.
  */
 const compareEquivalentOctetStreamBodies = (
-  config: any,
+  utf8Encoder: __Encoder,
   expectedBody: string,
   generatedBody: Uint8Array
 ): Object => {
   const expectedParts = {Value: expectedBody};
-  const generatedParts = {Value: config.utf8Encoder(generatedBody)};
+  const generatedParts = {Value: utf8Encoder(generatedBody)};
 
   return compareParts(expectedParts, generatedParts);
 }

smithy-typescript-codegen/src/main/resources/software/amazon/smithy/typescript/codegen/protocol-test-unknown-type-stub.ts

@@ -3,13 +3,13 @@
  * discrepancies between the components.
  */
 const compareEquivalentUnknownTypeBodies = (
-  config: any,
+  utf8Encoder: __Encoder,
   expectedBody: string,
   generatedBody: string | Uint8Array
 ): Object => {
   const expectedParts = {Value: expectedBody};
   const generatedParts = {
-    Value: generatedBody instanceof Uint8Array ? config.utf8Encoder(generatedBody) : generatedBody
+    Value: generatedBody instanceof Uint8Array ? utf8Encoder(generatedBody) : generatedBody
   };
 
   return compareParts(expectedParts, generatedParts);