From 1147cb56ba4415cd0217cbbad5ca03bb5a8e523a Mon Sep 17 00:00:00 2001
From: Brandon Millman <brandon.millman@gmail.com>
Date: Mon, 13 Nov 2017 16:25:21 -0500
Subject: Add assert package to the monorepo

---
 packages/assert/src/globals.d.ts |  5 +++
 packages/assert/src/index.ts     | 84 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 89 insertions(+)
 create mode 100644 packages/assert/src/globals.d.ts
 create mode 100644 packages/assert/src/index.ts

(limited to 'packages/assert/src')

diff --git a/packages/assert/src/globals.d.ts b/packages/assert/src/globals.d.ts
new file mode 100644
index 000000000..cc47f3113
--- /dev/null
+++ b/packages/assert/src/globals.d.ts
@@ -0,0 +1,5 @@
+declare module 'dirty-chai';
+
+declare module 'ethereum-address' {
+    const isAddress: (arg: any) => boolean;
+}
diff --git a/packages/assert/src/index.ts b/packages/assert/src/index.ts
new file mode 100644
index 000000000..b391a8bbb
--- /dev/null
+++ b/packages/assert/src/index.ts
@@ -0,0 +1,84 @@
+import BigNumber from 'bignumber.js';
+import * as ethereum_address from 'ethereum-address';
+import * as _ from 'lodash';
+import * as validUrl from 'valid-url';
+
+import {SchemaValidator, Schema} from '0x-json-schemas';
+
+const HEX_REGEX = /^0x[0-9A-F]*$/i;
+
+export const assert = {
+    isBigNumber(variableName: string, value: BigNumber): void {
+        const isBigNumber = _.isObject(value) && (value as any).isBigNumber;
+        this.assert(isBigNumber, this.typeAssertionMessage(variableName, 'BigNumber', value));
+    },
+    isUndefined(value: any, variableName?: string): void {
+        this.assert(_.isUndefined(value), this.typeAssertionMessage(variableName, 'undefined', value));
+    },
+    isString(variableName: string, value: string): void {
+        this.assert(_.isString(value), this.typeAssertionMessage(variableName, 'string', value));
+    },
+    isFunction(variableName: string, value: any): void {
+        this.assert(_.isFunction(value), this.typeAssertionMessage(variableName, 'function', value));
+    },
+    isHexString(variableName: string, value: string): void {
+        this.assert(_.isString(value) && HEX_REGEX.test(value),
+            this.typeAssertionMessage(variableName, 'HexString', value));
+    },
+    isETHAddressHex(variableName: string, value: string): void {
+        this.assert(ethereum_address.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
+        this.assert(
+            ethereum_address.isAddress(value) && value.toLowerCase() === value,
+            `Checksummed addresses are not supported. Convert ${variableName} to lower case before passing`,
+        );
+    },
+    doesBelongToStringEnum(variableName: string, value: string,
+                           stringEnum: any /* There is no base type for every string enum */): void {
+        const doesBelongToStringEnum = !_.isUndefined(stringEnum[value]);
+        const enumValues = _.keys(stringEnum);
+        const enumValuesAsStrings = _.map(enumValues, enumValue => `'${enumValue}'`);
+        const enumValuesAsString = enumValuesAsStrings.join(', ');
+        assert.assert(
+            doesBelongToStringEnum,
+            `Expected ${variableName} to be one of: ${enumValuesAsString}, encountered: ${value}`,
+        );
+    },
+    hasAtMostOneUniqueValue(value: any[], errMsg: string): void {
+        this.assert(_.uniq(value).length <= 1, errMsg);
+    },
+    isNumber(variableName: string, value: number): void {
+        this.assert(_.isFinite(value), this.typeAssertionMessage(variableName, 'number', value));
+    },
+    isBoolean(variableName: string, value: boolean): void {
+        this.assert(_.isBoolean(value), this.typeAssertionMessage(variableName, 'boolean', value));
+    },
+    isWeb3Provider(variableName: string, value: any): void {
+        const isWeb3Provider = _.isFunction((value as any).send) || _.isFunction((value as any).sendAsync);
+        this.assert(isWeb3Provider, this.typeAssertionMessage(variableName, 'Web3.Provider', value));
+    },
+    doesConformToSchema(variableName: string, value: any, schema: Schema): void {
+        const schemaValidator = new SchemaValidator();
+        const validationResult = schemaValidator.validate(value, schema);
+        const hasValidationErrors = validationResult.errors.length > 0;
+        const msg = `Expected ${variableName} to conform to schema ${schema.id}
+Encountered: ${JSON.stringify(value, null, '\t')}
+Validation errors: ${validationResult.errors.join(', ')}`;
+        this.assert(!hasValidationErrors, msg);
+    },
+    isHttpUrl(variableName: string, value: any): void {
+        const isValidUrl = validUrl.isWebUri(value);
+        this.assert(isValidUrl, this.typeAssertionMessage(variableName, 'http url', value));
+    },
+    isUri(variableName: string, value: any): void {
+        const isValidUri = validUrl.isUri(value);
+        this.assert(isValidUri, this.typeAssertionMessage(variableName, 'uri', value));
+    },
+    assert(condition: boolean, message: string): void {
+        if (!condition) {
+            throw new Error(message);
+        }
+    },
+    typeAssertionMessage(variableName: string, type: string, value: any): string {
+        return `Expected ${variableName} to be of type ${type}, encountered: ${value}`;
+    },
+};
-- 
cgit v1.2.3