gmx-contracts/test/competition/Competition.js at e3769cf71806bfd7af37b9167c0a487e8abd81e5 · gmx-io/gmx-contracts · GitHub

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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
const { ADDRESS_ZERO } = require("@uniswap/v3-sdk")
const { expect, use } = require("chai")
const { solidity } = require("ethereum-waffle")
const { ethers } = require("hardhat")
const { deployContract } = require("../shared/fixtures")
const { getBlockTime, sleep } = require("../shared/utilities")

use(solidity)

const { keccak256 } = ethers.utils

describe("Competition", function () {
  const provider = waffle.provider
  const [wallet, user0, user1, user2, user3] = provider.getWallets()
  let contract
  let ts
  let referralStorage
  let code = keccak256("0xFF")

  async function getTeamMembers(index, addr)
  {
    let start = 0
    const offset = 100
    const result = []

    while (true) {
      let res = await contract.getTeamMembers(index, addr, start, offset)
      res = res.filter(addr => addr !== ADDRESS_ZERO)

      res.forEach(r => {
        result.push(r)
      })

      if (res.length < offset) {
        break;
      }
    }

    return result
  }

  beforeEach(async () => {
    ts = await getBlockTime(provider)
    referralStorage = await deployContract("ReferralStorage", [])
    contract = await deployContract("Competition", [referralStorage.address]);
    await referralStorage.registerCode(code)
    await contract.createCompetition(ts + 10, ts + 20, 10)
  })

  it("allows owner to create competition", async () => {
    await contract.connect(wallet).createCompetition(ts + 10, ts + 20, 10)
  })

  it("disable non owners to set competition details", async () => {
    await expect(contract.connect(user0).createCompetition(ts + 10, ts + 20, 10)).to.be.revertedWith("Governable: forbidden")
  })

  it("disable people to register teams after registration time", async () => {
    const ts = await getBlockTime(provider)
    await contract.connect(wallet).createCompetition(ts + 2, ts + 60, 10)
    await sleep(2000);
    await expect(contract.connect(user0).createTeam(1, "1", code)).to.be.revertedWith("Registration is closed.")
  })

  it("allows people to register teams in times", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
  })

  it("disable people to register multiple teams", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await expect(contract.connect(user0).createTeam(0, "2", code)).to.be.revertedWith("Team members are not allowed.")
  })

  it("disable people to register a team with non existing referral code", async () => {
    await expect(contract.connect(user0).createTeam(0, "1", keccak256("0xFE"))).to.be.revertedWith("Referral code does not exist.")
  })

  it("disable multiple teams with the same name", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await expect(contract.connect(user1).createTeam(0, "1", code)).to.be.revertedWith("Team name already registered.")
  })

  it("allows people to create join requests", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await contract.connect(user1).createJoinRequest(0, user0.address)
  })

  it("allows people to replace join requests", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await contract.connect(user1).createTeam(0, "2", code)
    await contract.connect(user2).createJoinRequest(0, user0.address)
    await contract.connect(user2).createJoinRequest(0, user1.address)
  })

  it("allow people to cancel join requests", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await contract.connect(user1).createJoinRequest(0, user0.address)
    await contract.connect(user1).cancelJoinRequest(0)
    await expect(contract.connect(user0).approveJoinRequest(0, user1.address)).to.be.revertedWith("This member did not apply.")
  })

  it("disable team members to create join requests", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await contract.connect(user1).createTeam(0, "2", code)
    await expect(contract.connect(user0).createJoinRequest(0, user1.address)).to.be.revertedWith("Team members are not allowed.")
  })

  it("allows team leaders to accept requests", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await contract.connect(user1).createJoinRequest(0, user0.address)
    await contract.connect(user0).approveJoinRequest(0, user1.address)
    const members = await getTeamMembers(0, user0.address)
    expect(members).to.include(user1.address)
  })

  it("disallow leaders to accept non existant join request", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await expect(contract.connect(user0).approveJoinRequest(0, user1.address)).to.be.revertedWith("This member did not apply.")
  })

  it("disallow leaders to accept members after registration time", async () => {
    const ts = await getBlockTime(provider)
    await contract.connect(wallet).createCompetition(ts + 2, ts + 10, 10)
    await sleep(2000)
    await expect(contract.connect(user0).createTeam(1, "1", code)).to.be.revertedWith("Registration is closed.")
  })

  it("allow leaders to kick members", async () => {
    await contract.connect(user0).createTeam(0, "1", code)
    await contract.connect(user1).createJoinRequest(0, user0.address)
    await contract.connect(user0).approveJoinRequest(0, user1.address)
    let members = await getTeamMembers(0, user0.address)
    expect(members).to.include(user1.address)
    await contract.connect(user0).removeMember(0, user1.address)
    members = await getTeamMembers(0, user0.address)
    expect(members).to.not.include(user1.address)
    await contract.connect(user1).createJoinRequest(0, user0.address)
  })

  it("allow owner to change competition", async () => {
    await contract.connect(wallet).updateCompetition(0, ts + 60, ts + 12, 5);
  })

  it("disallow non owners to change competition", async () => {
    await expect(contract.connect(user0).updateCompetition(0, ts + 60, ts + 12, 5)).to.be.revertedWith("Governable: forbidden")
  })

  it("disallow leader to accept join request if team is full", async () => {
    const ts = await getBlockTime(provider)

    await contract.connect(wallet).updateCompetition(0, ts + 10, ts + 20, 3)
    await contract.connect(user0).createTeam(0, "1", code)

    await contract.connect(user1).createJoinRequest(0, user0.address)
    await contract.connect(user0).approveJoinRequest(0, user1.address)

    await contract.connect(user2).createJoinRequest(0, user0.address)
    await contract.connect(user0).approveJoinRequest(0, user2.address)

    await contract.connect(user3).createJoinRequest(0, user0.address)
    await expect(contract.connect(user0).approveJoinRequest(0, user3.address)).to.be.revertedWith("Team is full.")
  })
});