chore(protocol-tests): update protocol tests to unblock ci

Author: AllanZhengYP

protocol_tests/aws-query/tests/functional/awsquery.spec.ts

@@ -607,7 +607,6 @@ it("QueryComplexError:Error:GreetingWithErrors", async () => {
          <Error>
             <Type>Sender</Type>
             <Code>ComplexError</Code>
-            <Message>Hi</Message>
             <TopLevel>Top level</TopLevel>
             <Nested>
                 <Foo>bar</Foo>

protocol_tests/aws-restjson/RestJsonProtocol.ts

@@ -44,6 +44,11 @@ import {
   GreetingWithErrorsCommandInput,
   GreetingWithErrorsCommandOutput,
 } from "./commands/GreetingWithErrorsCommand";
+import {
+  HostWithPathOperationCommand,
+  HostWithPathOperationCommandInput,
+  HostWithPathOperationCommandOutput,
+} from "./commands/HostWithPathOperationCommand";
 import {
   HttpEnumPayloadCommand,
   HttpEnumPayloadCommandInput,
@@ -501,6 +506,35 @@ export class RestJsonProtocol extends RestJsonProtocolClient {
     }
   }
 
+  public hostWithPathOperation(
+    args: HostWithPathOperationCommandInput,
+    options?: __HttpHandlerOptions
+  ): Promise<HostWithPathOperationCommandOutput>;
+  public hostWithPathOperation(
+    args: HostWithPathOperationCommandInput,
+    cb: (err: any, data?: HostWithPathOperationCommandOutput) => void
+  ): void;
+  public hostWithPathOperation(
+    args: HostWithPathOperationCommandInput,
+    options: __HttpHandlerOptions,
+    cb: (err: any, data?: HostWithPathOperationCommandOutput) => void
+  ): void;
+  public hostWithPathOperation(
+    args: HostWithPathOperationCommandInput,
+    optionsOrCb?: __HttpHandlerOptions | ((err: any, data?: HostWithPathOperationCommandOutput) => void),
+    cb?: (err: any, data?: HostWithPathOperationCommandOutput) => void
+  ): Promise<HostWithPathOperationCommandOutput> | void {
+    const command = new HostWithPathOperationCommand(args);
+    if (typeof optionsOrCb === "function") {
+      this.send(command, optionsOrCb);
+    } else if (typeof cb === "function") {
+      if (typeof optionsOrCb !== "object") throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+      this.send(command, optionsOrCb || {}, cb);
+    } else {
+      return this.send(command, optionsOrCb);
+    }
+  }
+
   public httpEnumPayload(
     args: HttpEnumPayloadCommandInput,
     options?: __HttpHandlerOptions

protocol_tests/aws-restjson/RestJsonProtocolClient.ts

@@ -25,6 +25,10 @@ import {
   EndpointWithHostLabelOperationCommandOutput,
 } from "./commands/EndpointWithHostLabelOperationCommand";
 import { GreetingWithErrorsCommandInput, GreetingWithErrorsCommandOutput } from "./commands/GreetingWithErrorsCommand";
+import {
+  HostWithPathOperationCommandInput,
+  HostWithPathOperationCommandOutput,
+} from "./commands/HostWithPathOperationCommand";
 import { HttpEnumPayloadCommandInput, HttpEnumPayloadCommandOutput } from "./commands/HttpEnumPayloadCommand";
 import { HttpPayloadTraitsCommandInput, HttpPayloadTraitsCommandOutput } from "./commands/HttpPayloadTraitsCommand";
 import {
@@ -168,6 +172,7 @@ export type ServiceInputTypes =
   | EndpointOperationCommandInput
   | EndpointWithHostLabelOperationCommandInput
   | GreetingWithErrorsCommandInput
+  | HostWithPathOperationCommandInput
   | HttpEnumPayloadCommandInput
   | HttpPayloadTraitsCommandInput
   | HttpPayloadTraitsWithMediaTypeCommandInput
@@ -214,6 +219,7 @@ export type ServiceOutputTypes =
   | EndpointOperationCommandOutput
   | EndpointWithHostLabelOperationCommandOutput
   | GreetingWithErrorsCommandOutput
+  | HostWithPathOperationCommandOutput
   | HttpEnumPayloadCommandOutput
   | HttpPayloadTraitsCommandOutput
   | HttpPayloadTraitsWithMediaTypeCommandOutput

protocol_tests/aws-restjson/commands/HostWithPathOperationCommand.ts

@@ -0,0 +1,76 @@
+import { RestJsonProtocolClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RestJsonProtocolClient";
+import {
+  deserializeAws_restJson1HostWithPathOperationCommand,
+  serializeAws_restJson1HostWithPathOperationCommand,
+} from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  MiddlewareStack,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+export interface HostWithPathOperationCommandInput {}
+export interface HostWithPathOperationCommandOutput extends __MetadataBearer {}
+
+export class HostWithPathOperationCommand extends $Command<
+  HostWithPathOperationCommandInput,
+  HostWithPathOperationCommandOutput,
+  RestJsonProtocolClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: HostWithPathOperationCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: RestJsonProtocolClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<HostWithPathOperationCommandInput, HostWithPathOperationCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "RestJsonProtocolClient";
+    const commandName = "HostWithPathOperationCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: (input: any) => input,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: HostWithPathOperationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1HostWithPathOperationCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<HostWithPathOperationCommandOutput> {
+    return deserializeAws_restJson1HostWithPathOperationCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

protocol_tests/aws-restjson/index.ts

@@ -9,6 +9,7 @@ export * from "./commands/EmptyInputAndEmptyOutputCommand";
 export * from "./commands/EndpointOperationCommand";
 export * from "./commands/EndpointWithHostLabelOperationCommand";
 export * from "./commands/GreetingWithErrorsCommand";
+export * from "./commands/HostWithPathOperationCommand";
 export * from "./commands/HttpEnumPayloadCommand";
 export * from "./commands/HttpPayloadTraitsCommand";
 export * from "./commands/HttpPayloadTraitsWithMediaTypeCommand";

protocol_tests/aws-restjson/tests/functional/restjson1.spec.ts

@@ -8,6 +8,7 @@ import { EmptyInputAndEmptyOutputCommand } from "../../commands/EmptyInputAndEmp
 import { EndpointOperationCommand } from "../../commands/EndpointOperationCommand";
 import { EndpointWithHostLabelOperationCommand } from "../../commands/EndpointWithHostLabelOperationCommand";
 import { GreetingWithErrorsCommand } from "../../commands/GreetingWithErrorsCommand";
+import { HostWithPathOperationCommand } from "../../commands/HostWithPathOperationCommand";
 import { HttpEnumPayloadCommand } from "../../commands/HttpEnumPayloadCommand";
 import { HttpPayloadTraitsCommand } from "../../commands/HttpPayloadTraitsCommand";
 import { HttpPayloadTraitsWithMediaTypeCommand } from "../../commands/HttpPayloadTraitsWithMediaTypeCommand";
@@ -1862,6 +1863,34 @@ it("RestJsonInvalidGreetingError:Error:GreetingWithErrors", async () => {
   fail("Expected an exception to be thrown from response");
 });
 
+/**
+ * Custom endpoints supplied by users can have paths
+ */
+it("RestJsonHostWithPath:Request", async () => {
+  const client = new RestJsonProtocolClient({
+    ...clientParams,
+    endpoint: "https://example.com/custom",
+    requestHandler: new RequestSerializationTestHandler(),
+  });
+
+  const command = new HostWithPathOperationCommand({});
+  try {
+    await client.send(command);
+    fail("Expected an EXPECTED_REQUEST_SERIALIZATION_ERROR to be thrown");
+    return;
+  } catch (err) {
+    if (!(err instanceof EXPECTED_REQUEST_SERIALIZATION_ERROR)) {
+      fail(err);
+      return;
+    }
+    const r = err.request;
+    expect(r.method).toBe("GET");
+    expect(r.path).toBe("/custom/HostWithPathOperation");
+
+    expect(r.body).toBeFalsy();
+  }
+});
+
 it("EnumPayloadRequest:Request", async () => {
   const client = new RestJsonProtocolClient({
     ...clientParams,