status-im
/
liquid-funding
mirror of https://github.com/status-im/liquid-funding.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

eslint fix and test timeout longer

This commit is contained in:
Jordi Baylina 2017-08-13 14:12:45 +02:00
parent a12ade05d9
commit 526630f7f4
No known key found for this signature in database
GPG Key ID: 7480C80C1BE43112
2 changed files with 344 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
package.json
View File

@ -37,13 +37,13 @@
"ethereumjs-testrpc": "^3.0.5",
"random-bytes": "^1.0.0",
"mocha": "^3.5.0",
"chai": "^4.1.0",
"solcpiler": "0.0.4"
},
"homepage": "https://github.com/Giveth/liquidpledging#readme",
"dependencies": {
"async": "^2.4.0",
"ethconnector": "0.0.25",
"runethtx": "0.1.0"
"runethtx": "0.1.0",
"chai": "^4.1.0"
}
}

680
test/NormalOperation.js
View File

@ -1,364 +1,368 @@
/* eslint-env mocha */
/* eslint-disable no-await-in-loop */
const ethConnector = require('ethconnector');
const chai = require('chai');
const assert = chai.assert;
const getBalance = require('runethtx').getBalance;
const LiquidPledging = require('../js/liquidPledging.js')(true);
const Vault = require('../js/vault.js');
const assertFail = require("./helpers/assertFail");
const getBalance = require("runethtx").getBalance;
const assertFail = require('./helpers/assertFail');
const assert = chai.assert;
const getNote = async (liquidPledging, idNote) => {
const note = {
delegates: [],
};
const res = await liquidPledging.getNote(idNote);
note.amount = res[0];
note.owner = res[1];
for (let i=1; i <= res[2].toNumber(); i += 1) {
const delegate = {};
const resd = await liquidPledging.getNoteDelegate(idNote, i);
delegate.id = resd[0].toNumber();
delegate.addr = resd[1];
delegate.name = resd[2];
note.delegates.push(delegate);
}
if (res[3].toNumber()) {
note.proposedProject = res[3].toNumber();
note.commmitTime = res[4].toNumber();
}
if (res[5].toNumber()) {
note.oldProject = res[5].toNumber();
}
if (res[6].toNumber() == 0) {
note.paymentState = "NotPaid";
} else if (res[6].toNumber() == 1) {
note.paymentState = "Paying";
} else if (res[6].toNumber() == 2) {
note.paymentState = "Paid";
} else {
note.paymentState = "Unknown";
}
return note;
const note = {
delegates: [],
};
const res = await liquidPledging.getNote(idNote);
note.amount = res[0];
note.owner = res[1];
for (let i = 1; i <= res[2].toNumber(); i += 1) {
const delegate = {};
const resd = await liquidPledging.getNoteDelegate(idNote, i);
delegate.id = resd[0].toNumber();
delegate.addr = resd[1];
delegate.name = resd[2];
note.delegates.push(delegate);
}
if (res[3].toNumber()) {
note.proposedProject = res[3].toNumber();
note.commmitTime = res[4].toNumber();
}
if (res[5].toNumber()) {
note.oldProject = res[5].toNumber();
}
if (res[6].toNumber() === 0) {
note.paymentState = 'NotPaid';
} else if (res[6].toNumber() === 1) {
note.paymentState = 'Paying';
} else if (res[6].toNumber() === 2) {
note.paymentState = 'Paid';
} else {
note.paymentState = 'Unknown';
}
return note;
};
const getManager = async (liquidPledging, idManager) => {
const manager = {};
const res = await liquidPledging.getNoteManager(idManager);
if (res[0].toNumber() == 0) {
manager.paymentState = "Donor";
} else if (res[0].toNumber() === 1) {
manager.paymentState = "Delegate";
} else if (res[0].toNumber() === 2) {
manager.paymentState = "Project";
} else {
manager.paymentState = "Unknown";
}
manager.addr = res[1];
manager.name = res[2];
manager.commitTime = res[3].toNumber();
if (manager.paymentState == "Project") {
manager.reviewer = res[4];
manager.canceled = res[5];
}
return manager;
const manager = {};
const res = await liquidPledging.getNoteManager(idManager);
if (res[0].toNumber() === 0) {
manager.paymentState = 'Donor';
} else if (res[0].toNumber() === 1) {
manager.paymentState = 'Delegate';
} else if (res[0].toNumber() === 2) {
manager.paymentState = 'Project';
} else {
manager.paymentState = 'Unknown';
}
manager.addr = res[1];
manager.name = res[2];
manager.commitTime = res[3].toNumber();
if (manager.paymentState === 'Project') {
manager.reviewer = res[4];
manager.canceled = res[5];
}
return manager;
};
const getState = async (liquidPledging) => {
const st = {
notes: [null],
managers: [null],
};
const nNotes = await liquidPledging.numberOfNotes();
for (let i=1; i <= nNotes; i += 1) {
const note = await getNote(liquidPledging, i);
st.notes.push(note);
}
const st = {
notes: [null],
managers: [null],
};
const nNotes = await liquidPledging.numberOfNotes();
for (let i = 1; i <= nNotes; i += 1) {
const note = await getNote(liquidPledging, i);
st.notes.push(note);
}
const nManagers = await liquidPledging.numberOfNoteManagers();
for (let i=1; i <= nManagers; i += 1) {
const manager = await getManager(liquidPledging, i);
st.managers.push(manager);
}
return st;
const nManagers = await liquidPledging.numberOfNoteManagers();
for (let i = 1; i <= nManagers; i += 1) {
const manager = await getManager(liquidPledging, i);
st.managers.push(manager);
}
return st;
};
/*
const printState = async(liquidPledging) => {
const st = await getState(liquidPledging);
console.log(JSON.stringify(st, null, 2));
const st = await getState(liquidPledging);
console.log(JSON.stringify(st, null, 2));
};
const printBalances = async(liquidPledging) => {
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 13);
for (let i = 1; i <= 12; i += 1) {
console.log(i, ethConnector.web3.fromWei(st.notes[i].amount).toNumber());
}
};
*/
describe('LiquidPledging test', () => {
let web3;
let accounts;
let liquidPledging;
let vault;
let donor1;
let delegate1;
let adminProject1;
let adminProject2;
let adminProject2a;
let delegate2;
let reviewer;
before((done) => {
ethConnector.init('testrpc', { gasLimit: 4000000 }, () => {
web3 = ethConnector.web3;
accounts = ethConnector.accounts;
donor1 = accounts[1];
delegate1 = accounts[2];
adminProject1 = accounts[3];
adminProject2 = accounts[4];
adminProject2a = accounts[5];
delegate2 = accounts[6];
reviewer = accounts[7];
done();
});
});
it('Should deploy LiquidPledgin contract', async () => {
vault = await Vault.new(web3);
liquidPledging = await LiquidPledging.new(web3, vault.$address);
await vault.setLiquidPledging(liquidPledging.$address);
}).timeout(6000);
it('Should create a donor', async () => {
await liquidPledging.addDonor('Donor1', 86400, { from: donor1 });
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 1);
const res = await liquidPledging.getNoteManager(1);
assert.equal(res[0], 0); // Donor
assert.equal(res[1], donor1);
assert.equal(res[2], 'Donor1');
assert.equal(res[3], 86400);
}).timeout(6000);
it('Should make a donation', async () => {
await liquidPledging.donate(1, 1, { from: donor1, value: web3.toWei(1) });
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 1);
await liquidPledging.getNote(1);
}).timeout(6000);
it('Should create a delegate', async () => {
await liquidPledging.addDelegate('Delegate1', { from: delegate1 });
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 2);
const res = await liquidPledging.getNoteManager(2);
assert.equal(res[0], 1); // Donor
assert.equal(res[1], delegate1);
assert.equal(res[2], 'Delegate1');
}).timeout(6000);
it('Donor should delegate on the delegate', async () => {
await liquidPledging.transfer(1, 1, web3.toWei(0.5), 2, { from: donor1 });
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 2);
const res1 = await liquidPledging.getNote(1);
assert.equal(res1[0].toNumber(), web3.toWei(0.5));
const res2 = await liquidPledging.getNote(2);
assert.equal(res2[0].toNumber(), web3.toWei(0.5));
assert.equal(res2[1].toNumber(), 1); // One delegate
const d = await liquidPledging.getNoteDelegate(2, 1);
assert.equal(d[0], 2);
assert.equal(d[1], delegate1);
assert.equal(d[2], 'Delegate1');
}).timeout(6000);
it('Should create a 2 projects', async () => {
await liquidPledging.addProject('Project1', reviewer, 86400, { from: adminProject1 });
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 3);
const res = await liquidPledging.getNoteManager(3);
assert.equal(res[0], 2); // Project type
assert.equal(res[1], adminProject1);
assert.equal(res[2], 'Project1');
assert.equal(res[3], 86400);
assert.equal(res[4], reviewer);
assert.equal(res[5], false);
await liquidPledging.addProject('Project2', reviewer, 86400, { from: adminProject2 });
const nManagers2 = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers2, 4);
const res4 = await liquidPledging.getNoteManager(4);
assert.equal(res4[0], 2); // Project type
assert.equal(res4[1], adminProject2);
assert.equal(res4[2], 'Project2');
assert.equal(res4[3], 86400);
assert.equal(res4[4], reviewer);
assert.equal(res4[5], false);
}).timeout(6000);
it('Delegate should assign to project1', async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.transfer(2, 2, web3.toWei(0.2), 3, { from: delegate1 });
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 3);
const res3 = await liquidPledging.getNote(3);
assert.equal(res3[0].toNumber(), web3.toWei(0.2));
assert.equal(res3[1].toNumber(), 1); // Owner
assert.equal(res3[2].toNumber(), 1); // Delegates
assert.equal(res3[3].toNumber(), 3); // Proposed Project
assert.isAbove(res3[4].toNumber(), n + 86000);
assert.equal(res3[5].toNumber(), 0); // Old Node
assert.equal(res3[6].toNumber(), 0); // Not Paid
}).timeout(6000);
it('Donor should change his mind and assign half of it to project2', async () => {
await liquidPledging.transfer(1, 3, web3.toWei(0.1), 4, { from: donor1 });
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 4);
const res3 = await liquidPledging.getNote(3);
assert.equal(res3[0].toNumber(), web3.toWei(0.1));
const res4 = await liquidPledging.getNote(4);
assert.equal(res4[1].toNumber(), 4); // Owner
assert.equal(res4[2].toNumber(), 0); // Delegates
assert.equal(res4[3].toNumber(), 0); // Proposed Project
assert.equal(res4[4], 0);
assert.equal(res4[5].toNumber(), 2); // Old Node
assert.equal(res4[6].toNumber(), 0); // Not Paid
}).timeout(6000);
it('After the time, the project1 should be able to spend part of it', async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.setMockedTime(n + 86401);
await liquidPledging.withdraw(3, web3.toWei(0.05), { from: adminProject1 });
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 6);
const res5 = await liquidPledging.getNote(5);
assert.equal(res5[0].toNumber(), web3.toWei(0.05));
assert.equal(res5[1].toNumber(), 3); // Owner
assert.equal(res5[2].toNumber(), 0); // Delegates
assert.equal(res5[3].toNumber(), 0); // Proposed Project
assert.equal(res5[4], 0); // commit time
assert.equal(res5[5].toNumber(), 2); // Old Node
assert.equal(res5[6].toNumber(), 0); // Not Paid
const res6 = await liquidPledging.getNote(6);
assert.equal(res6[0].toNumber(), web3.toWei(0.05));
assert.equal(res6[1].toNumber(), 3); // Owner
assert.equal(res6[2].toNumber(), 0); // Delegates
assert.equal(res6[3].toNumber(), 0); // Proposed Project
assert.equal(res6[4], 0); // commit time
assert.equal(res6[5].toNumber(), 2); // Old Node
assert.equal(res6[6].toNumber(), 1); // Peinding paid Paid
}).timeout(6000);
it('Should collect the Ether', async () => {
const initialBalance = await getBalance(web3, adminProject1);
await vault.confirmPayment(0);
const finalBalance = await getBalance(web3, adminProject1);
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
assert.equal(collected, 0.05);
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 7);
const res7 = await liquidPledging.getNote(7);
assert.equal(res7[0].toNumber(), web3.toWei(0.05));
assert.equal(res7[1].toNumber(), 3); // Owner
assert.equal(res7[2].toNumber(), 0); // Delegates
assert.equal(res7[3].toNumber(), 0); // Proposed Project
assert.equal(res7[4], 0); // commit time
assert.equal(res7[5].toNumber(), 2); // Old Node
assert.equal(res7[6].toNumber(), 2); // Peinding paid Paid
}).timeout(6000);
it('Reviewer should be able to cancel project1', async () => {
await liquidPledging.cancelProject(3, { from: reviewer });
const st = await getState(liquidPledging);
assert.equal(st.managers[3].canceled, true);
}).timeout(6000);
it('Should not allow to withdraw from a canceled project', async () => {
const st = await getState(liquidPledging);
assert.equal(web3.fromWei(st.notes[5].amount).toNumber(), 0.05);
await assertFail(async () => {
await liquidPledging.withdraw(5, web3.toWei(0.01), { from: adminProject1 });
});
}).timeout(6000);
it('Delegate should send part of this ETH to project2', async () => {
await liquidPledging.transfer(2, 5, web3.toWei(0.03), 4,
{ $extraGas: 100000 },
{ from: delegate1 });
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 9);
assert.equal(web3.fromWei(st.notes[8].amount).toNumber(), 0.03);
assert.equal(st.notes[8].owner, 1);
assert.equal(st.notes[8].delegates.length, 1);
assert.equal(st.notes[8].delegates[0].id, 2);
assert.equal(st.notes[8].proposedProject, 4);
}).timeout(6000);
it('Donor should be able to send the remaining to project2', async () => {
await liquidPledging.transfer(1, 5, web3.toWei(0.02), 4, { from: donor1 });
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 9);
assert.equal(web3.fromWei(st.notes[5].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.notes[4].amount).toNumber(), 0.12);
}).timeout(6000);
it('A subproject 2a and a delegate2 is created', async () => {
await liquidPledging.addProject('Project2a', reviewer, 86400, { from: adminProject2a });
await liquidPledging.addDelegate('Delegate2', { from: delegate2 });
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 6);
}).timeout(6000);
it('Project 2 delegate in delegate2', async () => {
await liquidPledging.transfer(4, 4, web3.toWei(0.02), 6, { from: adminProject2 });
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 10);
assert.equal(web3.fromWei(st.notes[9].amount).toNumber(), 0.02);
assert.equal(web3.fromWei(st.notes[4].amount).toNumber(), 0.1);
}).timeout(6000);
it('delegate2 assigns to projec2a', async () => {
await liquidPledging.transfer(6, 9, web3.toWei(0.01), 5, { from: delegate2 });
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 11);
assert.equal(web3.fromWei(st.notes[9].amount).toNumber(), 0.01);
assert.equal(web3.fromWei(st.notes[10].amount).toNumber(), 0.01);
}).timeout(4000);
it('project2a authorize to spend a litle', async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.setMockedTime(n + (86401 * 3));
await liquidPledging.withdraw(10, web3.toWei(0.005), { from: adminProject2a });
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 13);
for (let i=1; i<=12; i++) {
console.log(i, web3.fromWei(st.notes[ i ].amount).toNumber() )
}
};
assert.equal(web3.fromWei(st.notes[10].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.notes[11].amount).toNumber(), 0.005);
assert.equal(web3.fromWei(st.notes[12].amount).toNumber(), 0.005);
}).timeout(4000);
it('project2 is canceled', async () => {
await liquidPledging.cancelProject(4, { from: reviewer });
}).timeout(6000);
it('project2 should not be able to confirm payment', async () => {
await assertFail(async () => {
await vault.confirmPayment(1);
});
}).timeout(6000);
it('Should not be able to withdraw it', async () => {
await assertFail(async () => {
await liquidPledging.withdraw(12, web3.toWei(0.005), { from: donor1 });
});
}).timeout(6000);
it('Should not be able to cancel payment', async () => {
await vault.cancelPayment(1);
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 13);
assert.equal(web3.fromWei(st.notes[2].amount).toNumber(), 0.31);
assert.equal(web3.fromWei(st.notes[11].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.notes[12].amount).toNumber(), 0);
}).timeout(6000);
it('original owner should recover the remaining funds', async () => {
await liquidPledging.withdraw(1, web3.toWei(0.5), { from: donor1 });
await liquidPledging.withdraw(2, web3.toWei(0.31), { from: donor1 });
await liquidPledging.withdraw(4, web3.toWei(0.1), { from: donor1 });
describe("LiquidPledging test", () => {
let web3;
let accounts;
let liquidPledging;
let vault;
let donor1;
let delegate1;
let adminProject1;
let adminProject2;
let adminProject2a;
let delegate2;
let reviewer;
before((done) => {
ethConnector.init("testrpc", { gasLimit: 4000000 }, () => {
web3 = ethConnector.web3;
accounts = ethConnector.accounts;
donor1 = accounts[1];
delegate1 = accounts[2];
adminProject1 = accounts[3];
adminProject2 = accounts[4];
adminProject2a = accounts[5];
delegate2 = accounts[6];
reviewer = accounts[7];
done();
});
});
it("Should deploy LiquidPledgin contract", async () => {
vault = await Vault.new(web3);
liquidPledging = await LiquidPledging.new(web3, vault.$address);
await vault.setLiquidPledging(liquidPledging.$address);
});
it("Should create a donor", async () => {
await liquidPledging.addDonor("Donor1", 86400, {from: donor1});
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 1);
const res = await liquidPledging.getNoteManager(1);
assert.equal(res[0], 0); // Donor
assert.equal(res[1], donor1);
assert.equal(res[2], "Donor1");
assert.equal(res[3], 86400);
});
it("Should make a donation", async () => {
await liquidPledging.donate(1, 1, {from: donor1, value: web3.toWei(1)});
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 1);
const res = await liquidPledging.getNote(1);
});
it("Should create a delegate", async () => {
await liquidPledging.addDelegate("Delegate1", {from: delegate1});
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 2);
const res = await liquidPledging.getNoteManager(2);
assert.equal(res[0], 1); // Donor
assert.equal(res[1], delegate1);
assert.equal(res[2], "Delegate1");
});
it("Donor should delegate on the delegate ", async () => {
await liquidPledging.transfer(1, 1, web3.toWei(0.5), 2, {from: donor1});
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 2);
const res1 = await liquidPledging.getNote(1);
assert.equal(res1[0].toNumber(), web3.toWei(0.5));
const res2 = await liquidPledging.getNote(2);
assert.equal(res2[0].toNumber(), web3.toWei(0.5));
assert.equal(res2[1].toNumber(), 1); // One delegate
await liquidPledging.withdraw(8, web3.toWei(0.03), { $extraGas: 100000 }, { from: donor1 });
await liquidPledging.withdraw(9, web3.toWei(0.01), { from: donor1 });
const d = await liquidPledging.getNoteDelegate(2, 1);
assert.equal(d[0], 2);
assert.equal(d[1], delegate1);
assert.equal(d[2], "Delegate1");
});
it("Should create a 2 projects", async () => {
await liquidPledging.addProject("Project1", reviewer, 86400, {from: adminProject1});
const initialBalance = await getBalance(web3, donor1);
await vault.multiConfirm([2, 3, 4, 5, 6]);
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 3);
const res = await liquidPledging.getNoteManager(3);
assert.equal(res[0], 2); // Project type
assert.equal(res[1], adminProject1);
assert.equal(res[2], "Project1");
assert.equal(res[3], 86400);
assert.equal(res[4], reviewer);
assert.equal(res[5], false);
await liquidPledging.addProject("Project2", reviewer, 86400, {from: adminProject2});
const nManagers2 = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers2, 4);
const res4 = await liquidPledging.getNoteManager(4);
assert.equal(res4[0], 2); // Project type
assert.equal(res4[1], adminProject2);
assert.equal(res4[2], "Project2");
assert.equal(res4[3], 86400);
assert.equal(res4[4], reviewer);
assert.equal(res4[5], false);
});
it("Delegate should assign to project1", async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.transfer(2, 2, web3.toWei(0.2), 3, {from: delegate1});
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 3);
const res3 = await liquidPledging.getNote(3);
assert.equal(res3[0].toNumber(), web3.toWei(0.2));
assert.equal(res3[1].toNumber(), 1); // Owner
assert.equal(res3[2].toNumber(), 1); // Delegates
assert.equal(res3[3].toNumber(), 3); // Proposed Project
assert.isAbove(res3[4].toNumber(), n + 86000);
assert.equal(res3[5].toNumber(), 0); // Old Node
assert.equal(res3[6].toNumber(), 0); // Not Paid
});
it("Donor should change his mind and assign half of it to project2", async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.transfer(1, 3, web3.toWei(0.1), 4, {from: donor1});
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 4);
const res3 = await liquidPledging.getNote(3);
assert.equal(res3[0].toNumber(), web3.toWei(0.1));
const res4 = await liquidPledging.getNote(4);
assert.equal(res4[1].toNumber(), 4); // Owner
assert.equal(res4[2].toNumber(), 0); // Delegates
assert.equal(res4[3].toNumber(), 0); // Proposed Project
assert.equal(res4[4], 0);
assert.equal(res4[5].toNumber(), 2); // Old Node
assert.equal(res4[6].toNumber(), 0); // Not Paid
});
it("After the time, the project1 should be able to spend part of it", async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.setMockedTime(n + 86401);
await liquidPledging.withdraw(3, web3.toWei(0.05), {from: adminProject1});
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 6);
const res5 = await liquidPledging.getNote(5);
assert.equal(res5[0].toNumber(), web3.toWei(0.05));
assert.equal(res5[1].toNumber(), 3); // Owner
assert.equal(res5[2].toNumber(), 0); // Delegates
assert.equal(res5[3].toNumber(), 0); // Proposed Project
assert.equal(res5[4], 0); // commit time
assert.equal(res5[5].toNumber(), 2); // Old Node
assert.equal(res5[6].toNumber(), 0); // Not Paid
const res6 = await liquidPledging.getNote(6);
assert.equal(res6[0].toNumber(), web3.toWei(0.05));
assert.equal(res6[1].toNumber(), 3); // Owner
assert.equal(res6[2].toNumber(), 0); // Delegates
assert.equal(res6[3].toNumber(), 0); // Proposed Project
assert.equal(res6[4], 0); // commit time
assert.equal(res6[5].toNumber(), 2); // Old Node
assert.equal(res6[6].toNumber(), 1); // Peinding paid Paid
});
it("Should collect the Ether", async () => {
const initialBalance = await getBalance(web3, adminProject1);
await vault.confirmPayment(0);
const finalBalance = await getBalance(web3, adminProject1);
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
assert.equal(collected, 0.05);
const nNotes = await liquidPledging.numberOfNotes();
assert.equal(nNotes.toNumber(), 7);
const res7 = await liquidPledging.getNote(7);
assert.equal(res7[0].toNumber(), web3.toWei(0.05));
assert.equal(res7[1].toNumber(), 3); // Owner
assert.equal(res7[2].toNumber(), 0); // Delegates
assert.equal(res7[3].toNumber(), 0); // Proposed Project
assert.equal(res7[4], 0); // commit time
assert.equal(res7[5].toNumber(), 2); // Old Node
assert.equal(res7[6].toNumber(), 2); // Peinding paid Paid
});
it("Reviewer should be able to cancel project1", async () => {
await liquidPledging.cancelProject(3, {from: reviewer});
const st = await getState(liquidPledging);
assert.equal(st.managers[3].canceled , true);
});
it("Should not allow to withdraw from a canceled project", async () => {
const st = await getState(liquidPledging);
assert.equal(web3.fromWei(st.notes[5].amount).toNumber(), 0.05);
await assertFail(async function() {
await liquidPledging.withdraw(5, web3.toWei(0.01), {from: adminProject1});
});
});
it("Delegate should send part of this ETH to project2", async () => {
await liquidPledging.transfer(2, 5, web3.toWei(0.03), 4,{$extraGas: 100000}, {from: delegate1});
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 9);
assert.equal(web3.fromWei(st.notes[ 8 ].amount).toNumber(), 0.03);
assert.equal(st.notes[8].owner, 1);
assert.equal(st.notes[8].delegates.length, 1);
assert.equal(st.notes[8].delegates[0].id, 2);
assert.equal(st.notes[8].proposedProject, 4);
});
it("Donor should be able to send the remaining to project2", async () => {
await liquidPledging.transfer(1, 5, web3.toWei(0.02), 4, {from: donor1});
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 9);
assert.equal(web3.fromWei(st.notes[ 5 ].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.notes[ 4 ].amount).toNumber(), 0.12);
});
it("A subproject 2a and a delegate2 is created", async () => {
await liquidPledging.addProject("Project2a", reviewer, 86400, {from: adminProject2a});
await liquidPledging.addDelegate("Delegate2", {from: delegate2});
const nManagers = await liquidPledging.numberOfNoteManagers();
assert.equal(nManagers, 6);
});
it("Project 2 delegate in delegate2", async () => {
await liquidPledging.transfer(4, 4, web3.toWei(0.02), 6, {from: adminProject2});
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 10);
assert.equal(web3.fromWei(st.notes[ 9 ].amount).toNumber(), 0.02);
assert.equal(web3.fromWei(st.notes[ 4 ].amount).toNumber(), 0.1);
});
it("delegate2 assigns to projec2a", async () => {
await liquidPledging.transfer(6, 9, web3.toWei(0.01), 5, {from: delegate2});
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 11);
assert.equal(web3.fromWei(st.notes[ 9 ].amount).toNumber(), 0.01);
assert.equal(web3.fromWei(st.notes[ 10 ].amount).toNumber(), 0.01);
}).timeout(4000);
it("project2a authorize to spend a little", async () => {
const n = Math.floor(new Date().getTime() / 1000);
await liquidPledging.setMockedTime(n + 86401*3);
await liquidPledging.withdraw(10, web3.toWei(0.005), {from: adminProject2a});
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 13);
assert.equal(web3.fromWei(st.notes[ 10 ].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.notes[ 11 ].amount).toNumber(), 0.005);
assert.equal(web3.fromWei(st.notes[ 12 ].amount).toNumber(), 0.005);
}).timeout(4000);
it("project2 is canceled", async () => {
await liquidPledging.cancelProject(4, {from: reviewer});
});
it("project2 should not be able to confirm payment", async () => {
await assertFail(async function() {
await vault.confirmPayment(1);
});
});
it("Should not be able to withdraw it", async() => {
await assertFail(async function() {
await liquidPledging.withdraw(12, web3.toWei(0.005), {from: donor1});
});
});
it("Should not be able to cancel payment", async() => {
await vault.cancelPayment(1);
const st = await getState(liquidPledging);
assert.equal(st.notes.length, 13);
assert.equal(web3.fromWei(st.notes[ 2 ].amount).toNumber(), 0.31);
assert.equal(web3.fromWei(st.notes[ 11 ].amount).toNumber(), 0);
assert.equal(web3.fromWei(st.notes[ 12 ].amount).toNumber(), 0);
});
it("original owner should recover the remaining funds", async () => {
const st = await getState(liquidPledging);
await liquidPledging.withdraw(1, web3.toWei(0.5), {from: donor1});
await liquidPledging.withdraw(2, web3.toWei(0.31), {from: donor1});
await liquidPledging.withdraw(4, web3.toWei(0.1), {from: donor1});
await liquidPledging.withdraw(8, web3.toWei(0.03), {$extraGas: 100000}, {from: donor1});
await liquidPledging.withdraw(9, web3.toWei(0.01), {from: donor1});
const initialBalance = await getBalance(web3, donor1);
await vault.multiConfirm([2,3,4,5,6]);
const finalBalance = await getBalance(web3, donor1);
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
assert.equal(collected, 0.95);
}).timeout(8000);
const finalBalance = await getBalance(web3, donor1);
const collected = web3.fromWei(finalBalance.sub(initialBalance)).toNumber();
assert.equal(collected, 0.95);
}).timeout(8000);
});