gistfile1.txt

const DelegationProxy = artifacts.require("DelegationProxy.sol")
const MiniMeTokenFactory = artifacts.require("MiniMeTokenFactory.sol")
const MiniMeToken = artifacts.require("MiniMeToken.sol")
const TestUtils = require("./TestUtils.js")

/**
 * 
0x0000a5f7a9669e0db02a4294bf289e009710705d,0x000e3c6b3464fde97576340146675e1842fcb2f9,0x003063d3ab7b2b90654ce4041cca2b15fa8d2f65,0x003f93dafb3338dd7aaade51d595f63195a7f51f,0x004e21f0fb982434cfe8b4e96a71f73278319708,0x005bab06189b79583a9aa152fb17b9f072ace79a,0x006a3edf9855bb26bec23b52a158ba0ac14aaafa,0x0078ffa5da34554b5eec74ddad291466a26b0f11,0x00a329c0648769a73afac7f9381e08fb43dbea72,0x00c9c5cb7096de7262b09202867cacdb5fb2793c,0x00ce5d959c1a0501bf9caaf98ac2d6d9d3c00cd1,0x00d994ef966d2f3c2459acb968a344ef1dcd2629
*/

// TODO: This a very minimal set of tests purely for understanding the contract. I think they can be used though.
contract("DelegationProxy", accounts => {
    
    let delegationProxy
    const member = accounts[0]
    const member2 = accounts[1]
    const member3 = accounts[2]
    const member4 = accounts[3]
    const member5 = accounts[4]
    const member6 = accounts[5]
    const member7 = accounts[6]
    const member8 = accounts[7]
    const member9 = accounts[8]
    const member10 = accounts[9]
    const member11 = accounts[10]
    const member12 = accounts[11]

    const delegateTo = member2
    const delegateTo2 = member3
    const delegateTo3 = member4
    const delegateTo4 = member12
    const delegateTo5 = member12
    const delegateTo6 = member12
    const delegateTo7 = member6
    const delegateTo8 = member6
    const delegateTo9 = member11
    const delegateTo10 = member11
    const delegateTo11 = member
    const delegateTo12 = 0x0

    const delegateFromAccount = member
    const delegateToAccount = member2
    

    beforeEach(async () => {
        delegationProxy = await DelegationProxy.new(0)
    })

    describe("delegate(address _to)", () => {

        it("creates Delegate Log event", async () => {
            const tx = await delegationProxy.delegate(delegateToAccount, {from: delegateFromAccount})
            const delegateArgs = await TestUtils.listenForEvent(delegationProxy.Delegate())

            assert.equal(delegateArgs.who, delegateFromAccount, "Delegate Log shows delegating from isn't sender")
            assert.equal(delegateArgs.to, delegateToAccount, "Delegate Log shows delegating to isn't passed address")
        })

        it("updates delegations mapping with new delegate", async () => {
            const tx = await delegationProxy.delegate(delegateToAccount, {from: delegateFromAccount})
            const delegations = await delegationProxy.delegations(delegateFromAccount, 0)

            assert.equal(delegations[0], web3.eth.blockNumber, "Delegations block number is incorrect")
            assert.equal(delegations[1], delegateToAccount, "Delegations to account is incorrect")
            // TODO: The below is incorrect, delegations function needs completing
            assert.equal(delegations[2], 0, "Delegations toIndex is incorrect")

        })
    })

    describe("delegatedToAt(address _who, uint _block)", () => {

        it("returns correctly delegated to address", async () => {
            await delegationProxy.delegate(delegateToAccount, {from: delegateFromAccount})
            const delegatedTo = await delegationProxy.delegatedToAt.call(delegateFromAccount, web3.eth.blockNumber)

            assert.equal(delegatedTo, delegateToAccount, "Delegated to account is incorrect")
        })
    })

    describe("delegation chain test", () => {

        let miniMeTokenFactory, miniMeToken
        const accountBalance = 1000

        beforeEach(async () => {
            miniMeTokenFactory = await MiniMeTokenFactory.new()
            miniMeToken = await MiniMeToken.new(miniMeTokenFactory.address, 0, 0, "TestToken", 18, "TTN", true)
            miniMeToken.generateTokens(member, accountBalance)
            miniMeToken.generateTokens(member2, accountBalance)
            miniMeToken.generateTokens(member3, accountBalance)
            miniMeToken.generateTokens(member4, accountBalance)
            miniMeToken.generateTokens(member5, accountBalance)
            miniMeToken.generateTokens(member6, accountBalance)
            miniMeToken.generateTokens(member7, accountBalance)
            miniMeToken.generateTokens(member8, accountBalance)
            miniMeToken.generateTokens(member9, accountBalance)
            miniMeToken.generateTokens(member10, accountBalance)
            miniMeToken.generateTokens(member11, accountBalance)
            miniMeToken.generateTokens(member12, accountBalance)
            delegationProxy.delegate(delegateTo, {from: member})
            delegationProxy.delegate(delegateTo2, {from: member2})
            delegationProxy.delegate(delegateTo3, {from: member3})
            delegationProxy.delegate(delegateTo4, {from: member4})
            delegationProxy.delegate(delegateTo5, {from: member5})
            delegationProxy.delegate(delegateTo6, {from: member6})
            delegationProxy.delegate(delegateTo7, {from: member7})
            delegationProxy.delegate(delegateTo8, {from: member8})
            delegationProxy.delegate(delegateTo9, {from: member9})
            delegationProxy.delegate(delegateTo10, {from: member10})
            await delegationProxy.delegate(delegateTo11, {from: member11})
            //delegationProxy.delegate(delegateTo12, {from: member12})
        })

        it("returns expected amount of delegatedToAt", async () => {
            
            const delegatedTo = await delegationProxy.delegatedToAt(member, web3.eth.blockNumber)
            assert.equal(delegatedTo, delegateTo, "delegatedToAt(member is not as expected")
            
            const delegatedTo2 = await delegationProxy.delegatedToAt(member2, web3.eth.blockNumber)
            assert.equal(delegatedTo2, delegateTo2, "delegatedToAt(member2 is not as expected")
            
            const delegatedTo3 = await delegationProxy.delegatedToAt(member3, web3.eth.blockNumber)
            assert.equal(delegatedTo3, delegateTo3, "delegatedToAt(member3 is not as expected")

            const delegatedTo4 = await delegationProxy.delegatedToAt(member4, web3.eth.blockNumber)
            assert.equal(delegatedTo4, delegateTo4, "delegatedToAt(member4 is not as expected")

            const delegatedTo5 = await delegationProxy.delegatedToAt(member5, web3.eth.blockNumber)
            assert.equal(delegatedTo5, delegateTo5, "delegatedToAt(member5 is not as expected")

            const delegatedTo6 = await delegationProxy.delegatedToAt(member6, web3.eth.blockNumber)
            assert.equal(delegatedTo6, delegateTo6, "delegatedToAt(member6 is not as expected")

            const delegatedTo7 = await delegationProxy.delegatedToAt(member7, web3.eth.blockNumber)
            assert.equal(delegatedTo7, delegateTo7, "delegatedToAt(member7 is not as expected")

            const delegatedTo8 = await delegationProxy.delegatedToAt(member8, web3.eth.blockNumber)
            assert.equal(delegatedTo8, delegateTo8, "delegatedToAt(member8 is not as expected")

            const delegatedTo9 = await delegationProxy.delegatedToAt(member9, web3.eth.blockNumber)
            assert.equal(delegatedTo9, delegateTo9, "delegatedToAt(member9 is not as expected")

            const delegatedTo10 = await delegationProxy.delegatedToAt(member10, web3.eth.blockNumber)
            assert.equal(delegatedTo10, delegateTo10, "delegatedToAt(member10 is not as expected")

            const delegatedTo11 = await delegationProxy.delegatedToAt(member11, web3.eth.blockNumber)
            assert.equal(delegatedTo11, delegateTo11, "delegatedToAt(member11 is not as expected")

            const delegatedTo12 = await delegationProxy.delegatedToAt(member12, web3.eth.blockNumber)
            assert.equal(delegatedTo12, delegateTo12, "delegatedToAt(member12 is not as expected")
        })

        it("returns expected delegationOfAt", async () => {
            const delegationOf = await delegationProxy.delegationOfAt(member, web3.eth.blockNumber)
            assert.equal(delegationOf, member12, "delegationOfAt(member is not as expected")
            
            const delegationOf2 = await delegationProxy.delegationOfAt(member2, web3.eth.blockNumber)
            assert.equal(delegationOf2, member12, "delegationOfAt(member2 is not as expected")
            
            const delegationOf3 = await delegationProxy.delegationOfAt(member3, web3.eth.blockNumber)
            assert.equal(delegationOf3, member12, "delegationOfAt(member3 is not as expected")
            
            const delegationOf4 = await delegationProxy.delegationOfAt(member4, web3.eth.blockNumber)
            assert.equal(delegationOf4, member12, "delegationOfAt(member4 is not as expected")
            
            const delegationOf5 = await delegationProxy.delegationOfAt(member5, web3.eth.blockNumber)
            assert.equal(delegationOf5, member12, "delegationOfAt(member5 is not as expected")
            
            const delegationOf6 = await delegationProxy.delegationOfAt(member6, web3.eth.blockNumber)
            assert.equal(delegationOf6, member12, "delegationOfAt(member6 is not as expected")
            
            const delegationOf7 = await delegationProxy.delegationOfAt(member7, web3.eth.blockNumber)
            assert.equal(delegationOf7, member12, "delegationOfAt(member7 is not as expected")
            
            const delegationOf8 = await delegationProxy.delegationOfAt(member8, web3.eth.blockNumber)
            assert.equal(delegationOf8, member12, "delegationOfAt(member8 is not as expected")
            
            const delegationOf9 = await delegationProxy.delegationOfAt(member9, web3.eth.blockNumber)
            assert.equal(delegationOf9, member12, "delegationOfAt(member9 is not as expected")
            
            const delegationOf10 = await delegationProxy.delegationOfAt(member10, web3.eth.blockNumber)
            assert.equal(delegationOf10, member12, "delegationOfAt(member10 is not as expected")
            
            const delegationOf11 = await delegationProxy.delegationOfAt(member11, web3.eth.blockNumber)
            assert.equal(delegationOf11, member12, "delegationOfAt(member11 is not as expected")
            
            const delegationOf12 = await delegationProxy.delegationOfAt(member12, web3.eth.blockNumber)
            assert.equal(delegationOf12, member12, "delegationOfAt(member12 is not as expected")
            
        })
            
        it("returns expected delegatedInfluenceFromAt", async () => {

            const delegatedInfluence = await delegationProxy.delegatedInfluenceFromAt(member, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence.toNumber(), 3000, "delegatedInfluenceFrom(member is not as expected")
            
            const delegatedInfluence2 = await delegationProxy.delegatedInfluenceFromAt(member2, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence2.toNumber(), 4000, "delegatedInfluenceFrom(member2 is not as expected")
            
            const delegatedInfluence3 = await delegationProxy.delegatedInfluenceFromAt(member3, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence3.toNumber(), 5000, "delegatedInfluenceFrom(member3 is not as expected")
            
            const delegatedInfluence4 = await delegationProxy.delegatedInfluenceFromAt(member4, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence4.toNumber(), 6000, "delegatedInfluenceFrom(member4 is not as expected")
            
            const delegatedInfluence5 = await delegationProxy.delegatedInfluenceFromAt(member5, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence5.toNumber(), 0, "delegatedInfluenceFrom(member5 is not as expected")
            
            const delegatedInfluence6 = await delegationProxy.delegatedInfluenceFromAt(member6, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence6.toNumber(), 2000, "delegatedInfluenceFrom(member6 is not as expected")
            
            const delegatedInfluence7 = await delegationProxy.delegatedInfluenceFromAt(member7, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence7.toNumber(), 0, "delegatedInfluenceFrom(member7 is not as expected")
            
            const delegatedInfluence8 = await delegationProxy.delegatedInfluenceFromAt(member8, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence8.toNumber(), 0, "delegatedInfluenceFrom(member8 is not as expected")
            
            const delegatedInfluence9 = await delegationProxy.delegatedInfluenceFromAt(member9, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence9.toNumber(), 0, "delegatedInfluenceFrom(member9 is not as expected")
            
            const delegatedInfluence10 = await delegationProxy.delegatedInfluenceFromAt(member10, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence10.toNumber(), 0, "delegatedInfluenceFrom(member10 is not as expected")
            
            const delegatedInfluence11 = await delegationProxy.delegatedInfluenceFromAt(member11, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence11.toNumber(), 2000, "delegatedInfluenceFrom(member11 is not as expected")
            
            const delegatedInfluence12 = await delegationProxy.delegatedInfluenceFromAt(member12, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(delegatedInfluence12.toNumber(), 11000, "delegatedInfluenceFrom(member12 is not as expected")
        
        })
        
        it("returns expected influenceOfAt", async () => {

            const influence = await delegationProxy.influenceOfAt(member, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence.toNumber(), 0, "influenceOfAt(member is not as expected")
            
            const influence2 = await delegationProxy.influenceOfAt(member2, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence2.toNumber(), 0, "influenceOfAt(member2 is not as expected")
            
            const influence3 = await delegationProxy.influenceOfAt(member3, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence3.toNumber(), 0, "influenceOfAt(member3 is not as expected")
            
            const influence4 = await delegationProxy.influenceOfAt(member4, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence4.toNumber(), 0, "influenceOfAt(member4 is not as expected")
            
            const influence5 = await delegationProxy.influenceOfAt(member5, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence5.toNumber(), 0, "influenceOfAt(member5 is not as expected")
            
            const influence6 = await delegationProxy.influenceOfAt(member6, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence6.toNumber(), 0, "influenceOfAt(member6 is not as expected")
            
            const influence7 = await delegationProxy.influenceOfAt(member7, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence7.toNumber(), 0, "influenceOfAt(member7 is not as expected")
            
            const influence8 = await delegationProxy.influenceOfAt(member8, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence8.toNumber(), 0, "influenceOfAt(member8 is not as expected")
            
            const influence9 = await delegationProxy.influenceOfAt(member9, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence9.toNumber(), 0, "influenceOfAt(member9 is not as expected")
            
            const influence10 = await delegationProxy.influenceOfAt(member10, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence10.toNumber(), 0, "influenceOfAt(member10 is not as expected")
            
            const influence11 = await delegationProxy.influenceOfAt(member11, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence11.toNumber(), 0, "influenceOfAt(member11 is not as expected")
            
            const influence12 = await delegationProxy.influenceOfAt(member12, miniMeToken.address, web3.eth.blockNumber)
            assert.equal(influence12.toNumber(), 12000, "influenceOfAt(member12 is not as expected")
            
        })

    })
})