Instadapp/aave-protocol-v2
1
0
Fork 0
mirror of https://github.com/Instadapp/aave-protocol-v2.git synced 2024-07-29 21:47:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Finished migration of configurator.spec.ts

Browse Source
This commit is contained in:
eboado 2020-06-12 09:41:30 +02:00
parent 6ef4ca54b5
commit 57cc16e665
7 changed files with 347 additions and 350 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
package-lock.json generated
View File

@ -1940,6 +1940,12 @@
"type-detect": "^4.0.5" "type-detect": "^4.0.5"
} }
}, },
"chai-bignumber": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/chai-bignumber/-/chai-bignumber-3.0.0.tgz",
"integrity": "sha512-SubOtaSI2AILWTWe2j0c6i2yFT/f9J6UBjeVGDuwDiPLkF/U5+/eTWUE3sbCZ1KgcPF6UJsDVYbIxaYA097MQA==",
"dev": true
},
"chalk": { "chalk": {
"version": "2.4.2", "version": "2.4.2",
"resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",

1
package.json
View File

@ -33,6 +33,7 @@
"bignumber.js": "9.0.0", "bignumber.js": "9.0.0",
"buidler-typechain": "0.1.1", "buidler-typechain": "0.1.1",
"chai": "4.2.0", "chai": "4.2.0",
"chai-bignumber": "3.0.0",
"ethereum-waffle": "2.5.1", "ethereum-waffle": "2.5.1",
"ethers": "4.0.47", "ethers": "4.0.47",
"ganache-cli": "6.9.1", "ganache-cli": "6.9.1",

1
test/__setup.spec.ts
View File

@ -626,6 +626,7 @@ const buildTestEnv = async (deployer: Signer, secondaryWallet: Signer) => {
before(async () => { before(async () => {
await rawBRE.run("set-bre"); await rawBRE.run("set-bre");
const [deployer, secondaryWallet] = await getEthersSigners(); const [deployer, secondaryWallet] = await getEthersSigners();
console.log("-> Deploying test environment...")
await buildTestEnv(deployer, secondaryWallet); await buildTestEnv(deployer, secondaryWallet);
console.log("\n***************"); console.log("\n***************");
console.log("Setup and snapshot finished"); console.log("Setup and snapshot finished");

28
test/atoken-modifiers.spec.ts
View File

@ -1,44 +1,28 @@
import {expect} from "chai"; import {expect} from "chai";
import {getAToken} from "../helpers/contracts-helpers";
import {AToken} from "../types/AToken";
import {makeSuite, TestEnv} from "./helpers/make-suite"; import {makeSuite, TestEnv} from "./helpers/make-suite";
makeSuite("AToken: Modifiers", (testEnv: TestEnv) => { makeSuite("AToken: Modifiers", (testEnv: TestEnv) => {
let _aDAI = {} as AToken;
const NOT_LENDING_POOL_MSG = const NOT_LENDING_POOL_MSG =
"The caller of this function must be a lending pool"; "The caller of this function must be a lending pool";
before(async () => {
const {helpersContract} = testEnv;
const aDAIAddress = (await helpersContract.getAllATokens()).find(
(aToken) => aToken.symbol === "aDAI"
)?.tokenAddress;
if (!aDAIAddress) {
console.log(`atoken-modifiers.spec: aDAI not correctly initialized`);
process.exit(1);
}
_aDAI = await getAToken(aDAIAddress);
});
it("Tries to invoke mintOnDeposit not being the LendingPool", async () => { it("Tries to invoke mintOnDeposit not being the LendingPool", async () => {
const {deployer} = testEnv; const {deployer, aDai} = testEnv;
await expect(_aDAI.mintOnDeposit(deployer.address, "1")).to.be.revertedWith( await expect(aDai.mintOnDeposit(deployer.address, "1")).to.be.revertedWith(
NOT_LENDING_POOL_MSG NOT_LENDING_POOL_MSG
); );
}); });
it("Tries to invoke burnOnLiquidation not being the LendingPool", async () => { it("Tries to invoke burnOnLiquidation not being the LendingPool", async () => {
const {deployer} = testEnv; const {deployer, aDai} = testEnv;
await expect( await expect(
_aDAI.burnOnLiquidation(deployer.address, "1") aDai.burnOnLiquidation(deployer.address, "1")
).to.be.revertedWith(NOT_LENDING_POOL_MSG); ).to.be.revertedWith(NOT_LENDING_POOL_MSG);
}); });
it("Tries to invoke transferOnLiquidation not being the LendingPool", async () => { it("Tries to invoke transferOnLiquidation not being the LendingPool", async () => {
const {deployer, users} = testEnv; const {deployer, users, aDai} = testEnv;
await expect( await expect(
_aDAI.transferOnLiquidation(deployer.address, users[0].address, "1") aDai.transferOnLiquidation(deployer.address, users[0].address, "1")
).to.be.revertedWith(NOT_LENDING_POOL_MSG); ).to.be.revertedWith(NOT_LENDING_POOL_MSG);
}); });
}); });

94
test/atoken-transfer.spec.ts
View File

@ -13,32 +13,32 @@ import {makeSuite, TestEnv} from "./helpers/make-suite";
makeSuite("AToken: Transfer", (testEnv: TestEnv) => { makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
it("User 0 deposits 1000 DAI, transfers to user 1", async () => { it("User 0 deposits 1000 DAI, transfers to user 1", async () => {
const {users, pool, core, _dai, _aDai} = testEnv; const {users, pool, core, dai, aDai} = testEnv;
await _dai await dai
.connect(users[0].signer) .connect(users[0].signer)
.mint(await convertToCurrencyDecimals(_dai.address, "1000")); .mint(await convertToCurrencyDecimals(dai.address, "1000"));
await _dai await dai
.connect(users[0].signer) .connect(users[0].signer)
.approve(core.address, APPROVAL_AMOUNT_LENDING_POOL_CORE); .approve(core.address, APPROVAL_AMOUNT_LENDING_POOL_CORE);
//user 1 deposits 1000 DAI //user 1 deposits 1000 DAI
const amountDAItoDeposit = await convertToCurrencyDecimals( const amountDAItoDeposit = await convertToCurrencyDecimals(
_dai.address, dai.address,
"1000" "1000"
); );
await pool await pool
.connect(users[0].signer) .connect(users[0].signer)
.deposit(_dai.address, amountDAItoDeposit, "0"); .deposit(dai.address, amountDAItoDeposit, "0");
await _aDai await aDai
.connect(users[0].signer) .connect(users[0].signer)
.transfer(users[1].address, amountDAItoDeposit); .transfer(users[1].address, amountDAItoDeposit);
const fromBalance = await _aDai.balanceOf(users[0].address); const fromBalance = await aDai.balanceOf(users[0].address);
const toBalance = await _aDai.balanceOf(users[1].address); const toBalance = await aDai.balanceOf(users[1].address);
expect(fromBalance.toString()).to.be.equal( expect(fromBalance.toString()).to.be.equal(
"0", "0",
@ -51,19 +51,16 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
}); });
it("User 1 redirects interest to user 2, transfers 500 DAI back to user 0", async () => { it("User 1 redirects interest to user 2, transfers 500 DAI back to user 0", async () => {
const {users, _aDai, _dai} = testEnv; const {users, aDai, dai} = testEnv;
await _aDai await aDai
.connect(users[1].signer) .connect(users[1].signer)
.redirectInterestStream(users[2].address); .redirectInterestStream(users[2].address);
const aDAIRedirected = await convertToCurrencyDecimals( const aDAIRedirected = await convertToCurrencyDecimals(dai.address, "1000");
_dai.address,
"1000"
);
const aDAItoTransfer = await convertToCurrencyDecimals(_dai.address, "500"); const aDAItoTransfer = await convertToCurrencyDecimals(dai.address, "500");
const user2RedirectedBalanceBefore = await _aDai.getRedirectedBalance( const user2RedirectedBalanceBefore = await aDai.getRedirectedBalance(
users[2].address users[2].address
); );
expect(user2RedirectedBalanceBefore.toString()).to.be.equal( expect(user2RedirectedBalanceBefore.toString()).to.be.equal(
@ -71,14 +68,14 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
"Invalid redirected balance for user 2 before transfer" "Invalid redirected balance for user 2 before transfer"
); );
await _aDai await aDai
.connect(users[1].signer) .connect(users[1].signer)
.transfer(users[0].address, aDAItoTransfer); .transfer(users[0].address, aDAItoTransfer);
const user2RedirectedBalanceAfter = await _aDai.getRedirectedBalance( const user2RedirectedBalanceAfter = await aDai.getRedirectedBalance(
users[2].address users[2].address
); );
const user1RedirectionAddress = await _aDai.getInterestRedirectionAddress( const user1RedirectionAddress = await aDai.getInterestRedirectionAddress(
users[1].address users[1].address
); );
@ -93,18 +90,18 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
}); });
it("User 0 transfers back to user 1", async () => { it("User 0 transfers back to user 1", async () => {
const {users, _aDai, _dai} = testEnv; const {users, aDai, dai} = testEnv;
const aDAItoTransfer = await convertToCurrencyDecimals(_dai.address, "500"); const aDAItoTransfer = await convertToCurrencyDecimals(dai.address, "500");
await _aDai await aDai
.connect(users[0].signer) .connect(users[0].signer)
.transfer(users[1].address, aDAItoTransfer); .transfer(users[1].address, aDAItoTransfer);
const user2RedirectedBalanceAfter = await _aDai.getRedirectedBalance( const user2RedirectedBalanceAfter = await aDai.getRedirectedBalance(
users[2].address users[2].address
); );
const user1BalanceAfter = await _aDai.balanceOf(users[1].address); const user1BalanceAfter = await aDai.balanceOf(users[1].address);
expect(user2RedirectedBalanceAfter.toString()).to.be.equal( expect(user2RedirectedBalanceAfter.toString()).to.be.equal(
user1BalanceAfter.toString(), user1BalanceAfter.toString(),
@ -134,15 +131,12 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
}); });
it("User 1 sets the DAI as collateral and borrows, tries to transfer everything back to user 0 (revert expected)", async () => { it("User 1 sets the DAI as collateral and borrows, tries to transfer everything back to user 0 (revert expected)", async () => {
const {users, pool, _aDai, _dai} = testEnv; const {users, pool, aDai, dai} = testEnv;
await pool await pool
.connect(users[1].signer) .connect(users[1].signer)
.setUserUseReserveAsCollateral(_dai.address, true); .setUserUseReserveAsCollateral(dai.address, true);
const aDAItoTransfer = await convertToCurrencyDecimals( const aDAItoTransfer = await convertToCurrencyDecimals(dai.address, "1000");
_dai.address,
"1000"
);
await pool await pool
.connect(users[1].signer) .connect(users[1].signer)
@ -154,21 +148,21 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
); );
await expect( await expect(
_aDai.connect(users[1].signer).transfer(users[0].address, aDAItoTransfer), aDai.connect(users[1].signer).transfer(users[0].address, aDAItoTransfer),
"Transfer cannot be allowed." "Transfer cannot be allowed."
).to.be.revertedWith("Transfer cannot be allowed."); ).to.be.revertedWith("Transfer cannot be allowed.");
}); });
it("User 0 tries to transfer 0 balance (revert expected)", async () => { it("User 0 tries to transfer 0 balance (revert expected)", async () => {
const {users, pool, _aDai, _dai} = testEnv; const {users, pool, aDai, dai} = testEnv;
await expect( await expect(
_aDai.connect(users[0].signer).transfer(users[1].address, "0"), aDai.connect(users[0].signer).transfer(users[1].address, "0"),
"Transferred amount needs to be greater than zero" "Transferred amount needs to be greater than zero"
).to.be.revertedWith("Transferred amount needs to be greater than zero"); ).to.be.revertedWith("Transferred amount needs to be greater than zero");
}); });
it("User 1 repays the borrow, transfers aDAI back to user 0", async () => { it("User 1 repays the borrow, transfers aDAI back to user 0", async () => {
const {users, pool, _aDai, _dai} = testEnv; const {users, pool, aDai, dai} = testEnv;
await pool await pool
.connect(users[1].signer) .connect(users[1].signer)
.repay(MOCK_ETH_ADDRESS, MAX_UINT_AMOUNT, users[1].address, { .repay(MOCK_ETH_ADDRESS, MAX_UINT_AMOUNT, users[1].address, {
@ -176,19 +170,19 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
}); });
const aDAItoTransfer = await convertToCurrencyDecimals( const aDAItoTransfer = await convertToCurrencyDecimals(
_aDai.address, aDai.address,
"1000" "1000"
); );
await _aDai await aDai
.connect(users[1].signer) .connect(users[1].signer)
.transfer(users[0].address, aDAItoTransfer); .transfer(users[0].address, aDAItoTransfer);
const user2RedirectedBalanceAfter = await _aDai.getRedirectedBalance( const user2RedirectedBalanceAfter = await aDai.getRedirectedBalance(
users[2].address users[2].address
); );
const user1RedirectionAddress = await _aDai.getInterestRedirectionAddress( const user1RedirectionAddress = await aDai.getInterestRedirectionAddress(
users[1].address users[1].address
); );
@ -204,41 +198,41 @@ makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
}); });
it("User 0 redirects interest to user 2, transfers 500 aDAI to user 1. User 1 redirects to user 3. User 0 transfers another 100 aDAI", async () => { it("User 0 redirects interest to user 2, transfers 500 aDAI to user 1. User 1 redirects to user 3. User 0 transfers another 100 aDAI", async () => {
const {users, pool, _aDai, _dai} = testEnv; const {users, pool, aDai, dai} = testEnv;
let aDAItoTransfer = await convertToCurrencyDecimals(_aDai.address, "500"); let aDAItoTransfer = await convertToCurrencyDecimals(aDai.address, "500");
await _aDai await aDai
.connect(users[0].signer) .connect(users[0].signer)
.redirectInterestStream(users[2].address); .redirectInterestStream(users[2].address);
await _aDai await aDai
.connect(users[0].signer) .connect(users[0].signer)
.transfer(users[1].address, aDAItoTransfer); .transfer(users[1].address, aDAItoTransfer);
await _aDai await aDai
.connect(users[1].signer) .connect(users[1].signer)
.redirectInterestStream(users[3].address); .redirectInterestStream(users[3].address);
aDAItoTransfer = await convertToCurrencyDecimals(_aDai.address, "100"); aDAItoTransfer = await convertToCurrencyDecimals(aDai.address, "100");
await _aDai await aDai
.connect(users[0].signer) .connect(users[0].signer)
.transfer(users[1].address, aDAItoTransfer); .transfer(users[1].address, aDAItoTransfer);
const user2RedirectedBalanceAfter = await _aDai.getRedirectedBalance( const user2RedirectedBalanceAfter = await aDai.getRedirectedBalance(
users[2].address users[2].address
); );
const user3RedirectedBalanceAfter = await _aDai.getRedirectedBalance( const user3RedirectedBalanceAfter = await aDai.getRedirectedBalance(
users[3].address users[3].address
); );
const expectedUser2Redirected = await convertToCurrencyDecimals( const expectedUser2Redirected = await convertToCurrencyDecimals(
_aDai.address, aDai.address,
"400" "400"
); );
const expectedUser3Redirected = await convertToCurrencyDecimals( const expectedUser3Redirected = await convertToCurrencyDecimals(
_aDai.address, aDai.address,
"600" "600"
); );

541
test/configurator.spec.ts
View File

@ -1,314 +1,311 @@
// import {ITestEnvWithoutInstances} from '../utils/types'; import {TestEnv, makeSuite} from "./helpers/make-suite";
// import { import {
// LendingPoolCoreInstance, MOCK_ETH_ADDRESS,
// LendingPoolConfiguratorInstance, RAY,
// LendingPoolInstance, APPROVAL_AMOUNT_LENDING_POOL_CORE,
// } from '../utils/typechain-types/truffle-contracts'; } from "../helpers/constants";
// import {testEnvProviderWithoutInstances} from '../utils/truffle/dlp-tests-env'; import {convertToCurrencyDecimals} from "../helpers/contracts-helpers";
// import {RAY, ETHEREUM_ADDRESS, APPROVAL_AMOUNT_LENDING_POOL_CORE} from '../utils/constants';
// import {convertToCurrencyDecimals} from '../utils/misc-utils';
// const expectRevert = require('@openzeppelin/test-helpers').expectRevert; const {expect} = require("chai");
// const {expect} = require('chai');
// contract('LendingPoolConfigurator', async ([deployer, ...users]) => { makeSuite("AToken: Transfer", (testEnv: TestEnv) => {
// let _testEnvProvider: ITestEnvWithoutInstances; it("Deactivates the ETH reserve", async () => {
// let _lendingPoolConfiguratorInstance: LendingPoolConfiguratorInstance; const {configurator, core} = testEnv;
// let _lendingPoolCoreInstance: LendingPoolCoreInstance; await configurator.deactivateReserve(MOCK_ETH_ADDRESS);
// let _lendingPoolInstance: LendingPoolInstance; const isActive = await core.getReserveIsActive(MOCK_ETH_ADDRESS);
expect(isActive).to.be.equal(false);
});
// before('Initializing LendingPoolConfigurator test variables', async () => { it("Rectivates the ETH reserve", async () => {
// console.time('setup-test'); const {configurator, core} = testEnv;
// _testEnvProvider = await testEnvProviderWithoutInstances(artifacts, [deployer, ...users]); await configurator.activateReserve(MOCK_ETH_ADDRESS);
// const { const isActive = await core.getReserveIsActive(MOCK_ETH_ADDRESS);
// getLendingPoolInstance, expect(isActive).to.be.equal(true);
// getLendingPoolCoreInstance, });
// getLendingPoolConfiguratorInstance,
// } = _testEnvProvider;
// const instances = await Promise.all([
// getLendingPoolConfiguratorInstance(),
// getLendingPoolCoreInstance(),
// getLendingPoolInstance(),
// ]);
// _lendingPoolConfiguratorInstance = instances[0];
// _lendingPoolCoreInstance = instances[1];
// _lendingPoolInstance = instances[2];
// console.timeEnd('setup-test'); it("Check the onlyLendingPoolManager on deactivateReserve ", async () => {
// }); const {configurator, users} = testEnv;
await expect(
configurator.connect(users[2].signer).deactivateReserve(MOCK_ETH_ADDRESS),
"The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Deactivates the ETH reserve', async () => { it("Check the onlyLendingPoolManager on activateReserve ", async () => {
// await _lendingPoolConfiguratorInstance.deactivateReserve(ETHEREUM_ADDRESS); const {configurator, users} = testEnv;
// const isActive = await _lendingPoolCoreInstance.getReserveIsActive(ETHEREUM_ADDRESS); await expect(
// expect(isActive).to.be.equal(false); configurator.connect(users[2].signer).activateReserve(MOCK_ETH_ADDRESS),
// }); "The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Rectivates the ETH reserve', async () => { it("Freezes the ETH reserve", async () => {
// await _lendingPoolConfiguratorInstance.activateReserve(ETHEREUM_ADDRESS); const {configurator, core} = testEnv;
await configurator.freezeReserve(MOCK_ETH_ADDRESS);
const isFreezed = await core.getReserveIsFreezed(MOCK_ETH_ADDRESS);
expect(isFreezed).to.be.equal(true);
});
// const isActive = await _lendingPoolCoreInstance.getReserveIsActive(ETHEREUM_ADDRESS); it("Unfreezes the ETH reserve", async () => {
// expect(isActive).to.be.equal(true); const {configurator, core} = testEnv;
// }); await configurator.unfreezeReserve(MOCK_ETH_ADDRESS);
// it('Check the onlyLendingPoolManager on deactivateReserve ', async () => { const isFreezed = await core.getReserveIsFreezed(MOCK_ETH_ADDRESS);
// await expectRevert( expect(isFreezed).to.be.equal(false);
// _lendingPoolConfiguratorInstance.deactivateReserve(ETHEREUM_ADDRESS, {from: users[2]}), });
// 'The caller must be a lending pool manager'
// );
// });
// it('Check the onlyLendingPoolManager on activateReserve ', async () => { it("Check the onlyLendingPoolManager on freezeReserve ", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.activateReserve(ETHEREUM_ADDRESS, {from: users[2]}), await expect(
// 'The caller must be a lending pool manager' configurator.connect(users[2].signer).freezeReserve(MOCK_ETH_ADDRESS),
// ); "The caller must be a lending pool manager"
// }); ).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Freezes the ETH reserve', async () => { it("Check the onlyLendingPoolManager on unfreezeReserve ", async () => {
// await _lendingPoolConfiguratorInstance.freezeReserve(ETHEREUM_ADDRESS); const {configurator, users} = testEnv;
// const isFreezed = await _lendingPoolCoreInstance.getReserveIsFreezed(ETHEREUM_ADDRESS); await expect(
// expect(isFreezed).to.be.equal(true); configurator.connect(users[2].signer).unfreezeReserve(MOCK_ETH_ADDRESS),
// }); "The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Unfreezes the ETH reserve', async () => { it("Deactivates the ETH reserve for borrowing", async () => {
// await _lendingPoolConfiguratorInstance.unfreezeReserve(ETHEREUM_ADDRESS); const {configurator, core} = testEnv;
await configurator.disableBorrowingOnReserve(MOCK_ETH_ADDRESS);
const isEnabled = await core.isReserveBorrowingEnabled(MOCK_ETH_ADDRESS);
expect(isEnabled).to.be.equal(false);
});
// const isFreezed = await _lendingPoolCoreInstance.getReserveIsFreezed(ETHEREUM_ADDRESS); it("Activates the ETH reserve for borrowing", async () => {
// expect(isFreezed).to.be.equal(false); const {configurator, core} = testEnv;
// }); await configurator.enableBorrowingOnReserve(MOCK_ETH_ADDRESS, true);
const isEnabled = await core.isReserveBorrowingEnabled(MOCK_ETH_ADDRESS);
const interestIndex = await core.getReserveLiquidityCumulativeIndex(
MOCK_ETH_ADDRESS
);
expect(isEnabled).to.be.equal(true);
expect(interestIndex.toString()).to.be.equal(RAY);
});
// it('Check the onlyLendingPoolManager on freezeReserve ', async () => { it("Check the onlyLendingPoolManager on disableBorrowingOnReserve ", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.freezeReserve(ETHEREUM_ADDRESS, {from: users[2]}), await expect(
// 'The caller must be a lending pool manager' configurator
// ); .connect(users[2].signer)
// }); .disableBorrowingOnReserve(MOCK_ETH_ADDRESS),
"The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Check the onlyLendingPoolManager on unfreezeReserve ', async () => { it("Check the onlyLendingPoolManager on enableBorrowingOnReserve ", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.unfreezeReserve(ETHEREUM_ADDRESS, {from: users[2]}), await expect(
// 'The caller must be a lending pool manager' configurator
// ); .connect(users[2].signer)
// }); .enableBorrowingOnReserve(MOCK_ETH_ADDRESS, true),
"The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Deactivates the ETH reserve for borrowing', async () => { it("Deactivates the ETH reserve as collateral", async () => {
// await _lendingPoolConfiguratorInstance.disableBorrowingOnReserve(ETHEREUM_ADDRESS); const {configurator, core} = testEnv;
// const isEnabled = await _lendingPoolCoreInstance.isReserveBorrowingEnabled(ETHEREUM_ADDRESS); await configurator.disableReserveAsCollateral(MOCK_ETH_ADDRESS);
// expect(isEnabled).to.be.equal(false); const isEnabled = await core.isReserveUsageAsCollateralEnabled(
// }); MOCK_ETH_ADDRESS
);
expect(isEnabled).to.be.equal(false);
});
// it('Activates the ETH reserve for borrowing', async () => { it("Activates the ETH reserve as collateral", async () => {
// await _lendingPoolConfiguratorInstance.enableBorrowingOnReserve(ETHEREUM_ADDRESS, true); const {configurator, core} = testEnv;
// const isEnabled = await _lendingPoolCoreInstance.isReserveBorrowingEnabled(ETHEREUM_ADDRESS); await configurator.enableReserveAsCollateral(
// const interestIndex = await _lendingPoolCoreInstance.getReserveLiquidityCumulativeIndex( MOCK_ETH_ADDRESS,
// ETHEREUM_ADDRESS "75",
// ); "80",
// expect(isEnabled).to.be.equal(true); "105"
// expect(interestIndex.toString()).to.be.equal(RAY); );
// });
// it('Check the onlyLendingPoolManager on disableBorrowingOnReserve ', async () => { const isEnabled = await core.isReserveUsageAsCollateralEnabled(
// await expectRevert( MOCK_ETH_ADDRESS
// _lendingPoolConfiguratorInstance.disableBorrowingOnReserve(ETHEREUM_ADDRESS, { );
// from: users[2], expect(isEnabled).to.be.equal(true);
// }), });
// 'The caller must be a lending pool manager'
// );
// });
// it('Check the onlyLendingPoolManager on enableBorrowingOnReserve ', async () => { it("Check the onlyLendingPoolManager on disableReserveAsCollateral ", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.enableBorrowingOnReserve(ETHEREUM_ADDRESS, true, { await expect(
// from: users[2], configurator
// }), .connect(users[2].signer)
// 'The caller must be a lending pool manager' .disableReserveAsCollateral(MOCK_ETH_ADDRESS),
// ); "The caller must be a lending pool manager"
// }); ).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Deactivates the ETH reserve as collateral', async () => { it("Check the onlyLendingPoolManager on enableReserveAsCollateral ", async () => {
// await _lendingPoolConfiguratorInstance.disableReserveAsCollateral(ETHEREUM_ADDRESS); const {configurator, users} = testEnv;
// const isEnabled = await _lendingPoolCoreInstance.isReserveUsageAsCollateralEnabled( await expect(
// ETHEREUM_ADDRESS configurator
// ); .connect(users[2].signer)
// expect(isEnabled).to.be.equal(false); .enableReserveAsCollateral(MOCK_ETH_ADDRESS, "75", "80", "105"),
// }); "The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Activates the ETH reserve as collateral', async () => { it("Disable stable borrow rate on the ETH reserve", async () => {
// await _lendingPoolConfiguratorInstance.enableReserveAsCollateral( const {configurator, core} = testEnv;
// ETHEREUM_ADDRESS, await configurator.disableReserveStableBorrowRate(MOCK_ETH_ADDRESS);
// '75', const isEnabled = await core.getReserveIsStableBorrowRateEnabled(
// '80', MOCK_ETH_ADDRESS
// '105' );
// ); expect(isEnabled).to.be.equal(false);
});
// const isEnabled = await _lendingPoolCoreInstance.isReserveUsageAsCollateralEnabled( it("Enables stable borrow rate on the ETH reserve", async () => {
// ETHEREUM_ADDRESS const {configurator, core} = testEnv;
// ); await configurator.enableReserveStableBorrowRate(MOCK_ETH_ADDRESS);
// expect(isEnabled).to.be.equal(true); const isEnabled = await core.getReserveIsStableBorrowRateEnabled(
// }); MOCK_ETH_ADDRESS
);
expect(isEnabled).to.be.equal(true);
});
// it('Check the onlyLendingPoolManager on disableReserveAsCollateral ', async () => { it("Check the onlyLendingPoolManager on disableReserveStableBorrowRate", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.disableReserveAsCollateral(ETHEREUM_ADDRESS, { await expect(
// from: users[2], configurator
// }), .connect(users[2].signer)
// 'The caller must be a lending pool manager' .disableReserveStableBorrowRate(MOCK_ETH_ADDRESS),
// ); "The caller must be a lending pool manager"
// }); ).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Check the onlyLendingPoolManager on enableReserveAsCollateral ', async () => { it("Check the onlyLendingPoolManager on enableReserveStableBorrowRate", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.enableReserveAsCollateral( await expect(
// ETHEREUM_ADDRESS, configurator
// '75', .connect(users[2].signer)
// '80', .enableReserveStableBorrowRate(MOCK_ETH_ADDRESS),
// '105', "The caller must be a lending pool manager"
// {from: users[2]} ).to.be.revertedWith("The caller must be a lending pool manager");
// ), });
// 'The caller must be a lending pool manager'
// );
// });
// it('Disable stable borrow rate on the ETH reserve', async () => { it("Changes LTV of the reserve", async () => {
// await _lendingPoolConfiguratorInstance.disableReserveStableBorrowRate(ETHEREUM_ADDRESS); const {configurator, pool} = testEnv;
// const isEnabled = await _lendingPoolCoreInstance.getReserveIsStableBorrowRateEnabled( await configurator.setReserveBaseLTVasCollateral(MOCK_ETH_ADDRESS, "60");
// ETHEREUM_ADDRESS const {ltv}: any = await pool.getReserveConfigurationData(MOCK_ETH_ADDRESS);
// ); expect(ltv).to.be.bignumber.equal("60", "Invalid LTV");
// expect(isEnabled).to.be.equal(false); });
// });
// it('Enables stable borrow rate on the ETH reserve', async () => { it("Check the onlyLendingPoolManager on setReserveBaseLTVasCollateral", async () => {
// await _lendingPoolConfiguratorInstance.enableReserveStableBorrowRate(ETHEREUM_ADDRESS); const {configurator, users} = testEnv;
// const isEnabled = await _lendingPoolCoreInstance.getReserveIsStableBorrowRateEnabled( await expect(
// ETHEREUM_ADDRESS configurator
// ); .connect(users[2].signer)
// expect(isEnabled).to.be.equal(true); .setReserveBaseLTVasCollateral(MOCK_ETH_ADDRESS, "75"),
// }); "The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Check the onlyLendingPoolManager on disableReserveStableBorrowRate', async () => { it("Changes liquidation threshold of the reserve", async () => {
// await expectRevert( const {configurator, pool} = testEnv;
// _lendingPoolConfiguratorInstance.disableReserveStableBorrowRate(ETHEREUM_ADDRESS, { await configurator.setReserveLiquidationThreshold(MOCK_ETH_ADDRESS, "75");
// from: users[2], const {liquidationThreshold}: any = await pool.getReserveConfigurationData(
// }), MOCK_ETH_ADDRESS
// 'The caller must be a lending pool manager' );
// ); expect(liquidationThreshold).to.be.bignumber.equal(
// }); "75",
"Invalid Liquidation threshold"
);
});
// it('Check the onlyLendingPoolManager on enableReserveStableBorrowRate', async () => { it("Check the onlyLendingPoolManager on setReserveLiquidationThreshold", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.enableReserveStableBorrowRate(ETHEREUM_ADDRESS, { await expect(
// from: users[2], configurator
// }), .connect(users[2].signer)
// 'The caller must be a lending pool manager' .setReserveLiquidationThreshold(MOCK_ETH_ADDRESS, "80"),
// ); "The caller must be a lending pool manager"
// }); ).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Changes LTV of the reserve', async () => { it("Changes liquidation bonus of the reserve", async () => {
// await _lendingPoolConfiguratorInstance.setReserveBaseLTVasCollateral(ETHEREUM_ADDRESS, '60'); const {configurator, core} = testEnv;
// const {ltv}: any = await _lendingPoolInstance.getReserveConfigurationData(ETHEREUM_ADDRESS); await configurator.setReserveLiquidationBonus(MOCK_ETH_ADDRESS, "110");
// expect(ltv).to.be.bignumber.equal('60', 'Invalid LTV'); const liquidationBonus = await core.getReserveLiquidationBonus(
// }); MOCK_ETH_ADDRESS
);
expect(liquidationBonus).to.be.bignumber.equal(
"110",
"Invalid Liquidation discount"
);
});
// it('Check the onlyLendingPoolManager on setReserveBaseLTVasCollateral', async () => { it("Check the onlyLendingPoolManager on setReserveLiquidationBonus", async () => {
// await expectRevert( const {configurator, users} = testEnv;
// _lendingPoolConfiguratorInstance.setReserveBaseLTVasCollateral(ETHEREUM_ADDRESS, '75', { await expect(
// from: users[2], configurator
// }), .connect(users[2].signer)
// 'The caller must be a lending pool manager' .setReserveLiquidationBonus(MOCK_ETH_ADDRESS, "80"),
// ); "The caller must be a lending pool manager"
// }); ).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Changes liquidation threshold of the reserve', async () => { it("Check the onlyLendingPoolManager on setReserveDecimals", async () => {
// await _lendingPoolConfiguratorInstance.setReserveLiquidationThreshold(ETHEREUM_ADDRESS, '75'); const {configurator, users} = testEnv;
// const {liquidationThreshold}: any = await _lendingPoolInstance.getReserveConfigurationData( await expect(
// ETHEREUM_ADDRESS configurator
// ); .connect(users[2].signer)
// expect(liquidationThreshold).to.be.bignumber.equal('75', 'Invalid Liquidation threshold'); .setReserveDecimals(MOCK_ETH_ADDRESS, "80"),
// }); "The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// it('Check the onlyLendingPoolManager on setReserveLiquidationThreshold', async () => { it("Removes the last added reserve", async () => {
// await expectRevert( const {configurator, pool} = testEnv;
// _lendingPoolConfiguratorInstance.setReserveLiquidationThreshold(ETHEREUM_ADDRESS, '80', { const reservesBefore = await pool.getReserves();
// from: users[2],
// }),
// 'The caller must be a lending pool manager'
// );
// });
// it('Changes liquidation bonus of the reserve', async () => { const lastReserve = reservesBefore[reservesBefore.length - 1];
// await _lendingPoolConfiguratorInstance.setReserveLiquidationBonus(ETHEREUM_ADDRESS, '110');
// const liquidationBonus = await _lendingPoolCoreInstance.getReserveLiquidationBonus(
// ETHEREUM_ADDRESS
// );
// expect(liquidationBonus).to.be.bignumber.equal('110', 'Invalid Liquidation discount');
// });
// it('Check the onlyLendingPoolManager on setReserveLiquidationBonus', async () => { await configurator.removeLastAddedReserve(lastReserve);
// await expectRevert(
// _lendingPoolConfiguratorInstance.setReserveLiquidationBonus(ETHEREUM_ADDRESS, '80', {
// from: users[2],
// }),
// 'The caller must be a lending pool manager'
// );
// });
// it('Check the onlyLendingPoolManager on setReserveDecimals', async () => { const reservesAfter = await pool.getReserves();
// await expectRevert(
// _lendingPoolConfiguratorInstance.setReserveDecimals(ETHEREUM_ADDRESS, '80', {from: users[2]}),
// 'The caller must be a lending pool manager'
// );
// });
// it('Removes the last added reserve', async () => { expect(reservesAfter.length).to.be.equal(
// const reservesBefore = await _lendingPoolInstance.getReserves(); reservesBefore.length - 1,
"Invalid number of reserves after removal"
);
});
// const lastReserve = reservesBefore[reservesBefore.length - 1]; it("Check the onlyLendingPoolManager on setReserveLiquidationBonus", async () => {
const {configurator, users} = testEnv;
await expect(
configurator
.connect(users[2].signer)
.setReserveLiquidationBonus(MOCK_ETH_ADDRESS, "80"),
"The caller must be a lending pool manager"
).to.be.revertedWith("The caller must be a lending pool manager");
});
// await _lendingPoolConfiguratorInstance.removeLastAddedReserve(lastReserve); it("Reverts when trying to disable the DAI reserve with liquidity on it", async () => {
const {dai, core, pool, configurator} = testEnv;
// const reservesAfter = await _lendingPoolInstance.getReserves(); await dai.mint(await convertToCurrencyDecimals(dai.address, "1000"));
// expect(reservesAfter.length).to.be.equal( //approve protocol to access depositor wallet
// reservesBefore.length - 1, await dai.approve(core.address, APPROVAL_AMOUNT_LENDING_POOL_CORE);
// 'Invalid number of reserves after removal' const amountDAItoDeposit = await convertToCurrencyDecimals(
// ); dai.address,
// }); "1000"
);
// it('Check the onlyLendingPoolManager on setReserveLiquidationBonus', async () => { //user 1 deposits 1000 DAI
// await expectRevert( await pool.deposit(dai.address, amountDAItoDeposit, "0");
// _lendingPoolConfiguratorInstance.setReserveLiquidationBonus(ETHEREUM_ADDRESS, '80', {
// from: users[2],
// }),
// 'The caller must be a lending pool manager'
// );
// });
// it('Reverts when trying to disable the DAI reserve with liquidity on it', async () => { await expect(
// const {getAllAssetsInstances, getFirstDepositorAddressOnTests} = _testEnvProvider; configurator.deactivateReserve(dai.address),
"The liquidity of the reserve needs to be 0"
// const daiInstance = (await getAllAssetsInstances()).DAI; ).to.be.revertedWith("The liquidity of the reserve needs to be 0");
});
// const _depositorAddress = await getFirstDepositorAddressOnTests(); });
// await daiInstance.mint(await convertToCurrencyDecimals(daiInstance.address, '1000'), {
// from: _depositorAddress,
// });
// //approve protocol to access depositor wallet
// await daiInstance.approve(_lendingPoolCoreInstance.address, APPROVAL_AMOUNT_LENDING_POOL_CORE, {
// from: _depositorAddress,
// });
// const amountDAItoDeposit = await convertToCurrencyDecimals(daiInstance.address, '1000');
// //user 1 deposits 1000 DAI
// await _lendingPoolInstance.deposit(daiInstance.address, amountDAItoDeposit, '0', {
// from: _depositorAddress,
// });
// await expectRevert(
// _lendingPoolConfiguratorInstance.deactivateReserve(daiInstance.address),
// 'The liquidity of the reserve needs to be 0'
// );
// });
// });

