Add an assertTypes utility (#3578)

* Add assertTypes util

* Add assertTypes function

Author: sam-gc

packages-exp/auth-exp/src/core/util/assert.test.ts

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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 { expect } from 'chai';
+
+import { FirebaseError } from '@firebase/util';
+
+import { assertTypes, opt } from './assert';
+
+class Parent {}
+class Child extends Parent {}
+
+describe('assertTypes', () => {
+  context('basic types', () => {
+    it('works when no arguments are present', () => {
+      assertTypes([]);
+    });
+
+    it('works using a basic argument', () => {
+      assertTypes(['foobar'], 'string');
+      expect(() => assertTypes([46], 'string')).to.throw(
+        FirebaseError,
+        'auth/argument-error'
+      );
+      expect(() => assertTypes([], 'string')).to.throw(
+        FirebaseError,
+        'auth/argument-error'
+      );
+    });
+
+    it('works using optional types with missing value', () => {
+      assertTypes([], opt('string'));
+      assertTypes([35], 'number', opt('string'));
+    });
+
+    it('works using optional types with value set', () => {
+      assertTypes(['foo'], opt('string'));
+      expect(() => assertTypes([46], opt('string'))).to.throw(
+        FirebaseError,
+        'auth/argument-error'
+      );
+    });
+
+    it('works with multiple types', () => {
+      assertTypes(['foo', null], 'string', 'null');
+    });
+
+    it("works with or'd types", () => {
+      assertTypes(['foo'], 'string|number');
+      assertTypes([47], 'string|number');
+    });
+
+    it('works with the arguments field from a function', () => {
+      function test(_name: string, _height?: unknown): void {
+        assertTypes(arguments, 'string', opt('number'));
+      }
+
+      test('foo');
+      test('foo', 11);
+      expect(() => test('foo', 'bar')).to.throw(
+        FirebaseError,
+        'auth/argument-error'
+      );
+    });
+
+    it('works with class types', () => {
+      assertTypes([new Child()], Child);
+      assertTypes([new Child()], Parent);
+      assertTypes([new Parent()], opt(Parent));
+      expect(() => assertTypes([new Parent()], Child)).to.throw(
+        FirebaseError,
+        'auth/argument-error'
+      );
+    });
+  });
+
+  context('record types', () => {
+    it('works one level deep', () => {
+      assertTypes([{ foo: 'bar', clazz: new Child(), test: null }], {
+        foo: 'string',
+        clazz: Parent,
+        test: 'null',
+        missing: opt('string')
+      });
+
+      expect(() =>
+        assertTypes(
+          [{ foo: 'bar', clazz: new Child(), test: null, missing: 46 }],
+          {
+            foo: 'string',
+            clazz: Parent,
+            test: 'null',
+            missing: opt('string')
+          }
+        )
+      ).to.throw(FirebaseError, 'auth/argument-error');
+    });
+
+    it('works nested', () => {
+      assertTypes(
+        [{ name: 'foo', metadata: { height: 11, extraInfo: null } }],
+        {
+          name: 'string',
+          metadata: {
+            height: opt('number'),
+            extraInfo: 'string|null'
+          }
+        }
+      );
+
+      expect(() =>
+        assertTypes(
+          [{ name: 'foo', metadata: { height: 11, extraInfo: null } }],
+          {
+            name: 'string',
+            metadata: {
+              height: opt('number'),
+              extraInfo: 'string'
+            }
+          }
+        )
+      ).to.throw(FirebaseError, 'auth/argument-error');
+    });
+
+    it('works with triply nested', () => {
+      assertTypes([{ a: { b: { c: 'test' } } }], { a: { b: { c: 'string' } } });
+
+      expect(() =>
+        assertTypes([{ a: { b: { c: 'test' } } }], {
+          a: { b: { c: 'number' } }
+        })
+      ).to.throw(FirebaseError, 'auth/argument-error');
+    });
+  });
+});

packages-exp/auth-exp/src/core/util/assert.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { AuthErrorCode, AUTH_ERROR_FACTORY } from '../errors';
+import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 import { _logError } from './log';
 
 /**
@@ -44,6 +44,92 @@ export function assert(
   }
 }
 
+type TypeExpectation = Function | string | MapType;
+
+interface MapType extends Record<string, TypeExpectation | Optional> {}
+
+class Optional {
+  constructor(readonly type: TypeExpectation) {}
+}
+
+export function opt(type: TypeExpectation): Optional {
+  return new Optional(type);
+}
+
+/**
+ * Asserts the runtime types of arguments. The 'expected' field can be one of
+ * a class, a string (representing a "typeof" call), or a record map of name
+ * to type. Furthermore, the opt() function can be used to mark a field as
+ * optional. For example:
+ *
+ * function foo(auth: Auth, profile: {displayName?: string}, update = false) {
+ *   assertTypes(arguments, [AuthImpl, {displayName: opt('string')}, opt('boolean')]);
+ * }
+ *
+ * opt() can be used for any type:
+ * function foo(auth?: Auth) {
+ *   assertTypes(arguments, [opt(AuthImpl)]);
+ * }
+ *
+ * The string types can be or'd together, and you can use "null" as well (note
+ * that typeof null === 'object'; this is an edge case). For example:
+ *
+ * function foo(profile: {displayName?: string | null}) {
+ *   assertTypes(arguments, [{displayName: opt('string|null')}]);
+ * }
+ *
+ * @param args
+ * @param expected
+ */
+export function assertTypes(
+  args: Omit<IArguments, 'callee'>,
+  ...expected: Array<TypeExpectation | Optional>
+): void {
+  if (args.length > expected.length) {
+    fail('TODO', AuthErrorCode.ARGUMENT_ERROR);
+  }
+
+  for (let i = 0; i < expected.length; i++) {
+    let expect = expected[i];
+    const arg = args[i];
+
+    if (expect instanceof Optional) {
+      // If the arg is undefined, then it matches "optional" and we can move to
+      // the next arg
+      if (typeof arg === 'undefined') {
+        continue;
+      }
+      expect = expect.type;
+    }
+
+    if (typeof expect === 'string') {
+      // Handle the edge case for null because typeof null === 'object'
+      if (expect.includes('null') && arg === null) {
+        continue;
+      }
+
+      const required = expect.split('|');
+      assert(
+        required.includes(typeof arg),
+        'TODO',
+        AuthErrorCode.ARGUMENT_ERROR
+      );
+    } else if (typeof expect === 'object') {
+      // Recursively check record arguments
+      const record = arg as Record<string, unknown>;
+      const map = expect as MapType;
+      const keys = Object.keys(expect);
+
+      assertTypes(
+        keys.map(k => record[k]),
+        ...keys.map(k => map[k])
+      );
+    } else {
+      assert(arg instanceof expect, 'app', AuthErrorCode.ARGUMENT_ERROR);
+    }
+  }
+}
+
 /**
  * Unconditionally fails, throwing an internal error with the given message.
  *