@typespec/http-specs 0.1.0-alpha.0

package/specs/README.md

@@ -0,0 +1,3 @@
+# HTTP Test scenarios
+
+**_Pending_**

package/specs/authentication/api-key/main.tsp

@@ -0,0 +1,40 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@scenarioService("/authentication/api-key")
+@doc("Illustrates clients generated with ApiKey authentication.")
+@useAuth(ApiKeyAuth<ApiKeyLocation.header, "x-ms-api-key">)
+namespace Authentication.ApiKey;
+
+@scenario
+@scenarioDoc("Expects header 'x-ms-api-key': 'valid-key'")
+@doc("Check whether client is authenticated")
+@get
+@route("/valid")
+op valid(): NoContentResponse;
+
+@scenario
+@scenarioDoc("""
+  Expect error code 403 and error body:
+    ```json
+    {
+      "error": {
+        "code": "InvalidApiKey",
+        "message": "API key is invalid"
+      }
+    }
+    ```
+  """)
+@doc("Check whether client is authenticated.")
+@get
+@route("/invalid")
+op invalid(): NoContentResponse | InvalidAuth;
+
+@error
+model InvalidAuth {
+  @statusCode _: 403;
+  error: string;
+}

package/specs/authentication/api-key/mockapi.ts

@@ -0,0 +1,35 @@
+import { json, passOnCode, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Authentication_ApiKey_invalid = passOnCode(403, {
+  uri: `/authentication/api-key/invalid`,
+  method: `get`,
+  request: {
+    headers: {
+      "x-ms-api-key": "valid-key",
+    },
+    status: 403,
+  },
+  response: {
+    status: 403,
+    body: json({
+      error: "invalid-api-key",
+    }),
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Authentication_ApiKey_valid = passOnSuccess({
+  uri: `/authentication/api-key/valid`,
+  method: `get`,
+  request: {
+    headers: {
+      "x-ms-api-key": "valid-key",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});

package/specs/authentication/http/custom/main.tsp

@@ -0,0 +1,40 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using TypeSpec.Http;
+using Spector;
+
+@scenarioService("/authentication/http/custom")
+@doc("Illustrates clients generated with generic HTTP auth.")
+@useAuth({
+  type: AuthType.http,
+  scheme: "SharedAccessKey",
+})
+namespace Authentication.Http.Custom;
+
+@scenario
+@scenarioDoc("Expects header 'Authorization': 'SharedAccessKey valid-key'")
+@doc("Check whether client is authenticated")
+@get
+@route("/valid")
+op valid(): NoContentResponse;
+
+@scenario
+@scenarioDoc("""
+  Expect error code 403 and error body:
+    ```json
+    {
+      "error": "invalid-api-key"
+    }
+    ```
+  """)
+@doc("Check whether client is authenticated.")
+@get
+@route("/invalid")
+op invalid(): NoContentResponse | InvalidAuth;
+
+@error
+model InvalidAuth {
+  @statusCode _: 403;
+  error: string;
+}

package/specs/authentication/http/custom/mockapi.ts

@@ -0,0 +1,35 @@
+import { json, passOnCode, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Authentication_Http_Custom_valid = passOnSuccess({
+  uri: `/authentication/http/custom/valid`,
+  method: "get",
+  request: {
+    headers: {
+      authorization: "SharedAccessKey valid-key",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Authentication_Http_Custom_invalid = passOnCode(403, {
+  uri: `/authentication/http/custom/invalid`,
+  method: "get",
+  request: {
+    headers: {
+      authorization: "SharedAccessKey invalid-key",
+    },
+    status: 403,
+  },
+  response: {
+    status: 403,
+    body: json({
+      error: "invalid-api-key",
+    }),
+  },
+  kind: "MockApiDefinition",
+});

package/specs/authentication/oauth2/main.tsp

@@ -0,0 +1,45 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@scenarioService("/authentication/oauth2")
+@doc("Illustrates clients generated with OAuth2 authentication.")
+@useAuth(OAuth2Auth<[MyFlow]>)
+namespace Authentication.OAuth2;
+
+model MyFlow {
+  type: OAuth2FlowType.implicit;
+  authorizationUrl: "https://login.microsoftonline.com/common/oauth2/authorize";
+  scopes: ["https://security.microsoft.com/.default"];
+}
+
+@scenario
+@scenarioDoc("Expects header 'authorization': 'Bearer https://security.microsoft.com/.default'")
+@doc("Check whether client is authenticated")
+@get
+@route("/valid")
+op valid(): NoContentResponse;
+
+@scenario
+@scenarioDoc("""
+  Expect error code 400 and error body:
+    ```json
+    {
+      "message": "Expected Bearer x but got Bearer y",
+      "expected": "Bearer x",
+      "actual": "Bearer y",
+    }
+    ```
+  """)
+@doc("Check whether client is authenticated. Will return an invalid bearer error.")
+@get
+@route("/invalid")
+op invalid(): NoContentResponse | InvalidAuth;
+
+@error
+model InvalidAuth {
+  @statusCode _: 403;
+  error: string;
+}

package/specs/authentication/oauth2/mockapi.ts

@@ -0,0 +1,32 @@
+import { json, passOnCode, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Authentication_OAuth2_valid = passOnSuccess({
+  uri: `/authentication/oauth2/valid`,
+  method: "get",
+  request: {
+    headers: {
+      authorization: "Bearer https://security.microsoft.com/.default",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Authentication_OAuth2_invalid = passOnCode(403, {
+  uri: `/authentication/oauth2/invalid`,
+  method: "get",
+  request: {
+    status: 403,
+  },
+  response: {
+    status: 403,
+    body: json({
+      error: "invalid-grant",
+    }),
+  },
+  kind: "MockApiDefinition",
+});

package/specs/authentication/union/main.tsp

@@ -0,0 +1,30 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@scenarioService("/authentication/union")
+@doc("Illustrates clients generated with ApiKey and OAuth2 authentication.")
+@useAuth(ApiKeyAuth<ApiKeyLocation.header, "x-ms-api-key"> | OAuth2Auth<[MyFlow]>)
+namespace Authentication.Union;
+
+model MyFlow {
+  type: OAuth2FlowType.implicit;
+  authorizationUrl: "https://login.microsoftonline.com/common/oauth2/authorize";
+  scopes: ["https://security.microsoft.com/.default"];
+}
+
+@scenario
+@scenarioDoc("Expects header 'x-ms-api-key': 'valid-key'")
+@doc("Check whether client is authenticated")
+@get
+@route("/validkey")
+op validKey(): NoContentResponse;
+
+@scenario
+@scenarioDoc("Expects header 'authorization': 'Bearer https://security.microsoft.com/.default'")
+@doc("Check whether client is authenticated")
+@get
+@route("/validtoken")
+op validToken(): NoContentResponse;

package/specs/authentication/union/mockapi.ts

@@ -0,0 +1,31 @@
+import { passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Authentication_Union_validKey = passOnSuccess({
+  uri: `/authentication/union/validkey`,
+  method: "get",
+  request: {
+    headers: {
+      "x-ms-api-key": "valid-key",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Authentication_Union_validToken = passOnSuccess({
+  uri: `/authentication/union/validtoken`,
+  method: "get",
+  request: {
+    headers: {
+      authorization: "Bearer https://security.microsoft.com/.default",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});

package/specs/encode/bytes/main.tsp

@@ -0,0 +1,363 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Test for encode decorator on bytes.")
+@scenarioService("/encode/bytes")
+namespace Encode.Bytes;
+
+@encode(BytesKnownEncoding.base64url)
+scalar base64urlBytes extends bytes;
+
+@route("/query")
+namespace Query {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test default encode (base64) for bytes query parameter.
+    Expected query parameter:
+    value=dGVzdA== (base64 encode of test)
+    """)
+  op default(
+    @query
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64")
+  @scenario
+  @scenarioDoc("""
+    Test base64 encode for bytes query parameter.
+    Expected query parameter:
+    value=dGVzdA== (base64 encode of test)
+    """)
+  op base64(
+    @query
+    @encode(BytesKnownEncoding.base64)
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64url")
+  @scenario
+  @scenarioDoc("""
+    Test base64url encode for bytes query parameter.
+    Expected query parameter:
+    value=dGVzdA (base64url encode of test)
+    """)
+  op base64url(
+    @query
+    @encode(BytesKnownEncoding.base64url)
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64url-array")
+  @scenario
+  @scenarioDoc("""
+    Test base64url encode for bytes array query parameter.
+    Expected query parameter:
+    value=dGVzdA, dGVzdA
+    """)
+  op base64urlArray(
+    #suppress "deprecated" "Deprecated in next release"
+    @query({
+      format: "csv",
+    })
+    value: base64urlBytes[],
+  ): NoContentResponse;
+}
+
+model DefaultBytesProperty {
+  value: bytes;
+}
+
+model Base64BytesProperty {
+  @encode(BytesKnownEncoding.base64)
+  value: bytes;
+}
+
+model Base64urlBytesProperty {
+  @encode(BytesKnownEncoding.base64url)
+  value: bytes;
+}
+
+model Base64urlArrayBytesProperty {
+  value: base64urlBytes[];
+}
+
+@route("/property")
+namespace Property {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains bytes properties with default encode (base64).
+    Expected request body:
+    ```json
+    {
+      "value": "dGVzdA==" // base64 encode of test
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": "dGVzdA=="
+    }
+    ```
+    """)
+  @post
+  op default(@body body: DefaultBytesProperty): DefaultBytesProperty;
+
+  @route("/base64")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains bytes properties with base64 encode.
+    Expected request body:
+    ```json
+    {
+      "value": "dGVzdA==" // base64 encode of test
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": "dGVzdA=="
+    }
+    ```
+    """)
+  @post
+  op base64(@body body: Base64BytesProperty): Base64BytesProperty;
+
+  @route("/base64url")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains bytes properties with base64url encode.
+    Expected request body:
+    ```json
+    {
+      "value": "dGVzdA" // base64url encode of test
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": "dGVzdA"
+    }
+    ```
+    """)
+  @post
+  op base64url(@body body: Base64urlBytesProperty): Base64urlBytesProperty;
+
+  @route("/base64url-array")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains bytes array properties with base64url encode.
+    Expected request body:
+    ```json
+    {
+      "value": ["dGVzdA", "dGVzdA"]
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": ["dGVzdA", "dGVzdA"]
+    }
+    ```
+    """)
+  @post
+  op base64urlArray(@body body: Base64urlArrayBytesProperty): Base64urlArrayBytesProperty;
+}
+
+@route("/header")
+namespace Header {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test default encode (base64) for bytes header.
+    Expected header:
+    value=dGVzdA== (base64 encode of test)
+    """)
+  op default(
+    @header
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64")
+  @scenario
+  @scenarioDoc("""
+    Test base64 encode for bytes header.
+    Expected header:
+    value=dGVzdA== (base64 encode of test)
+    """)
+  op base64(
+    @header
+    @encode(BytesKnownEncoding.base64)
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64url")
+  @scenario
+  @scenarioDoc("""
+    Test base64url encode for bytes header.
+    Expected header:
+    value=dGVzdA (base64url encode of test)
+    """)
+  op base64url(
+    @header
+    @encode(BytesKnownEncoding.base64url)
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64url-array")
+  @scenario
+  @scenarioDoc("""
+    Test base64url encode for bytes array header.
+    Expected header:
+    value=dGVzdA,dGVzdA
+    """)
+  op base64urlArray(
+    @header({
+      format: "csv",
+    })
+    value: base64urlBytes[],
+  ): NoContentResponse;
+}
+
+@route("/body/request")
+namespace RequestBody {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test default encode (base64) for bytes in a json body.
+    Expected body:
+    "dGVzdA==" (base64 encode of test, in JSON string)
+    """)
+  @post
+  op default(
+    @body
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/octet-stream")
+  @scenario
+  @scenarioDoc("""
+    When content type is application/octet-stream and body is `bytes` the payload is a binary file.
+    File should match packages/cadl-ranch-specs/assets/image.png
+    """)
+  @post
+  op octetStream(
+    @header
+    contentType: "application/octet-stream",
+
+    @body
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/custom-content-type")
+  @scenario
+  @scenarioDoc("""
+    When content type is a custom type(image/png here) and body is `bytes` the payload is a binary file.
+    File should match packages/cadl-ranch-specs/assets/image.png
+    """)
+  @post
+  op customContentType(
+    @header
+    contentType: "image/png",
+
+    @body
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64")
+  @scenario
+  @scenarioDoc("""
+    Test base64 encode for bytes body.
+    Expected body:
+    "dGVzdA==" (base64 encode of test, in JSON string)
+    """)
+  @post
+  op base64(
+    @body
+    @encode(BytesKnownEncoding.base64)
+    value: bytes,
+  ): NoContentResponse;
+
+  @route("/base64url")
+  @scenario
+  @scenarioDoc("""
+    Test base64url encode for bytes body.
+    Expected body:
+    "dGVzdA" (base64url encode of test, in JSON string)
+    """)
+  @post
+  op base64url(
+    @body
+    @encode(BytesKnownEncoding.base64url)
+    value: bytes,
+  ): NoContentResponse;
+}
+
+@route("/body/response")
+namespace ResponseBody {
+  @route("/default")
+  @scenario
+  @scenarioDoc("""
+    Test default encode (base64) for bytes in a json body.
+    Expected body:
+    "dGVzdA==" (base64 encode of test, in JSON string)
+    """)
+  op default(): {
+    @body
+    value: bytes;
+  };
+
+  @route("/octet-stream")
+  @scenario
+  @scenarioDoc("""
+    When content type is application/octet-stream and body is `bytes` the payload is a binary file.
+    File should match packages/cadl-ranch-specs/assets/image.png
+    """)
+  op octetStream(): {
+    @header
+    contentType: "application/octet-stream";
+
+    @body
+    value: bytes;
+  };
+
+  @route("/custom-content-type")
+  @scenario
+  @scenarioDoc("""
+    When content type is a custom type(image/png here) and body is `bytes` the payload is a binary file.
+    File should match packages/cadl-ranch-specs/assets/image.png
+    """)
+  op customContentType(): {
+    @header
+    contentType: "image/png";
+
+    @body
+    value: bytes;
+  };
+
+  @route("/base64")
+  @scenario
+  @scenarioDoc("""
+    Test base64 encode for bytes body.
+    Expected body:
+    "dGVzdA==" (base64 encode of test, in JSON string)
+    """)
+  op base64(): {
+    @body
+    @encode(BytesKnownEncoding.base64)
+    value: bytes;
+  };
+
+  @route("/base64url")
+  @scenario
+  @scenarioDoc("""
+    Test base64url encode for bytes body.
+    Expected body:
+    "dGVzdA" (base64url encode of test, in JSON string)
+    """)
+  op base64url(): base64urlBytes;
+}