Skip to content

Commit c49dc40

Browse files
jeissonijeissoni
committed
variables and functions are renamed
1 parent f441652 commit c49dc40

File tree

1 file changed

+102
-98
lines changed

1 file changed

+102
-98
lines changed

‎test/testETHPool.ts

+102-98
Original file line numberDiff line numberDiff line change
@@ -19,248 +19,252 @@ describe("test of ETHPools", function () {
1919
const [owner, user1, user2, user3, user4] = await ethers.getSigners();
2020
const ETHPoolFactory = await ethers.getContractFactory("ETHPool");
2121
const ETHPoolDeploy = await ETHPoolFactory.deploy();
22-
const ganaciasDepositadas: BigNumber = ethers.utils.parseEther("10")
22+
const earningsDeposited: BigNumber = ethers.utils.parseEther("10")
2323

2424

2525
return {
2626
owner,
2727
user1, user2, user3, user4,
2828
ETHPoolDeploy,
29-
ganaciasDepositadas
29+
earningsDeposited
3030
}
3131
}
3232

33-
describe("test funcionalidad del equipo", function () {
34-
it('La cuenta que despliega es la cuenta del equipo', async () => {
33+
describe("Test team options", function () {
34+
35+
it('The account you display is the team account', async () => {
3536
const { owner, user1, ETHPoolDeploy } = await dataETHPool()
3637

37-
const esOwnerEquipo: boolean = await ETHPoolDeploy.usuariosEquipo(owner.address)
38-
const esUser1Equipo: boolean = await ETHPoolDeploy.usuariosEquipo(user1.address)
38+
const isTeam: boolean = await ETHPoolDeploy.usersTeam(owner.address)
39+
const isUser: boolean = await ETHPoolDeploy.usersTeam(user1.address)
3940

40-
expect(esOwnerEquipo).to.equal(true)
41-
expect(esUser1Equipo).to.equal(false)
41+
expect(isTeam).to.equal(true)
42+
expect(isUser).to.equal(false)
4243
})
4344

44-
it('El equipo NO puede depositar antes de una semana', async () => {
45-
const { ETHPoolDeploy, ganaciasDepositadas } = await dataETHPool()
4645

47-
await expect(ETHPoolDeploy.depositarGananciasEquipo({ value: ganaciasDepositadas })).to.be.revertedWith("No ha pasado una semana!")
46+
it('The team CANNOT deposit before one week', async () => {
47+
const { ETHPoolDeploy, earningsDeposited } = await dataETHPool()
48+
49+
await expect(ETHPoolDeploy.depositRewardTeam({ value: earningsDeposited })).to.be.revertedWith("It hasn't been a week")
4850
})
4951

50-
it('El equipo SI puede depositar despues de una semana', async () => {
51-
const { ETHPoolDeploy, ganaciasDepositadas } = await dataETHPool()
52+
53+
it('The team can deposit after one week', async () => {
54+
const { ETHPoolDeploy, earningsDeposited } = await dataETHPool()
5255

5356
await ethers.provider.send("evm_increaseTime", [(60 * 60 * 24 * 7) + 1])
5457

55-
await ETHPoolDeploy.depositarGananciasEquipo({ value: ganaciasDepositadas })
58+
await ETHPoolDeploy.depositRewardTeam({ value: earningsDeposited })
5659

57-
const ganaciasContrato: BigNumber = await ETHPoolDeploy.totalRecompensa()
60+
const reward: BigNumber = await ETHPoolDeploy.totalReward()
5861

59-
expect(ganaciasDepositadas).to.equal(ganaciasContrato)
62+
expect(earningsDeposited).to.equal(reward)
6063
})
6164
})
6265

6366

64-
describe("test funcionalidad de usuarios", function () {
67+
describe("User functionality test", function () {
6568

6669

67-
describe("Depositar", function () {
68-
it("Se puede depositar por los usuarios", async () => {
70+
describe("Deposit", function () {
71+
it("Can be deposited by users", async () => {
6972

7073
const { user1, ETHPoolDeploy } = await dataETHPool()
7174

72-
const depositoUsuario: BigNumber = ethers.utils.parseEther("10")
75+
const userdeposit : BigNumber = ethers.utils.parseEther("10")
7376

74-
const antesTotalDepositosUsuarios = await ETHPoolDeploy.totalDepositosUsuarios()
77+
const beforeTotalUsersDeposites = await ETHPoolDeploy.totalUserDeposits()
7578

76-
const tx = await ETHPoolDeploy.connect(user1).depositarEthUsuario({ value: depositoUsuario })
79+
const tx = await ETHPoolDeploy.connect(user1).depositEthUser({ value: userdeposit })
7780

7881
const timestamp = (await ethers.provider.getBlock(tx.blockNumber)).timestamp;
7982

80-
var depositoUsuarioContrato = await ETHPoolDeploy.usuarios(user1.address)
83+
var depositUser = await ETHPoolDeploy.users(user1.address)
8184

82-
expect(depositoUsuarioContrato.deposito).to.equal(depositoUsuario)
83-
expect(depositoUsuarioContrato.fechaDeposito).to.equal(timestamp)
84-
expect(await ETHPoolDeploy.totalDepositosUsuarios()).to.equal(antesTotalDepositosUsuarios + depositoUsuario)
85+
expect(depositUser.deposit).to.equal(userdeposit)
86+
expect(depositUser.dateDeposit).to.equal(timestamp)
87+
expect(await ETHPoolDeploy.totalUserDeposits()).to.equal(userdeposit)
8588
})
8689
})
8790

8891

8992

90-
describe("Retirar", function () {
93+
describe("Withdra", function () {
9194

92-
it("Restringir si el usuario no ha depositado nada", async () => {
93-
const { owner, user1, ETHPoolDeploy, ganaciasDepositadas } = await dataETHPool()
95+
it("Restrict if user has not deposited anything", async () => {
96+
const { owner, user1, ETHPoolDeploy, earningsDeposited } = await dataETHPool()
9497

9598
await ethers.provider.send("evm_increaseTime", [(60 * 60 * 24 * 7) + 1])
96-
await ETHPoolDeploy.connect(owner).depositarGananciasEquipo({ value: ganaciasDepositadas })
99+
await ETHPoolDeploy.connect(owner).depositRewardTeam({ value: earningsDeposited })
97100

98-
await expect(ETHPoolDeploy.connect(user1).retirarDepositoMasGanancias()).to.be.revertedWith("EL usuarion no a depositado")
101+
await expect(ETHPoolDeploy.connect(user1).withdraw()).to.be.revertedWith("The user has not deposited")
99102
})
100103

101-
it("Entrega de depositos sin ganancias", async () => {
102-
const { user1, ETHPoolDeploy, ganaciasDepositadas } = await dataETHPool()
104+
it("Delivery of deposits without profit", async () => {
105+
const { user1, ETHPoolDeploy, earningsDeposited } = await dataETHPool()
103106

104-
//await ethers.provider.send("evm_increaseTime", [(60 * 60 * 24 * 1)])
105-
await ETHPoolDeploy.connect(user1).depositarEthUsuario({ value: ganaciasDepositadas })
107+
await ETHPoolDeploy.connect(user1).depositEthUser({ value: earningsDeposited })
106108

107-
var balanceUsurAntes = await ethers.provider.getBalance(user1.address)
109+
var balanceUsurBefore = await ethers.provider.getBalance(user1.address)
108110

109-
var tx = await ETHPoolDeploy.connect(user1).retirarDepositoMasGanancias()
111+
var tx = await ETHPoolDeploy.connect(user1).withdraw()
110112

111113
const gasUsed: BigNumber = (await tx.wait()).gasUsed
112114
const gasPrice: BigNumber = tx.gasPrice
113115
var gasCost: BigNumber = gasUsed.mul(gasPrice)
114116

115-
var balanceUsurDespues = await ethers.provider.getBalance(user1.address)
117+
var balanceUsurAfter = await ethers.provider.getBalance(user1.address)
116118

117-
expect(balanceUsurDespues).to.equal(balanceUsurAntes.add(ganaciasDepositadas).sub(gasCost))
119+
expect(balanceUsurAfter).to.equal(balanceUsurBefore.add(earningsDeposited).sub(gasCost))
118120

119121
})
120122

121-
122-
// prueba con 4 usuarios
123-
// recompensa por parte del equipo 10 eth
124-
// deposito por partde de los usuarios de manera aleatoria (entre 1 y 10 eth)
125-
it("Entrega de rendimientos con depositos aleatorios", async () => {
123+
// test with 4 users
124+
// reward from team 10 eth
125+
// I deposit by users randomly (between 1 and 10 eth)
126+
it("Delivering returns with random deposits", async () => {
126127
const { owner, user1, user2, user3, user4, ETHPoolDeploy } = await dataETHPool()
127128

128-
interface userDeposito {
129+
interface IuserDeposit {
129130
user: SignerWithAddress;
130131
value: BigNumber;
131132
}
132133

133134
const eth = ethers.constants.WeiPerEther;
134135

135-
var totalRecompensa: BigNumber = ethers.utils.parseEther("10")
136+
var totalReward: BigNumber = ethers.utils.parseEther("10")
136137

137-
var userDepositoArray: userDeposito[] = new Array();
138+
var userDepositArray: IuserDeposit[] = new Array();
138139

139140
var userArray: SignerWithAddress[] = [user1, user2, user3, user4]
140141

141-
var totalDespositoUsuario: BigNumber = ethers.constants.Zero;
142-
142+
var totalDespositUser: BigNumber = ethers.constants.Zero;
143143

144144

145-
// deposito de usuario, cantidad de ETH al azar
146-
// valor entre 1 y 10 ETH
145+
// user deposit, random amount of ETH
146+
// value between 1 and 10 ETH
147147
for (const item of userArray) {
148-
var depositoUsuario: BigNumber = ethers.utils.parseEther(
148+
var depositUser: BigNumber = ethers.utils.parseEther(
149149
getRandomArbitrary(1, 10).toString())
150150

151-
await ETHPoolDeploy.connect(item).depositarEthUsuario({
152-
value: depositoUsuario.toString()
151+
await ETHPoolDeploy.connect(item).depositEthUser({
152+
value: depositUser.toString()
153153
})
154154

155-
userDepositoArray.push({
155+
userDepositArray.push({
156156
user: item,
157-
value: depositoUsuario,
157+
value: depositUser,
158158
})
159159

160-
totalDespositoUsuario = totalDespositoUsuario.add(depositoUsuario)
160+
totalDespositUser = totalDespositUser.add(depositUser)
161161
}
162162

163163

164-
// deposito del la recompensa por parte del equipo
164+
165+
// deposit of the reward by the team
165166
await ethers.provider.send("evm_increaseTime", [(60 * 60 * 24 * 7) + 1])
166167

167-
await ETHPoolDeploy.connect(owner).depositarGananciasEquipo({
168-
value: totalRecompensa.toString()
168+
await ETHPoolDeploy.connect(owner).depositRewardTeam({
169+
value: totalReward.toString()
169170
})
170171

171172

172173

173-
// retiro de los usuarios
174-
for (const item of userDepositoArray) {
174+
// user withdrawal
175+
for (const item of userDepositArray) {
175176

176-
var porcentajePool: BigNumber = item.value.mul(eth).div(totalDespositoUsuario)
177+
var percentagePool: BigNumber = item.value.mul(eth).div(totalDespositUser)
177178

178-
var balanceUserAntes = await ethers.provider.getBalance(item.user.address)
179+
var balanceUserBefore = await ethers.provider.getBalance(item.user.address)
179180

180-
var ganaciasMasDeposito: BigNumber =
181-
item.value.add(totalRecompensa.mul(porcentajePool).div(eth))
181+
var earningsAndDeposit: BigNumber =
182+
item.value.add(totalReward.mul(percentagePool).div(eth))
182183

183-
var tx = await ETHPoolDeploy.connect(item.user).retirarDepositoMasGanancias()
184+
var tx = await ETHPoolDeploy.connect(item.user).withdraw()
184185

185-
totalDespositoUsuario = totalDespositoUsuario.sub(item.value)
186+
totalDespositUser = totalDespositUser.sub(item.value)
186187

187-
totalRecompensa = totalRecompensa.sub(totalRecompensa.mul(porcentajePool).div(eth))
188+
totalReward = totalReward.sub(totalReward.mul(percentagePool).div(eth))
188189

189190
const gasUsed: BigNumber = (await tx.wait()).gasUsed
190191
const gasPrice: BigNumber = tx.gasPrice
191192
var gasCost: BigNumber = gasUsed.mul(gasPrice)
192193

193-
var balanceUsuario = await ethers.provider.getBalance(item.user.address)
194+
var balanceUser = await ethers.provider.getBalance(item.user.address)
194195

195-
balanceUserAntes = balanceUserAntes.add(ganaciasMasDeposito.sub(gasCost))
196+
balanceUserBefore = balanceUserBefore.add(earningsAndDeposit.sub(gasCost))
196197

197-
expect(balanceUserAntes).to.equal(balanceUsuario)
198+
expect(balanceUserBefore).to.equal(balanceUser)
198199
}
199200

200201
})
201202

202-
it("Retiro de depositos sin ganancias", async () => {
203+
it("Withdrawal of deposits without profit", async () => {
203204
const { owner, user1, user2, ETHPoolDeploy } = await dataETHPool()
204205

205206

206-
var totalRecompensa: BigNumber = ethers.utils.parseEther("10")
207+
var totalReward: BigNumber = ethers.utils.parseEther("10")
207208

208-
// valor entre 1 y 10 ETH
209-
var depositoUsuario: BigNumber = ethers.utils.parseEther(
209+
// value between 1 and 10 ETH
210+
var depositUser: BigNumber = ethers.utils.parseEther(
210211
getRandomArbitrary(1, 10).toString())
211212
//------------------------------------------------------------
212213

213214

214-
//deposito usuario1
215-
await ETHPoolDeploy.connect(user1).depositarEthUsuario({
216-
value: depositoUsuario.toString()
215+
//deposit user1
216+
await ETHPoolDeploy.connect(user1).depositEthUser({
217+
value: depositUser.toString()
217218
})
218219
//------------------------------------------------------------
219220

220221

221-
// deposito del la recompensa por parte del equipo
222+
// deposit of the reward by the team
222223
await ethers.provider.send("evm_increaseTime", [(60 * 60 * 24 * 7) + 1])
223224

224-
await ETHPoolDeploy.connect(owner).depositarGananciasEquipo({
225-
value: totalRecompensa.toString()
225+
await ETHPoolDeploy.connect(owner).depositRewardTeam({
226+
value: totalReward.toString()
226227
})
227228
//------------------------------------------------------------
228229

229230

230-
//retiro usuario1
231-
//balance user1 - deposito - gas
232-
var balanceUsuario1Antes = await ethers.provider.getBalance(user1.address)
233-
var tx = await ETHPoolDeploy.connect(user1).retirarDepositoMasGanancias()
231+
//user1 withdrawal
232+
//balance user1 - deposit - gas
233+
234+
var balanceUser1Before = await ethers.provider.getBalance(user1.address)
235+
236+
var tx = await ETHPoolDeploy.connect(user1).withdraw()
234237
const gasUsedUser1: BigNumber = (await tx.wait()).gasUsed
235238
const gasPriceUser1: BigNumber = tx.gasPrice
236239
var gasCost: BigNumber = gasUsedUser1.mul(gasPriceUser1)
237240

238-
balanceUsuario1Antes = balanceUsuario1Antes.add(totalRecompensa).add(depositoUsuario).sub(gasCost)
239-
var balanceUsuario1Despues = await ethers.provider.getBalance(user1.address)
241+
balanceUser1Before = balanceUser1Before.add(totalReward).add(depositUser).sub(gasCost)
242+
243+
var balanceUser1After = await ethers.provider.getBalance(user1.address)
240244

241-
expect(balanceUsuario1Antes).to.equal(balanceUsuario1Despues)
245+
expect(balanceUser1Before).to.equal(balanceUser1After)
242246
//------------------------------------------------------------
243247

244248

245249

246-
//deposito usuario2
247-
await ETHPoolDeploy.connect(user2).depositarEthUsuario({
248-
value: depositoUsuario.toString()
250+
//deposit user2
251+
await ETHPoolDeploy.connect(user2).depositEthUser({
252+
value: depositUser.toString()
249253
})
250254
//------------------------------------------------------------
251255

252256

253-
//retiro usuario2
254-
var balanceUsuario2Antes = await ethers.provider.getBalance(user2.address)
255-
var tx = await ETHPoolDeploy.connect(user2).retirarDepositoMasGanancias()
257+
//user2 withdrawal
258+
var balanceUser2Before = await ethers.provider.getBalance(user2.address)
259+
var tx = await ETHPoolDeploy.connect(user2).withdraw()
256260
const gasUsedUser2: BigNumber = (await tx.wait()).gasUsed
257261
const gasPriceUser2: BigNumber = tx.gasPrice
258262
var gasCostUser2: BigNumber = gasUsedUser2.mul(gasPriceUser2)
259263

260-
var balanceUsuario2Despues = await ethers.provider.getBalance(user2.address)
261-
balanceUsuario2Antes = balanceUsuario2Antes.add(depositoUsuario).sub(gasCostUser2)
264+
var balanceUser2After = await ethers.provider.getBalance(user2.address)
265+
balanceUser2Before = balanceUser2Before.add(depositUser).sub(gasCostUser2)
262266

263-
expect(balanceUsuario2Antes).to.equal(balanceUsuario2Despues)
267+
expect(balanceUser2Before).to.equal(balanceUser2After)
264268
//------------------------------------------------------------
265269

266270

0 commit comments

Comments
 (0)