chore: add expectation utilities for parsing

This adds a few methods to assert that a type is the expected type
before returning it. This is useful to make sure that we aren't
blindly returning json that is invalid.

Author: JordonPhillips

packages/smithy-client/src/parse-utils.spec.ts

@@ -1,4 +1,5 @@
 import { parseBoolean } from "./parse-utils";
+import { expectBoolean, expectNumber, expectString } from "./parse-utils";
 
 describe("parseBoolean", () => {
   it('Returns true for "true"', () => {
@@ -45,3 +46,68 @@ describe("parseBoolean", () => {
     expect(() => parseBoolean({} as any)).toThrowError();
   });
 });
+
+describe("expectBoolean", () => {
+  it("accepts booleans", () => {
+    expect(expectBoolean(true)).toEqual(true);
+    expect(expectBoolean(false)).toEqual(false);
+  });
+
+  it("rejects non-booleans", () => {
+    expect(() => expectBoolean("true")).toThrowError();
+    expect(() => expectBoolean("false")).toThrowError();
+    expect(() => expectBoolean(0)).toThrowError();
+    expect(() => expectBoolean(1)).toThrowError();
+    expect(() => expectBoolean(1.1)).toThrowError();
+    expect(() => expectBoolean(Infinity)).toThrowError();
+    expect(() => expectBoolean(-Infinity)).toThrowError();
+    expect(() => expectBoolean(NaN)).toThrowError();
+    expect(() => expectBoolean({})).toThrowError();
+    expect(() => expectBoolean([])).toThrowError();
+    expect(() => expectBoolean(null)).toThrowError();
+    expect(() => expectBoolean(undefined)).toThrowError();
+  });
+});
+
+describe("expectNumber", () => {
+  it("accepts numbers", () => {
+    expect(expectNumber(1)).toEqual(1);
+    expect(expectNumber(1.1)).toEqual(1.1);
+    expect(expectNumber(Infinity)).toEqual(Infinity);
+    expect(expectNumber(-Infinity)).toEqual(-Infinity);
+    expect(expectNumber(NaN)).toEqual(NaN);
+  });
+
+  it("rejects non-numbers", () => {
+    expect(() => expectNumber("1")).toThrowError();
+    expect(() => expectNumber("1.1")).toThrowError();
+    expect(() => expectNumber("Infinity")).toThrowError();
+    expect(() => expectNumber("-Infinity")).toThrowError();
+    expect(() => expectNumber("NaN")).toThrowError();
+    expect(() => expectNumber(true)).toThrowError();
+    expect(() => expectNumber(false)).toThrowError();
+    expect(() => expectNumber([])).toThrowError();
+    expect(() => expectNumber({})).toThrowError();
+    expect(() => expectNumber(null)).toThrowError();
+    expect(() => expectNumber(undefined)).toThrowError();
+  });
+});
+
+describe("expectString", () => {
+  it("accepts strings", () => {
+    expect(expectString("foo")).toEqual("foo");
+  });
+
+  it("rejects non-strings", () => {
+    expect(() => expectString(1)).toThrowError();
+    expect(() => expectString(NaN)).toThrowError();
+    expect(() => expectString(Infinity)).toThrowError();
+    expect(() => expectString(-Infinity)).toThrowError();
+    expect(() => expectString(true)).toThrowError();
+    expect(() => expectString(false)).toThrowError();
+    expect(() => expectString([])).toThrowError();
+    expect(() => expectString({})).toThrowError();
+    expect(() => expectString(null)).toThrowError();
+    expect(() => expectString(undefined)).toThrowError();
+  });
+});

packages/smithy-client/src/parse-utils.ts

@@ -13,4 +13,43 @@ export const parseBoolean = (value: string): boolean => {
     default:
       throw new Error(`Unable to parse boolean value "${value}"`);
   }
+};
+
+/*
+ * Asserts a value is a boolean and returns it.
+ *
+ * @param value A value that is expected to be a boolean.
+ * @returns The value if it is a boolean, otherwise an error is thrown.
+ */
+export function expectBoolean(value: any): boolean {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  throw new TypeError(`Expected boolean, got ${typeof value}`);
+}
+
+/**
+ * Asserts a value is a number and returns it.
+ *
+ * @param value A value that is expected to be a number.
+ * @returns The value if it is a number, otherwise an error is thrown.
+ */
+export function expectNumber(value: any): number {
+  if (typeof value === "number") {
+    return value;
+  }
+  throw new TypeError(`Expected number, got ${typeof value}`);
+}
+
+/**
+ * Asserts a value is a string and returns it.
+ *
+ * @param value A value that is expected to be a string.
+ * @returns The value if it is a string, otherwise an error is thrown.
+ */
+export function expectString(value: any): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new TypeError(`Expected string, got ${typeof value}`);
 }