Add assert package to the monorepo

9 files changed, 515 insertions, 1 deletions

diff --git a/packages/0x.js/package.json b/packages/0x.js/package.json
index 6e30df612..02ae87cd5 100644
--- a/packages/0x.js/package.json
+++ b/packages/0x.js/package.json
@@ -87,7 +87,7 @@
   },
   "dependencies": {
     "0x-json-schemas": "^0.6.1",
-    "bignumber.js": "^4.1.0",
+    "bignumber.js": "~4.1.0",
     "compare-versions": "^3.0.1",
     "es6-promisify": "^5.0.0",
     "ethereumjs-abi": "^0.6.4",
diff --git a/packages/assert/README.md b/packages/assert/README.md
new file mode 100644
index 000000000..4e72d5bcb
--- /dev/null
+++ b/packages/assert/README.md
@@ -0,0 +1,5 @@
+<img src="https://github.com/0xProject/branding/blob/master/0x_Black_CMYK.png" width="200px" >
+
+---
+
+Standard type and schema assertions to be used across all 0x projects and packages
diff --git a/packages/assert/circle.yml b/packages/assert/circle.yml
new file mode 100644
index 000000000..32b9e7315
--- /dev/null
+++ b/packages/assert/circle.yml
@@ -0,0 +1,14 @@
+machine:
+  node:
+    version: 6.5.0
+
+dependencies:
+  override:
+    - yarn
+  cache_directories:
+    - ~/.cache/yarn
+
+test:
+  override:
+    - yarn test
+    - yarn lint
diff --git a/packages/assert/package.json b/packages/assert/package.json
new file mode 100644
index 000000000..43ecf5371
--- /dev/null
+++ b/packages/assert/package.json
@@ -0,0 +1,45 @@
+{
+  "name": "0x-assert",
+  "version": "0.0.3",
+  "description": "Provides a standard way of performing type and schema validation across 0x projects",
+  "main": "lib/src/index.js",
+  "types": "lib/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "shx rm -rf _bundles lib test_temp",
+    "lint": "tslint src/**/*.ts test/**/*.ts",
+    "run_mocha": "mocha lib/test/**/*_test.js",
+    "prepublishOnly": "run-p build",
+    "test": "run-s clean build run_mocha"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xProject/assert.git"
+  },
+  "bugs": {
+    "url": "https://github.com/0xProject/assert/issues"
+  },
+  "homepage": "https://github.com/0xProject/assert#readme",
+  "devDependencies": {
+    "@types/lodash": "^4.14.78",
+    "@types/mocha": "^2.2.42",
+    "@types/valid-url": "^1.0.2",
+    "chai": "^4.0.1",
+    "chai-typescript-typings": "^0.0.1",
+    "dirty-chai": "^2.0.1",
+    "mocha": "^4.0.1",
+    "npm-run-all": "^4.1.1",
+    "shx": "^0.2.2",
+    "tslint": "~5.5.0",
+    "tslint-config-0xproject": "^0.0.2",
+    "typescript": "^2.4.2"
+  },
+  "dependencies": {
+    "0x-json-schemas": "^0.6.5",
+    "bignumber.js": "~4.1.0",
+    "ethereum-address": "^0.0.4",
+    "lodash": "^4.17.4",
+    "valid-url": "^1.0.9"
+  }
+}
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}`;
+    },
+};
diff --git a/packages/assert/test/assert_test.ts b/packages/assert/test/assert_test.ts
new file mode 100644
index 000000000..0e35f7f50
--- /dev/null
+++ b/packages/assert/test/assert_test.ts
@@ -0,0 +1,338 @@
+import 'mocha';
+import * as dirtyChai from 'dirty-chai';
+import * as chai from 'chai';
+import {BigNumber} from 'bignumber.js';
+import {schemas} from '0x-json-schemas';
+import {assert} from '../src/index';
+
+chai.config.includeStack = true;
+chai.use(dirtyChai);
+const expect = chai.expect;
+
+describe('Assertions', () => {
+    const variableName = 'variable';
+    describe('#isBigNumber', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                new BigNumber(23),
+                new BigNumber('45'),
+            ];
+            validInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                'test',
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+            ];
+            invalidInputs.forEach(input => expect(assert.isBigNumber.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isUndefined', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                undefined,
+            ];
+            validInputs.forEach(input => expect(assert.isUndefined.bind(assert, input, variableName)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                'test',
+                42,
+                false,
+                { random: 'test' },
+            ];
+            invalidInputs.forEach(input => expect(assert.isUndefined.bind(assert, input, variableName)).to.throw());
+        });
+    });
+    describe('#isString', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'hello',
+                'goodbye',
+            ];
+            validInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isString.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isFunction', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                BigNumber,
+                assert.isString.bind(this),
+            ];
+            validInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isFunction.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isHexString', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x61a3ed31B43c8780e905a260a35faefEc527be7516aa11c0256729b5b351bc33',
+                '0x40349190569279751135161d22529dc25add4f6069af05be04cacbda2ace2254',
+            ];
+            validInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                '0x61a3ed31B43c8780e905a260a35faYfEc527be7516aa11c0256729b5b351bc33',
+            ];
+            invalidInputs.forEach(input => expect(assert.isHexString.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isETHAddressHex', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x0000000000000000000000000000000000000000',
+                '0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x12459c951127e0c374ff9105dda097662a027093',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                '0x6FFFd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x6FFFd0ae3f7d88c9b4925323f54c6e4',
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isETHAddressHex.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#doesBelongToStringEnum', () => {
+        enum TestEnums {
+            Test1 = 'Test1',
+            Test2 = 'Test2',
+        }
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                TestEnums.Test1,
+                TestEnums.Test2,
+            ];
+            validInputs.forEach(input =>
+                expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.doesBelongToStringEnum.bind(assert, variableName, input, TestEnums)).to.throw(),
+            );
+        });
+    });
+    describe('#hasAtMostOneUniqueValue', () => {
+        const errorMsg = 'more than one unique value';
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                ['hello'],
+                ['goodbye', 'goodbye', 'goodbye'],
+            ];
+            validInputs.forEach(input =>
+                expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                ['hello', 'goodbye'],
+                ['goodbye', 42, false, false],
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.hasAtMostOneUniqueValue.bind(assert, input, errorMsg)).to.throw(),
+            );
+        });
+    });
+    describe('#isNumber', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                42,
+                0.00,
+                21e+42,
+            ];
+            validInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                false,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isNumber.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isBoolean', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                true,
+                false,
+            ];
+            validInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.not.throw());
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input => expect(assert.isBoolean.bind(assert, variableName, input)).to.throw());
+        });
+    });
+    describe('#isWeb3Provider', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                { send: () => 45 },
+                { sendAsync: () => 45 },
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isWeb3Provider.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#doesConformToSchema', () => {
+        const schema = schemas.addressSchema;
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                '0x6fffd0ae3f7d88c9b4925323f54c6e4b2918c5fd',
+                '0x12459c951127e0c374ff9105dda097662a027093',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.doesConformToSchema.bind(assert, variableName, input, schema)).to.throw(),
+            );
+        });
+    });
+    describe('#isHttpUrl', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'http://www.google.com',
+                'https://api.example-relayer.net',
+                'https://api.radarrelay.com/0x/v0/',
+                'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isHttpUrl.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                'ws://www.api.example-relayer.net',
+                'www.google.com',
+                'api.example-relayer.net',
+                'user:password@api.example-relayer.net',
+                '//api.example-relayer.net',
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isHttpUrl.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#isUri', () => {
+        it('should not throw for valid input', () => {
+            const validInputs = [
+                'http://www.google.com',
+                'https://api.example-relayer.net',
+                'https://api.radarrelay.com/0x/v0/',
+                'https://zeroex.beta.radarrelay.com:8000/0x/v0/',
+                'ws://www.api.example-relayer.net',
+                'wss://www.api.example-relayer.net',
+                'user:password@api.example-relayer.net',
+            ];
+            validInputs.forEach(input =>
+                expect(assert.isUri.bind(assert, variableName, input)).to.not.throw(),
+            );
+        });
+        it('should throw for invalid input', () => {
+            const invalidInputs = [
+                42,
+                { random: 'test' },
+                undefined,
+                new BigNumber(45),
+                'www.google.com',
+                'api.example-relayer.net',
+                '//api.example-relayer.net',
+            ];
+            invalidInputs.forEach(input =>
+                expect(assert.isUri.bind(assert, variableName, input)).to.throw(),
+            );
+        });
+    });
+    describe('#assert', () => {
+        const assertMessage = 'assert not satisfied';
+        it('should not throw for valid input', () => {
+            expect(assert.assert.bind(assert, true, assertMessage)).to.not.throw();
+        });
+        it('should throw for invalid input', () => {
+            expect(assert.assert.bind(assert, false, assertMessage)).to.throw();
+        });
+    });
+    describe('#typeAssertionMessage', () => {
+        it('should render correct message', () => {
+            expect(assert.typeAssertionMessage('variable', 'string', 'number'))
+            .to.equal(`Expected variable to be of type string, encountered: number`);
+        });
+    });
+});
diff --git a/packages/assert/tsconfig.json b/packages/assert/tsconfig.json
new file mode 100644
index 000000000..bdb4e43a8
--- /dev/null
+++ b/packages/assert/tsconfig.json
@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "lib": [ "es2017", "dom"],
+    "outDir": "lib",
+    "sourceMap": true,
+    "declaration": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true
+  },
+  "include": [
+    "./src/**/*",
+    "./test/**/*",
+    "../../node_modules/chai-typescript-typings/index.d.ts",    
+    "../../node_modules/web3-typescript-typings/index.d.ts"
+  ]
+}
diff --git a/packages/assert/tslint.json b/packages/assert/tslint.json
new file mode 100644
index 000000000..5842a872a
--- /dev/null
+++ b/packages/assert/tslint.json
@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "tslint-config-0xproject"
+  ]
+}