crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update tests

Browse Source
This commit is contained in:
Amir Bandeali
2019-06-05 17:44:34 -07:00
parent b1cfdc7a6a
commit d5e88677ae
1 changed files with 244 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
contracts/dev-utils/test/lib_asset_data.ts
View File

@@ -13,11 +13,12 @@ import {
ERC1155MintableContract, ERC1155MintableContract,
ERC1155TransferSingleEventArgs, ERC1155TransferSingleEventArgs,
} from '@0x/contracts-erc1155'; } from '@0x/contracts-erc1155';
import { artifacts as erc20Artifacts, DummyERC20TokenContract } from '@0x/contracts-erc20'; import { artifacts as erc20Artifacts, DummyERC20TokenContract, ERC20TokenContract } from '@0x/contracts-erc20';
import { artifacts as erc721Artifacts, DummyERC721TokenContract } from '@0x/contracts-erc721'; import { artifacts as erc721Artifacts, DummyERC721TokenContract } from '@0x/contracts-erc721';
import { artifacts as exchangeArtifacts, ExchangeContract } from '@0x/contracts-exchange'; import { artifacts as exchangeArtifacts, ExchangeContract } from '@0x/contracts-exchange';
import { chaiSetup, constants, LogDecoder, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils'; import { chaiSetup, constants, LogDecoder, provider, txDefaults, web3Wrapper } from '@0x/contracts-test-utils';
import { BlockchainLifecycle } from '@0x/dev-utils'; import { BlockchainLifecycle } from '@0x/dev-utils';
import { assetDataUtils } from '@0x/order-utils';
import { AssetProxyId } from '@0x/types'; import { AssetProxyId } from '@0x/types';
import { BigNumber } from '@0x/utils'; import { BigNumber } from '@0x/utils';
@@ -185,6 +186,7 @@ describe('LibAssetData', () => {
expect(libAssetData.address.slice(0, 2)).to.equal('0x'); expect(libAssetData.address.slice(0, 2)).to.equal('0x');
}); });
describe('encoding and decoding', () => {
it('should encode ERC20 asset data', async () => { it('should encode ERC20 asset data', async () => {
expect(await libAssetData.encodeERC20AssetData.callAsync(KNOWN_ERC20_ENCODING.address)).to.equal( expect(await libAssetData.encodeERC20AssetData.callAsync(KNOWN_ERC20_ENCODING.address)).to.equal(
KNOWN_ERC20_ENCODING.assetData, KNOWN_ERC20_ENCODING.assetData,
@@ -227,13 +229,15 @@ describe('LibAssetData', () => {
}); });
it('should decode ERC1155 asset data', async () => { it('should decode ERC1155 asset data', async () => {
expect(await libAssetData.decodeERC1155AssetData.callAsync(KNOWN_ERC1155_ENCODING.assetData)).to.deep.equal([ expect(await libAssetData.decodeERC1155AssetData.callAsync(KNOWN_ERC1155_ENCODING.assetData)).to.deep.equal(
[
AssetProxyId.ERC1155, AssetProxyId.ERC1155,
KNOWN_ERC1155_ENCODING.tokenAddress, KNOWN_ERC1155_ENCODING.tokenAddress,
KNOWN_ERC1155_ENCODING.tokenIds, KNOWN_ERC1155_ENCODING.tokenIds,
KNOWN_ERC1155_ENCODING.tokenValues, KNOWN_ERC1155_ENCODING.tokenValues,
KNOWN_ERC1155_ENCODING.callbackData, KNOWN_ERC1155_ENCODING.callbackData,
]); ],
);
}); });
it('should encode multiasset data', async () => { it('should encode multiasset data', async () => {
@@ -246,70 +250,91 @@ describe('LibAssetData', () => {
}); });
it('should decode multiasset data', async () => { it('should decode multiasset data', async () => {
expect(await libAssetData.decodeMultiAssetData.callAsync(KNOWN_MULTI_ASSET_ENCODING.assetData)).to.deep.equal([ expect(
await libAssetData.decodeMultiAssetData.callAsync(KNOWN_MULTI_ASSET_ENCODING.assetData),
).to.deep.equal([
AssetProxyId.MultiAsset, AssetProxyId.MultiAsset,
KNOWN_MULTI_ASSET_ENCODING.amounts, KNOWN_MULTI_ASSET_ENCODING.amounts,
KNOWN_MULTI_ASSET_ENCODING.nestedAssetData, KNOWN_MULTI_ASSET_ENCODING.nestedAssetData,
]); ]);
}); });
});
describe('getBalance', () => {
it('should query ERC20 balance by asset data', async () => { it('should query ERC20 balance by asset data', async () => {
expect( const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
await libAssetData.getBalance.callAsync( expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(
tokenOwnerAddress, erc20TokenTotalSupply,
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address), );
), });
).to.bignumber.equal(erc20TokenTotalSupply);
it('should return 0 if ERC20 token does not exist', async () => {
const assetData = assetDataUtils.encodeERC20AssetData(constants.NULL_ADDRESS);
const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
}); });
it('should query ERC721 balance by asset data', async () => { it('should query ERC721 balance by asset data', async () => {
expect( const assetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
await libAssetData.getBalance.callAsync( expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(1);
tokenOwnerAddress, });
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId),
), it('should return 0 if ERC721 token does not exist', async () => {
).to.bignumber.equal(1); const assetData = assetDataUtils.encodeERC721AssetData(constants.NULL_ADDRESS, firstERC721TokenId);
const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
}); });
it('should query ERC1155 balances by asset data', async () => { it('should query ERC1155 balances by asset data', async () => {
expect( const assetData = assetDataUtils.encodeERC1155AssetData(
await libAssetData.getBalance.callAsync(
tokenOwnerAddress,
await libAssetData.encodeERC1155AssetData.callAsync(
erc1155Token.address, erc1155Token.address,
[erc1155TokenId], [erc1155TokenId],
[new BigNumber(1)], // token values [new BigNumber(1)],
'0x', // callback data constants.NULL_BYTES,
), );
), expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(1);
).to.bignumber.equal(1); });
it('should return 0 if ERC1155 token does not exist', async () => {
const assetData = assetDataUtils.encodeERC1155AssetData(
constants.NULL_ADDRESS,
[erc1155TokenId],
[new BigNumber(1)],
constants.NULL_BYTES,
);
const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData);
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
}); });
it('should query multi-asset batch balance by asset data', async () => { it('should query multi-asset batch balance by asset data', async () => {
expect( const assetData = assetDataUtils.encodeMultiAssetData(
await libAssetData.getBalance.callAsync(
tokenOwnerAddress,
await libAssetData.encodeMultiAssetData.callAsync(
[new BigNumber(1), new BigNumber(1)], [new BigNumber(1), new BigNumber(1)],
[ [
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address), assetDataUtils.encodeERC20AssetData(erc20Token.address),
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId), assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId),
], ],
), );
), expect(await libAssetData.getBalance.callAsync(tokenOwnerAddress, assetData)).to.bignumber.equal(
).to.bignumber.equal(Math.min(erc20TokenTotalSupply.toNumber(), numberOfERC721Tokens)); Math.min(erc20TokenTotalSupply.toNumber(), numberOfERC721Tokens),
);
}); });
it('should return a balance of 0 if the assetData does not correspond to an AssetProxy contract', async () => {
const fakeAssetData = '0x01020304';
const balance = await libAssetData.getBalance.callAsync(tokenOwnerAddress, fakeAssetData);
expect(balance).to.bignumber.equal(constants.ZERO_AMOUNT);
});
});
describe('getAssetProxyAllowance', () => {
it('should query ERC20 allowances by asset data', async () => { it('should query ERC20 allowances by asset data', async () => {
const allowance = new BigNumber(1); const allowance = new BigNumber(1);
await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, { await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
expect( expect(
await libAssetData.getAssetProxyAllowance.callAsync( await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
tokenOwnerAddress,
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address),
),
).to.bignumber.equal(allowance); ).to.bignumber.equal(allowance);
}); });
@@ -317,11 +342,9 @@ describe('LibAssetData', () => {
await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, { await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
const assetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
expect( expect(
await libAssetData.getAssetProxyAllowance.callAsync( await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
tokenOwnerAddress,
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId),
),
).to.bignumber.equal(1); ).to.bignumber.equal(1);
}); });
@@ -329,11 +352,9 @@ describe('LibAssetData', () => {
await erc721Token.setApprovalForAll.awaitTransactionSuccessAsync(erc721Proxy.address, true, { await erc721Token.setApprovalForAll.awaitTransactionSuccessAsync(erc721Proxy.address, true, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
const assetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
expect( expect(
await libAssetData.getAssetProxyAllowance.callAsync( await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
tokenOwnerAddress,
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId),
),
).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS); ).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
}); });
@@ -341,16 +362,14 @@ describe('LibAssetData', () => {
await erc1155Token.setApprovalForAll.awaitTransactionSuccessAsync(erc1155Proxy.address, true, { await erc1155Token.setApprovalForAll.awaitTransactionSuccessAsync(erc1155Proxy.address, true, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
expect( const assetData = assetDataUtils.encodeERC1155AssetData(
await libAssetData.getAssetProxyAllowance.callAsync(
tokenOwnerAddress,
await libAssetData.encodeERC1155AssetData.callAsync(
erc1155Token.address, erc1155Token.address,
[erc1155TokenId], [erc1155TokenId],
[new BigNumber(1)], [new BigNumber(1)],
'0x', constants.NULL_BYTES,
), );
), expect(
await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS); ).to.bignumber.equal(constants.UNLIMITED_ALLOWANCE_IN_BASE_UNITS);
}); });
@@ -362,44 +381,34 @@ describe('LibAssetData', () => {
await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, { await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
expect( const assetData = assetDataUtils.encodeMultiAssetData(
await libAssetData.getAssetProxyAllowance.callAsync(
tokenOwnerAddress,
await libAssetData.encodeMultiAssetData.callAsync(
[new BigNumber(1), new BigNumber(1)], [new BigNumber(1), new BigNumber(1)],
[ [
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address), assetDataUtils.encodeERC20AssetData(erc20Token.address),
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId), assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId),
], ],
), );
), expect(
await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
).to.bignumber.equal(1); ).to.bignumber.equal(1);
return; return;
}); });
it('should query balances for a batch of asset data strings', async () => { it('should return an allowance of 0 if the assetData does not correspond to an AssetProxy contract', async () => {
expect( const fakeAssetData = '0x01020304';
await libAssetData.getBatchBalances.callAsync(tokenOwnerAddress, [ const allowance = await libAssetData.getAssetProxyAllowance.callAsync(tokenOwnerAddress, fakeAssetData);
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address), expect(allowance).to.bignumber.equal(constants.ZERO_AMOUNT);
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId), });
]),
).to.deep.equal([new BigNumber(erc20TokenTotalSupply), new BigNumber(1)]);
}); });
it('should query allowances for a batch of asset data strings', async () => { describe('getBatchBalances', () => {
const allowance = new BigNumber(1); it('should query balances for a batch of asset data strings', async () => {
await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, { const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
from: tokenOwnerAddress, const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
});
await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
from: tokenOwnerAddress,
});
expect( expect(
await libAssetData.getBatchAssetProxyAllowances.callAsync(tokenOwnerAddress, [ await libAssetData.getBatchBalances.callAsync(tokenOwnerAddress, [erc20AssetData, erc721AssetData]),
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address), ).to.deep.equal([new BigNumber(erc20TokenTotalSupply), new BigNumber(1)]);
await libAssetData.encodeERC721AssetData.callAsync(erc721Token.address, firstERC721TokenId), });
]),
).to.deep.equal([new BigNumber(1), new BigNumber(1)]);
}); });
describe('getERC721TokenOwner', async () => { describe('getERC721TokenOwner', async () => {
@@ -416,28 +425,48 @@ describe('LibAssetData', () => {
}); });
}); });
describe('getBalanceAndAllowance', () => {
it('should query balance and allowance together, from asset data', async () => { it('should query balance and allowance together, from asset data', async () => {
const allowance = new BigNumber(1); const allowance = new BigNumber(1);
await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, { await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
expect( expect(
await libAssetData.getBalanceAndAssetProxyAllowance.callAsync( await libAssetData.getBalanceAndAssetProxyAllowance.callAsync(tokenOwnerAddress, assetData),
tokenOwnerAddress,
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address),
),
).to.deep.equal([new BigNumber(erc20TokenTotalSupply), allowance]); ).to.deep.equal([new BigNumber(erc20TokenTotalSupply), allowance]);
}); });
});
describe('getBatchBalancesAndAllowances', () => {
it('should query balances and allowances together, from an asset data array', async () => { it('should query balances and allowances together, from an asset data array', async () => {
const allowance = new BigNumber(1); const allowance = new BigNumber(1);
await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, { await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
from: tokenOwnerAddress, from: tokenOwnerAddress,
}); });
const assetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
expect( expect(
await libAssetData.getBatchBalancesAndAssetProxyAllowances.callAsync(tokenOwnerAddress, [ await libAssetData.getBatchBalancesAndAssetProxyAllowances.callAsync(tokenOwnerAddress, [assetData]),
await libAssetData.encodeERC20AssetData.callAsync(erc20Token.address),
]),
).to.deep.equal([[new BigNumber(erc20TokenTotalSupply)], [allowance]]); ).to.deep.equal([[new BigNumber(erc20TokenTotalSupply)], [allowance]]);
}); });
});
describe('getBatchAssetProxyAllowances', () => {
it('should query allowances for a batch of asset data strings', async () => {
const allowance = new BigNumber(1);
await erc20Token.approve.awaitTransactionSuccessAsync(erc20Proxy.address, allowance, {
from: tokenOwnerAddress,
});
await erc721Token.approve.awaitTransactionSuccessAsync(erc721Proxy.address, firstERC721TokenId, {
from: tokenOwnerAddress,
});
const erc20AssetData = assetDataUtils.encodeERC20AssetData(erc20Token.address);
const erc721AssetData = assetDataUtils.encodeERC721AssetData(erc721Token.address, firstERC721TokenId);
expect(
await libAssetData.getBatchAssetProxyAllowances.callAsync(tokenOwnerAddress, [
erc20AssetData,
erc721AssetData,
]),
).to.deep.equal([new BigNumber(1), new BigNumber(1)]);
});
});
}); });