status-im
/
StandardBounties
mirror of https://github.com/status-im/StandardBounties.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
StandardBounties/test/standardBountyMany.js

562 lines
22 KiB
JavaScript
Raw Blame History

const StandardBounties = artifacts.require("../contracts/StandardBounties");
const HumanStandardToken = artifacts.require("../contracts/inherited/HumanStandardToken");
const utils = require('./helpers/Utils');
contract('StandardBounties', function(accounts) {
it("[ETH] Verifies that I can issue new bounties paying in ETH", async () => {
let registry = await StandardBounties.new(accounts[0]);
for (var i = 0; i < 100; i++){
await registry.issueBounty(0xF633f5bAf5954eE8F357055FE5151DDc27EEfdBF,
2528821098,
"data"+i,
1000,
0x0,
false,
0x0,{from: accounts[0]});
let data = await registry.getBountyData(i);
assert(data == ("data"+i));
}
});
it("[TOKENS] Verifies that I can issue new bounties paying in Tokens", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT");
for (var i = 0; i < 100; i++){
await registry.issueBounty(0xF633f5bAf5954eE8F357055FE5151DDc27EEfdBF,
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[0]});
let data = await registry.getBountyData(i);
assert(data == ("data"+i));
}
});
it("[BOTH] Verifies that I can issue new bounties paying in both ETH and Tokens", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT");
for (var i = 0; i < 100; i++){
if (i % 2){
await registry.issueBounty(0xF633f5bAf5954eE8F357055FE5151DDc27EEfdBF,
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address, {from: accounts[0]});
let data = await registry.getBountyData(i);
let bounty = await registry.getBounty(i);
let tokenAddress = await registry.getBountyToken(i);
assert(bounty[3] == true);
assert(tokenAddress == bountyToken.address)
assert(data == ("data"+i));
} else {
await registry.issueBounty(0xF633f5bAf5954eE8F357055FE5151DDc27EEfdBF,
2528821098,
"data"+i,
1000,
0x0,
false,
0x0, {from: accounts[0]});
let data = await registry.getBountyData(i);
let bounty = await registry.getBounty(i);
let tokenAddress = await registry.getBountyToken(i);
assert(bounty[3] == false);
assert(tokenAddress == "0x0000000000000000000000000000000000000000")
assert(data == ("data"+i));
}
}
});
it("[BOTH] Verifies that I can issue new bounties and retreive them as needed", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT");
for (var i = 0; i < 100; i++){
if (i % 2){
await registry.issueBounty(0xF633f5bAf5954eE8F357055FE5151DDc27EEfdBF,
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address, {from: accounts[0]});
let data = await registry.getBountyData(i);
let bounty = await registry.getBounty(i);
let tokenAddress = await registry.getBountyToken(i);
let total = await registry.getNumBounties();
assert(bounty[3] == true);
assert(tokenAddress == bountyToken.address)
assert(data == ("data"+i));
assert(total == (i+1));
} else {
await registry.issueBounty(0xF633f5bAf5954eE8F357055FE5151DDc27EEfdBF,
2528821098,
"data"+i,
1000,
0x0,
false,
0x0, {from: accounts[0]});
let data = await registry.getBountyData(i);
let bounty = await registry.getBounty(i);
let tokenAddress = await registry.getBountyToken(i);
let total = await registry.getNumBounties();
assert(bounty[3] == false);
assert(tokenAddress == "0x0000000000000000000000000000000000000000")
assert(data == ("data"+i));
assert(total == (i+1));
}
}
});
it("[BOTH] Verifies that I can issue, activate, fulfill, accept, and pay out new bounties paying in both ETH and Tokens", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
for (var i = 0; i < 100; i++){
if (i % 2){
await registry.issueBounty(accounts[0],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[0]});
await bountyToken.approve(registry.address, 1000, {from: accounts[0]});
await registry.activateBounty(i,1000, {from: accounts[0]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.acceptFulfillment(i,0,{from: accounts[0]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
} else {
await registry.issueBounty(accounts[0],
2528821098,
"data"+i,
1000,
0x0,
false,
0x0,{from: accounts[0]});
await registry.activateBounty(i,1000, {from: accounts[0], value: 1000});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.fulfillBounty(i, "data", {from: accounts[1]});
await registry.acceptFulfillment(i,0,{from: accounts[0]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
}
}
});
it("[BOTH] Verifies that I can issue, activate, fulfill many times, accept, and pay out new bounties paying in both ETH and Tokens", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
for (var i = 0; i < 10; i++){
if (i % 2){
await registry.issueBounty(accounts[0],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[0]});
await bountyToken.approve(registry.address, 1000, {from: accounts[0]});
await registry.activateBounty(i,1000, {from: accounts[0]});
for (var j = 0; j < 50; j++){
await registry.fulfillBounty(i, "data", {from: accounts[1]});
var numFul = await registry.getNumFulfillments(i);
assert(numFul == (j+1));
}
var random = Math.floor(Math.random() * 49);
await registry.acceptFulfillment(i,random,{from: accounts[0]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
} else {
await registry.issueBounty(accounts[0],
2528821098,
"data"+i,
1000,
0x0,
false,
0x0,{from: accounts[0]});
await registry.activateBounty(i,1000, {from: accounts[0], value: 1000});
for (var j = 0; j < 50; j++){
await registry.fulfillBounty(i, "data", {from: accounts[1]});
var numFul = await registry.getNumFulfillments(i);
assert(numFul == (j+1));
}
var random = Math.floor(Math.random() * 49);
await registry.acceptFulfillment(i,random,{from: accounts[0]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
}
}
});
it("[BOTH] Verifies that I can issue, activate, fulfill, accept, and pay out new bounties paying in both ETH and Tokens from various addresses, with various token contracts", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
await bountyToken.transfer(accounts[1], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[2], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[3], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[4], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[5], 100000000, {from: accounts[0]});
let bountyToken2 = await HumanStandardToken.new(1000000000, "Bounty Token2", 18, "BOUNT2", {from: accounts[0]});
await bountyToken2.transfer(accounts[1], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[2], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[3], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[4], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[5], 100000000, {from: accounts[0]});
for (var i = 0; i < 100; i++){
if (i % 2){
if (i % 4){
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[(i%5)]});
await bountyToken.approve(registry.address, 1000, {from: accounts[(i%5)]});
await registry.activateBounty(i,1000, {from: accounts[(i%5)]});
await registry.fulfillBounty(i, "data", {from: accounts[(i%5)+1]});
await registry.acceptFulfillment(i,0,{from: accounts[(i%5)]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
} else {
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken2.address,{from: accounts[(i%5)]});
await bountyToken.approve(registry.address, 1000, {from: accounts[(i%5)]});
await registry.activateBounty(i,1000, {from: accounts[(i%5)]});
await registry.fulfillBounty(i, "data", {from: accounts[(i%5)+1]});
await registry.acceptFulfillment(i,0,{from: accounts[(i%5)]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
}
} else {
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
false,
0x0,{from: accounts[(i%5)]});
await registry.activateBounty(i,1000, {from: accounts[(i%5)], value: 1000});
await registry.fulfillBounty(i, "data", {from: accounts[(i%5)+1]});
await registry.acceptFulfillment(i,0,{from: accounts[(i%5)]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
}
}
let balance1 = await bountyToken.balanceOf(registry.address);
assert(balance1 == 0);
let balance2 = await bountyToken2.balanceOf(registry.address);
assert(balance2 == 0);
let balance3 = await web3.eth.getBalance(registry.address);
assert(balance3 == 0);
});
it("[BOTH] Verifies that I can't edit someone else's bounty", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
await bountyToken.transfer(accounts[1], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[2], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[3], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[4], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[5], 100000000, {from: accounts[0]});
for (var i = 0; i < 100; i++){
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[0]});
if(i !== 0){
try {
await registry.transferIssuer((i-1), accounts[(i%5)], {from: accounts[(i%5)]});
} catch (error){
return utils.ensureException(error);
}
}
}
});
it("[TOKENS] Verifies that accessing an out of bounds bountyId fails", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
for (var i = 0; i < 10; i++){
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[0]});
}
try {
await registry.transferIssuer(10, accounts[0], {from: accounts[0]});
} catch (error){
return utils.ensureException(error);
}
});
it("[ETH] Verifies that accessing an out of bounds fulfillmentId fails", async () => {
let registry = await StandardBounties.new(accounts[0]);
await registry.issueBounty(accounts[0],
2528821098,
"data",
1000,
0x0,
false,
0x0,{from: accounts[0]});
await registry.activateBounty(0 ,1000, {from: accounts[0], value: 1000});
await registry.fulfillBounty(0, "data1", {from: accounts[1]});
await registry.fulfillBounty(0, "data2", {from: accounts[2]});
await registry.fulfillBounty(0, "data3", {from: accounts[3]});
await registry.fulfillBounty(0, "data4", {from: accounts[4]});
try {
await registry.acceptFulfillment(0,4,{from: accounts[0]});
} catch (error){
return utils.ensureException(error);
}
});
it("[TOKENS] Verifies that accessing an out of bounds fulfillmentId fails", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
await registry.issueBounty(accounts[0],
2528821098,
"data",
1000,
0x0,
true,
bountyToken.address,{from: accounts[0]});
await bountyToken.approve(registry.address, 1000, {from: accounts[0]});
await registry.activateBounty(0 ,1000, {from: accounts[0]});
await registry.fulfillBounty(0, "data1", {from: accounts[1]});
await registry.fulfillBounty(0, "data2", {from: accounts[2]});
await registry.fulfillBounty(0, "data3", {from: accounts[3]});
await registry.fulfillBounty(0, "data4", {from: accounts[4]});
try {
await registry.acceptFulfillment(0,4,{from: accounts[0]});
} catch (error){
return utils.ensureException(error);
}
});
it("[BOTH] Verifies that I can issue, activate, fulfill, accept, and pay out new bounties paying in both ETH and Tokens from various addresses, with various token contracts, with several fulfillments", async () => {
let registry = await StandardBounties.new(accounts[0]);
let bountyToken = await HumanStandardToken.new(1000000000, "Bounty Token", 18, "BOUNT", {from: accounts[0]});
await bountyToken.transfer(accounts[1], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[2], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[3], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[4], 100000000, {from: accounts[0]});
await bountyToken.transfer(accounts[5], 100000000, {from: accounts[0]});
let bountyToken2 = await HumanStandardToken.new(1000000000, "Bounty Token2", 18, "BOUNT2", {from: accounts[0]});
await bountyToken2.transfer(accounts[1], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[2], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[3], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[4], 100000000, {from: accounts[0]});
await bountyToken2.transfer(accounts[5], 100000000, {from: accounts[0]});
for (var i = 0; i < 100; i++){
if (i % 2){
if (i % 4){
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken.address,{from: accounts[(i%5)]});
await bountyToken.approve(registry.address, 3000, {from: accounts[(i%5)]});
await registry.activateBounty(i,3000, {from: accounts[(i%5)]});
await registry.fulfillBounty(i, "data", {from: accounts[(i%5)+1]});
await registry.fulfillBounty(i, "data2", {from: accounts[(i%5)+2]});
await registry.fulfillBounty(i, "data3", {from: accounts[(i%5)+3]});
await registry.acceptFulfillment(i,0,{from: accounts[(i%5)]});
await registry.acceptFulfillment(i,1,{from: accounts[(i%5)]});
await registry.acceptFulfillment(i,2,{from: accounts[(i%5)]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
} else {
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
true,
bountyToken2.address,{from: accounts[(i%5)]});
await bountyToken.approve(registry.address, 3000, {from: accounts[(i%5)]});
await registry.activateBounty(i,3000, {from: accounts[(i%5)]});
await registry.fulfillBounty(i, "data", {from: accounts[(i%5)+1]});
await registry.fulfillBounty(i, "data2", {from: accounts[(i%5)+2]});
await registry.fulfillBounty(i, "data3", {from: accounts[(i%5)+3]});
await registry.acceptFulfillment(i,0,{from: accounts[(i%5)]});
await registry.acceptFulfillment(i,1,{from: accounts[(i%5)]});
await registry.acceptFulfillment(i,2,{from: accounts[(i%5)]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
}
} else {
await registry.issueBounty(accounts[(i%5)],
2528821098,
"data"+i,
1000,
0x0,
false,
0x0,{from: accounts[(i%5)]});
await registry.activateBounty(i,3000, {from: accounts[(i%5)], value: 3000});
await registry.fulfillBounty(i, "data", {from: accounts[(i%5)+1]});
await registry.fulfillBounty(i, "data2", {from: accounts[(i%5)+2]});
await registry.fulfillBounty(i, "data3", {from: accounts[(i%5)+3]});
await registry.acceptFulfillment(i,0,{from: accounts[(i%5)]});
await registry.acceptFulfillment(i,1,{from: accounts[(i%5)]});
await registry.acceptFulfillment(i,2,{from: accounts[(i%5)]});
var bounty = await registry.getBounty(i);
assert(bounty[5] == 0);
}
}
let balance1 = await bountyToken.balanceOf(registry.address);
assert(balance1 == 0);
let balance2 = await bountyToken2.balanceOf(registry.address);
assert(balance2 == 0);
let balance3 = await web3.eth.getBalance(registry.address);
assert(balance3 == 0);
});
});
Reference in New Issue View Git Blame Copy Permalink