-
Notifications
You must be signed in to change notification settings - Fork 18
/
12_GovernanceData.js
147 lines (138 loc) · 5.18 KB
/
12_GovernanceData.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
const Governance = artifacts.require('Governance');
const GovernanceData = artifacts.require('GovernanceData');
const SimpleVoting = artifacts.require('SimpleVoting');
const catchRevert = require('../helpers/exceptions.js').catchRevert;
const encode = require('../helpers/encoder.js').encode;
const GBTStandardToken = artifacts.require('GBTStandardToken');
let gv;
let gd;
let sv;
let gbt;
contract('Governance Data', function([owner, taker]) {
before(function() {
Governance.deployed()
.then(function(instance) {
gv = instance;
return GovernanceData.deployed();
})
.then(function(instance) {
gd = instance;
return SimpleVoting.deployed();
})
.then(function(instance) {
sv = instance;
return GBTStandardToken.deployed();
})
.then(function(instance) {
gbt = instance;
});
});
it('Should create a proposal with solution', async function() {
this.timeout(100000);
let actionHash = encode(
'addNewMemberRole(bytes32,string,address,bool)',
'0x41647669736f727920426f617265000000000000000000000000000000000000',
'New member role',
owner,
false
);
p1 = await gd.getAllProposalIdsLengthByAddress(owner);
let amount = 50000000000000000000;
await gbt.lock('GOV', amount, 5468545613353456);
await gv.createProposalwithSolution(
'Add new member',
'Add new member',
'Addnewmember',
0,
1,
'Add new member',
actionHash
);
p2 = await gd.getAllProposalIdsLengthByAddress(owner);
assert.equal(p1.toNumber() + 1, p2.toNumber(), 'Proposal not created');
});
it('Should vote in favour of the proposal', async function() {
this.timeout(100000);
p = await gd.getAllProposalIdsLengthByAddress(owner);
p = p.toNumber();
await sv.proposalVoting(p, [1]);
await catchRevert(sv.proposalVoting(p, [1]));
});
it('Should close the proposal', async function() {
this.timeout(100000);
p = await gd.getAllProposalIdsLengthByAddress(owner);
p = p.toNumber();
await sv.closeProposalVote(p);
await catchRevert(sv.closeProposalVote(p));
});
it('Should check getters', async function() {
this.timeout(100000);
let g1 = await gd.constructorCheck();
let pl = await gd.getProposalLength();
let g3 = await gd.getVotingTypeDetailsById(0);
let g4 = await gd.callProposalVersionEvent(0, 0, 'yo', 0);
let g5 = await gd.getProposalDetailsById2(0);
let g6 = await gd.getProposalDetailsById3(0, owner);
let g7 = await gd.getProposalDetailsById6(0);
let g9 = await gd.getTotalProposalIncentive();
let g10 = await gd.getProposalVersion(0);
let g12 = await gd.getStatusOfProposals();
let g14 = await gd.getAllSolutionIdsByAddress(owner);
let g15 = await gd.getLatestVotingAddress();
await gd.storeProposalVersion(0, 'x');
await catchRevert(gd.governanceDataInitiate());
await gd.callReputationEvent(owner, 0, 'x', 1, '0x0');
assert.equal(g1, true, 'Not initialized');
// TODO verify the data returned
});
it('Should change member rep points', async function() {
this.timeout(100000);
await gd.changeMemberReputationPoints(20, 15);
let pop = await gd.addProposalOwnerPoints();
assert.equal(pop.toNumber(), 20, 'Member points not changed correctly');
await gd.changeProposalOwnerAdd(25);
pop = await gd.addProposalOwnerPoints();
assert.equal(pop.toNumber(), 25, 'Member points not changed correctly');
await gd.changeSolutionOwnerAdd(30);
pop = await gd.addSolutionOwnerPoints();
assert.equal(pop.toNumber(), 30, 'Member points not changed correctly');
});
it('Should set dApp supports locking', async function() {
this.timeout(100000);
await gd.setDAppTokenSupportsLocking(true);
assert.equal(
await gd.dAppTokenSupportsLocking(),
true,
'dAppTokenSupportsLocking not changed correctly'
);
});
it('Should pause unpause proposal', async function() {
this.timeout(100000);
await gd.toggleProposalPause(true, 0);
await gd.toggleProposalPause(true, 0);
let p1 = await gd.proposalPaused(0);
await gd.toggleProposalPause(false, 0);
let p2 = await gd.proposalPaused(0);
assert.notEqual(p1, p2, 'proposal not paused unpaused properly');
});
it('Should change parameters', async function() {
this.timeout(100000);
await gd.changeStakeWeight(20);
let param = await gd.stakeWeight();
assert.equal(param.toNumber(), 20, 'parameter changed correctly');
await gd.changeBonusStake(25);
param = await gd.bonusStake();
assert.equal(param.toNumber(), 25, 'parameter changed correctly');
await gd.changeReputationWeight(30);
param = await gd.reputationWeight();
assert.equal(param.toNumber(), 30, 'parameter changed correctly');
await gd.changeBonusReputation(20);
param = await gd.bonusReputation();
assert.equal(param.toNumber(), 20, 'parameter changed correctly');
await gd.changeQuorumPercentage(25);
param = await gd.quorumPercentage();
assert.equal(param.toNumber(), 25, 'parameter changed correctly');
await gd.setPunishVoters(true);
assert.equal(await gd.punishVoters(), true, 'parameter changed correctly');
});
});