26
test/helpers/make-suite.ts
View File

@ -9,6 +9,7 @@ import {
getAaveProtocolTestHelpers, getAaveProtocolTestHelpers,
getAToken, getAToken,
getMintableErc20, getMintableErc20,
getLendingPoolConfiguratorProxy,
} from "../../helpers/contracts-helpers"; } from "../../helpers/contracts-helpers";
import {tEthereumAddress} from "../../helpers/types"; import {tEthereumAddress} from "../../helpers/types";
import {LendingPool} from "../../types/LendingPool"; import {LendingPool} from "../../types/LendingPool";
@ -17,21 +18,28 @@ import {LendingPoolAddressesProvider} from "../../types/LendingPoolAddressesProv
import {AaveProtocolTestHelpers} from "../../types/AaveProtocolTestHelpers"; import {AaveProtocolTestHelpers} from "../../types/AaveProtocolTestHelpers";
import {MintableErc20} from "../../types/MintableErc20"; import {MintableErc20} from "../../types/MintableErc20";
import {AToken} from "../../types/AToken"; import {AToken} from "../../types/AToken";
import {LendingPoolConfigurator} from "../../types/LendingPoolConfigurator";
import chai from "chai";
// @ts-ignore
import bignumberChai from "chai-bignumber";
chai.use(bignumberChai());
export interface SignerWithAddress { export interface SignerWithAddress {
signer: Signer; signer: Signer;
address: tEthereumAddress; address: tEthereumAddress;
} }
export type TestEnv = { export interface TestEnv {
deployer: SignerWithAddress; deployer: SignerWithAddress;
users: SignerWithAddress[]; users: SignerWithAddress[];
pool: LendingPool; pool: LendingPool;
core: LendingPoolCore; core: LendingPoolCore;
configurator: LendingPoolConfigurator;
addressesProvider: LendingPoolAddressesProvider; addressesProvider: LendingPoolAddressesProvider;
helpersContract: AaveProtocolTestHelpers; helpersContract: AaveProtocolTestHelpers;
_dai: MintableErc20; dai: MintableErc20;
_aDai: AToken; aDai: AToken;
}; }
export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) { export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) {
describe(name, () => { describe(name, () => {
@ -40,6 +48,11 @@ export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) {
users: [] as SignerWithAddress[], users: [] as SignerWithAddress[],
pool: {} as LendingPool, pool: {} as LendingPool,
core: {} as LendingPoolCore, core: {} as LendingPoolCore,
configurator: {} as LendingPoolConfigurator,
addressesProvider: {} as LendingPoolAddressesProvider,
helpersContract: {} as AaveProtocolTestHelpers,
dai: {} as MintableErc20,
aDai: {} as AToken,
} as TestEnv; } as TestEnv;
before(async () => { before(async () => {
console.time("makeSuite"); console.time("makeSuite");
@ -59,6 +72,7 @@ export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) {
testEnv.deployer = deployer; testEnv.deployer = deployer;
testEnv.pool = await getLendingPool(); testEnv.pool = await getLendingPool();
testEnv.core = await getLendingPoolCore(); testEnv.core = await getLendingPoolCore();
testEnv.configurator = await getLendingPoolConfiguratorProxy();
testEnv.addressesProvider = await getLendingPoolAddressesProvider(); testEnv.addressesProvider = await getLendingPoolAddressesProvider();
testEnv.helpersContract = await getAaveProtocolTestHelpers(); testEnv.helpersContract = await getAaveProtocolTestHelpers();
const aDaiAddress = (await testEnv.helpersContract.getAllATokens()).find( const aDaiAddress = (await testEnv.helpersContract.getAllATokens()).find(
@ -77,8 +91,8 @@ export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) {
process.exit(1); process.exit(1);
} }
testEnv._aDai = await getAToken(aDaiAddress); testEnv.aDai = await getAToken(aDaiAddress);
testEnv._dai = await getMintableErc20(daiAddress); testEnv.dai = await getMintableErc20(daiAddress);
console.timeEnd("makeSuite"); console.timeEnd("makeSuite");
}); });
tests(testEnv); tests(testEnv);