aboutsummaryrefslogtreecommitdiffstats
path: root/packages/assert
diff options
context:
space:
mode:
Diffstat (limited to 'packages/assert')
-rw-r--r--packages/assert/package.json86
-rw-r--r--packages/assert/src/index.ts166
-rw-r--r--packages/assert/test/assert_test.ts478
-rw-r--r--packages/assert/tsconfig.json10
-rw-r--r--packages/assert/tslint.json2
5 files changed, 371 insertions, 371 deletions
diff --git a/packages/assert/package.json b/packages/assert/package.json
index a2d195728..0e10b3384 100644
--- a/packages/assert/package.json
+++ b/packages/assert/package.json
@@ -1,45 +1,45 @@
{
- "name": "@0xproject/assert",
- "version": "0.0.13",
- "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 --project . 'src/**/*.ts' 'test/**/*.ts'",
- "run_mocha": "mocha lib/test/**/*_test.js",
- "prepublishOnly": "run-p build",
- "test": "run-s clean build run_mocha",
- "test:circleci": "yarn test"
- },
- "license": "Apache-2.0",
- "repository": {
- "type": "git",
- "url": "https://github.com/0xProject/0x.js.git"
- },
- "bugs": {
- "url": "https://github.com/0xProject/0x.js/issues"
- },
- "homepage": "https://github.com/0xProject/0x.js/packages/assert/README.md",
- "devDependencies": {
- "@0xproject/tslint-config": "^0.4.4",
- "@types/lodash": "^4.14.86",
- "@types/mocha": "^2.2.42",
- "@types/valid-url": "^1.0.2",
- "chai": "^4.0.1",
- "chai-typescript-typings": "^0.0.2",
- "dirty-chai": "^2.0.1",
- "mocha": "^4.0.1",
- "npm-run-all": "^4.1.2",
- "shx": "^0.2.2",
- "tslint": "5.8.0",
- "typescript": "~2.6.1"
- },
- "dependencies": {
- "@0xproject/json-schemas": "^0.7.5",
- "@0xproject/utils": "^0.2.2",
- "lodash": "^4.17.4",
- "valid-url": "^1.0.9"
- }
+ "name": "@0xproject/assert",
+ "version": "0.0.13",
+ "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 --project . 'src/**/*.ts' 'test/**/*.ts'",
+ "run_mocha": "mocha lib/test/**/*_test.js",
+ "prepublishOnly": "run-p build",
+ "test": "run-s clean build run_mocha",
+ "test:circleci": "yarn test"
+ },
+ "license": "Apache-2.0",
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/0xProject/0x.js.git"
+ },
+ "bugs": {
+ "url": "https://github.com/0xProject/0x.js/issues"
+ },
+ "homepage": "https://github.com/0xProject/0x.js/packages/assert/README.md",
+ "devDependencies": {
+ "@0xproject/tslint-config": "^0.4.4",
+ "@types/lodash": "^4.14.86",
+ "@types/mocha": "^2.2.42",
+ "@types/valid-url": "^1.0.2",
+ "chai": "^4.0.1",
+ "chai-typescript-typings": "^0.0.2",
+ "dirty-chai": "^2.0.1",
+ "mocha": "^4.0.1",
+ "npm-run-all": "^4.1.2",
+ "shx": "^0.2.2",
+ "tslint": "5.8.0",
+ "typescript": "~2.6.1"
+ },
+ "dependencies": {
+ "@0xproject/json-schemas": "^0.7.5",
+ "@0xproject/utils": "^0.2.2",
+ "lodash": "^4.17.4",
+ "valid-url": "^1.0.9"
+ }
}
diff --git a/packages/assert/src/index.ts b/packages/assert/src/index.ts
index 7ad574ec7..0578bd303 100644
--- a/packages/assert/src/index.ts
+++ b/packages/assert/src/index.ts
@@ -6,89 +6,89 @@ import * as validUrl from 'valid-url';
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));
- },
- isValidBaseUnitAmount(variableName: string, value: BigNumber) {
- assert.isBigNumber(variableName, value);
- const isNegative = value.lessThan(0);
- this.assert(!isNegative, `${variableName} cannot be a negative number, found value: ${value.toNumber()}`);
- const hasDecimals = value.decimalPlaces() !== 0;
- this.assert(
- !hasDecimals,
- `${variableName} should be in baseUnits (no decimals), found value: ${value.toNumber()}`,
- );
- },
- 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(addressUtils.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
- this.assert(
- addressUtils.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.send) || _.isFunction(value.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}
+ isBigNumber(variableName: string, value: BigNumber): void {
+ const isBigNumber = _.isObject(value) && (value as any).isBigNumber;
+ this.assert(isBigNumber, this.typeAssertionMessage(variableName, 'BigNumber', value));
+ },
+ isValidBaseUnitAmount(variableName: string, value: BigNumber) {
+ assert.isBigNumber(variableName, value);
+ const isNegative = value.lessThan(0);
+ this.assert(!isNegative, `${variableName} cannot be a negative number, found value: ${value.toNumber()}`);
+ const hasDecimals = value.decimalPlaces() !== 0;
+ this.assert(
+ !hasDecimals,
+ `${variableName} should be in baseUnits (no decimals), found value: ${value.toNumber()}`,
+ );
+ },
+ 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(addressUtils.isAddress(value), this.typeAssertionMessage(variableName, 'ETHAddressHex', value));
+ this.assert(
+ addressUtils.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.send) || _.isFunction(value.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 = !_.isUndefined(validUrl.isWebUri(value));
- this.assert(isValidUrl, this.typeAssertionMessage(variableName, 'http url', value));
- },
- isUri(variableName: string, value: any): void {
- const isValidUri = !_.isUndefined(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}`;
- },
+ this.assert(!hasValidationErrors, msg);
+ },
+ isHttpUrl(variableName: string, value: any): void {
+ const isValidUrl = !_.isUndefined(validUrl.isWebUri(value));
+ this.assert(isValidUrl, this.typeAssertionMessage(variableName, 'http url', value));
+ },
+ isUri(variableName: string, value: any): void {
+ const isValidUri = !_.isUndefined(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
index b0fa398d6..0af493bda 100644
--- a/packages/assert/test/assert_test.ts
+++ b/packages/assert/test/assert_test.ts
@@ -11,243 +11,243 @@ 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('#isValidBaseUnitAmount', () => {
- it('should not throw for valid input', () => {
- const validInputs = [new BigNumber(23), new BigNumber('45000000')];
- validInputs.forEach(input =>
- expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).to.not.throw(),
- );
- });
- it('should throw for invalid input', () => {
- const invalidInputs = [0, undefined, new BigNumber(3.145), 3.145, new BigNumber(-400)];
- invalidInputs.forEach(input =>
- expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).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];
- 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, 21e42];
- 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`,
- );
- });
- });
+ 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('#isValidBaseUnitAmount', () => {
+ it('should not throw for valid input', () => {
+ const validInputs = [new BigNumber(23), new BigNumber('45000000')];
+ validInputs.forEach(input =>
+ expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).to.not.throw(),
+ );
+ });
+ it('should throw for invalid input', () => {
+ const invalidInputs = [0, undefined, new BigNumber(3.145), 3.145, new BigNumber(-400)];
+ invalidInputs.forEach(input =>
+ expect(assert.isValidBaseUnitAmount.bind(assert, variableName, input)).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];
+ 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, 21e42];
+ 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
index 88a467ccb..8314a9459 100644
--- a/packages/assert/tsconfig.json
+++ b/packages/assert/tsconfig.json
@@ -1,7 +1,7 @@
{
- "extends": "../../tsconfig",
- "compilerOptions": {
- "outDir": "lib"
- },
- "include": ["./src/**/*", "./test/**/*", "../../node_modules/chai-typescript-typings/index.d.ts"]
+ "extends": "../../tsconfig",
+ "compilerOptions": {
+ "outDir": "lib"
+ },
+ "include": ["./src/**/*", "./test/**/*", "../../node_modules/chai-typescript-typings/index.d.ts"]
}
diff --git a/packages/assert/tslint.json b/packages/assert/tslint.json
index ffaefe83a..e63054bfc 100644
--- a/packages/assert/tslint.json
+++ b/packages/assert/tslint.json
@@ -1,3 +1,3 @@
{
- "extends": ["@0xproject/tslint-config"]
+ "extends": ["@0xproject/tslint-config"]
}