topic-democracy/test/messageTribute.js

const TestUtils = require("../utils/testUtils.js");

describe('MessageTribute', function() {

    let accounts;
    let SNT;

    const secret = "0x0000000000000000000000000000000000000000000000000000000000123456";

    this.timeout(0);

    before( function(done) {
        this.timeout(0);

        EmbarkSpec.deployAll({
                "MiniMeTokenFactory": {},
                "MiniMeToken": {
                    "args": [
                        "$MiniMeTokenFactory",
                        "0x0",
                        "0x0",
                        "Status Test Token",
                        18,
                        "STT",
                        true
                        ]
                },
                "MessageTribute": {
                    "args": ["$MiniMeToken"]
                }
            }, (_accounts) => { 
            accounts = _accounts;  

            SNT = MiniMeToken;

            Promise.all([
                SNT.methods.generateTokens(accounts[0], 5000).send(),
                SNT.methods.generateTokens(accounts[1], 5000).send(),
                SNT.methods.generateTokens(accounts[2], 5000).send(),
                SNT.methods.generateTokens(accounts[3], 5000).send(),
                SNT.methods.generateTokens(accounts[4], 5000).send(),
                SNT.methods.generateTokens(accounts[5], 5000).send(),
                SNT.methods.generateTokens(accounts[6], 5000).send(),
                SNT.methods.generateTokens(accounts[7], 5000).send(),
                SNT.methods.generateTokens(accounts[8], 5000).send(),
                SNT.methods.generateTokens(accounts[9], 5000).send()
            ])
            .then(() => {
                console.log("  - Added balances");
                done();
            });
        });
    });
    
    it("Adding friends", async () => {
        await MessageTribute.methods.addFriends([accounts[1], accounts[2]]).send({from: accounts[0]});
        await MessageTribute.methods.addFriends([accounts[3]]).send({from: accounts[1]});
        await MessageTribute.methods.addFriends([accounts[4]]).send({from: accounts[1]});
        await MessageTribute.methods.addFriends([accounts[5]]).send({from: accounts[1]});

        assert.equal(
            await MessageTribute.methods.areFriends(accounts[0], accounts[1]).call(),
            true,
            "1. " + accounts[1] + " must be a friend of " + accounts[0]);

        assert.equal(
            await MessageTribute.methods.areFriends(accounts[1], accounts[3]).call(),
            true,
            "2. " + accounts[3] + " must be a friend of " + accounts[1]);

        assert.equal(
            await MessageTribute.methods.areFriends(accounts[0], accounts[4]).call(),
            false,
            "3. " + accounts[4] + " must not be a friend of " + accounts[0]);

        assert.equal(
            await MessageTribute.methods.areFriends(accounts[1], accounts[2]).call(),
            false,
            "4. " + accounts[2] + " must not be a friend of " + accounts[1]);

    });

    it("Removing friends", async () => {
        await MessageTribute.methods.removeFriends([accounts[3]]).send({from: accounts[1]});
        
        await MessageTribute.methods.removeFriends([accounts[4], accounts[5]]).send({from: accounts[1]});

        assert.equal(
            await MessageTribute.methods.areFriends(accounts[0], accounts[3]).call(),
            false,
            accounts[3] + " must not be a friend of " + accounts[0]);
        
        assert.equal(
            await MessageTribute.methods.areFriends(accounts[0], accounts[4]).call(),
            false,
            accounts[4] + " must not be a friend of " + accounts[0]);

        try {
            let tx = await MessageTribute.methods.removeFriends([accounts[5]]).send({from: accounts[1]});
            assert.fail('should have reverted before');
        } catch(error) {
            TestUtils.assertJump(error);
        }
    });

    it("Should be able to deposit", async() => {
        let amount = 2000;

        await SNT.methods.approve(MessageTribute.address, amount).send({from: accounts[1]});
        
        let initialBalance = await SNT.methods.balanceOf(accounts[1]).call();

        await MessageTribute.methods.deposit(amount).send({from: accounts[1]});

        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[1]}),
            amount,
            "Deposited balance must be " + amount); 

        assert.equal(
            await SNT.methods.balanceOf(accounts[1]).call(),
            web3.utils.toBN(initialBalance).sub(web3.utils.toBN(amount)).toString(),
            accounts[1] + " SNT balance is incorrect"); 

        assert.equal(
            await SNT.methods.balanceOf(MessageTribute.address).call(),
            amount,
            "Contract SNT balance is incorrect");

    });

    it("Should be able to withdraw", async() => {
        let amount = 2000;

        let initialBalance = await SNT.methods.balanceOf(accounts[1]).call();

        await MessageTribute.methods.withdraw(amount).send({from: accounts[1]});
        
        assert.equal(
            await SNT.methods.balanceOf(accounts[1]).call(),
            web3.utils.toBN(initialBalance).add(web3.utils.toBN(amount)).toString(),
            "SNT Balance must be " + initialBalance + amount); 

        assert.equal(
            await SNT.methods.balanceOf(MessageTribute.address).call(),
            0,
            "Contract SNT balance is incorrect");
        
        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[1]}),
            0,
            "Deposited balance must be 0"); 
        
    });

    it("Requesting audience without requiring deposit", async () => {
        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[9]}),
            0,
            "Deposited balance must be 0"); 

        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[9], secret);

        let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[9]});

        assert.notEqual(tx.events.AudienceRequested, undefined, "AudienceRequested wasn't triggered");

    });

    it("Requesting audience requiring deposit and no funds deposited", async () => {
        await MessageTribute.methods.setRequiredTribute(accounts[9], 100, false, true).send({from: accounts[0]});
        
        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[9]}),
            0,
            "Deposited balance must be 0"); 

        assert.equal(
            await MessageTribute.methods.hasEnoughFundsToTalk(accounts[0]).call({from: accounts[9]}),
            false,
            "Must return false");

        try {
            let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[9], secret);

            let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[9]});
            assert.fail('should have reverted before');
        } catch(error) {
            TestUtils.assertJump(error);
        }
    });

    it("Requesting an audience as a friend", async() => {
       assert.equal(
        await MessageTribute.methods.areFriends(accounts[0], accounts[2]).call(),
        true,
        "Should be friends"); 

        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[2]}),
            0,
            "Deposited balance must be 0"); 

        assert.equal(
            await MessageTribute.methods.hasEnoughFundsToTalk(accounts[0]).call({from: accounts[2]}),
            true,
            "Must return true");

        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[2], secret);

        let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[2]});
        
        assert.notEqual(tx.events.AudienceRequested, undefined, "AudienceRequested wasn't triggered");
    });


    it("Request audience requiring deposit, not having funds at the beginning, deposit funds and request audience", async () => {
        await MessageTribute.methods.setRequiredTribute(accounts[8], 200, false, true).send({from: accounts[0]});
        
        await SNT.methods.approve(MessageTribute.address, 100).send({from: accounts[8]});
        await MessageTribute.methods.deposit(100).send({from: accounts[8]});

        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[8]}),
            100,
            "Deposited balance must be 100"); 

        assert.equal(
            await MessageTribute.methods.hasEnoughFundsToTalk(accounts[0]).call({from: accounts[8]}),
            false,
            "Must return false");

        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[2], secret);
        
        try {
            let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[8]});
            assert.fail('should have reverted before');
        } catch(error) {
            TestUtils.assertJump(error);
        }

        await SNT.methods.approve(MessageTribute.address, 100).send({from: accounts[8]});
        await MessageTribute.methods.deposit(100).send({from: accounts[8]});

        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[8]}),
            200,
            "Deposited balance must be 200"); 

        assert.equal(
            await MessageTribute.methods.hasEnoughFundsToTalk(accounts[0]).call({from: accounts[8]}),
            true,
            "Must return true");
        
        let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[8]});
    
        assert.notEqual(tx.events.AudienceRequested, undefined, "AudienceRequested wasn't triggered");
    });


    it("Requesting tribute from specific account", async() => {
        await MessageTribute.methods.setRequiredTribute(accounts[7], 100, true, true).send({from: accounts[0]});
        
        await SNT.methods.approve(MessageTribute.address, 200).send({from: accounts[7]});
        await MessageTribute.methods.deposit(200).send({from: accounts[7]});

        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[7]}),
            200,
            "Deposited balance must be 200"); 

        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[7], secret);

        let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[7]});
        
        assert.notEqual(tx.events.AudienceRequested, undefined, "AudienceRequested wasn't triggered");
    
        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[7]}),
            100,
            "Deposited balance must be 100"); 
     });

     it("Cancelling an audience", async() => {
        
        assert.equal(
            await MessageTribute.methods.hasPendingAudience(accounts[0], accounts[8]).call(),
            true,
            "Must have a pending audience");

        // Commented because it requires moving the evm timestamp, and current version of testrpc seems to not support it
        /*
        let tx = await MessageTribute.methods.cancelAudienceRequest(accounts[0]).send({from: accounts[8]});

        assert.notEqual(tx.events.AudienceCancelled, undefined, "AudienceCancelled wasn't triggered");

        assert.equal(
            await MessageTribute.methods.hasPendingAudience(accounts[0]).call({from: accounts[8]}),
            false,
            "Must not have a pending audience");
        */

     });

     it("Cancelling an audience without having one", async() => {
        
        assert.equal(
            await MessageTribute.methods.hasPendingAudience(accounts[0], accounts[6]).call(),
            false,
            "Must not have a pending audience");

        try {
            let tx = await MessageTribute.methods.cancelAudienceRequest(accounts[0]).send({from: accounts[6]});
            assert.fail('should have reverted before');
        } catch(error) {
            TestUtils.assertJump(error);
        }
     });

     it("Granting an audience that requires a permanent tribute", async() => {
        
        let initial7balance = (await SNT.methods.balanceOf(accounts[7]).call()).toString();
        let initial0balance = (await SNT.methods.balanceOf(accounts[0]).call()).toString();
        let initialCBalance = (await SNT.methods.balanceOf(MessageTribute.address).call()).toString();
        let initial7DepBalance = (await MessageTribute.methods.balance().call({from: accounts[7]})).toString();
        let amount = (await MessageTribute.methods.getRequiredFee(accounts[0]).call({from: accounts[7]})).fee.toString();
     
        assert.equal(
            await MessageTribute.methods.hasPendingAudience(accounts[0], accounts[7]).call(),
            true,
            "Must have a pending audience");
        
        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[7], secret);
        
        let tx = await MessageTribute.methods.grantAudience(accounts[7], true, secret).send({from: accounts[0]});

        assert.notEqual(tx.events.AudienceGranted, undefined, "AudienceGranted wasn't triggered");

        assert.equal(
            await SNT.methods.balanceOf(accounts[7]).call(),
            initial7balance,
            accounts[7] + " SNT Balance must be " + initial7balance); 

        assert.equal(
            await SNT.methods.balanceOf(accounts[0]).call(),
            web3.utils.toBN(initial0balance).add(web3.utils.toBN(amount)).toString(),
            accounts[0] + "SNT Balance must be " + initial0balance); 

        assert.equal(
            await SNT.methods.balanceOf(MessageTribute.address).call(),
            web3.utils.toBN(initialCBalance).sub(web3.utils.toBN(amount)).toString(),
            accounts[0] + "SNT Balance must be " + web3.utils.toBN(initialCBalance).sub(web3.utils.toBN(amount)).toString());

        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[7]}),
            initial7DepBalance,
            accounts[0] + "SNT deposit balance must be 0");

        assert.equal(
            await MessageTribute.methods.hasPendingAudience(accounts[0], accounts[7]).call(),
            false,
            "Must not have a pending audience");
     });

     it("Denying an audience", async() => {

        let amount = (await MessageTribute.methods.getRequiredFee(accounts[0]).call({from: accounts[7]})).fee.toString();

        let initial7DepBalance = (await MessageTribute.methods.balance().call({from: accounts[7]})).toString();

        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[7], secret);

        let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[7]});

        let afterReq7DepBalance = (await MessageTribute.methods.balance().call({from: accounts[7]})).toString();
        
        assert.equal(
            afterReq7DepBalance,
            web3.utils.toBN(initial7DepBalance).sub(web3.utils.toBN(amount)).toString(),
            accounts[7] + "SNT deposit balance error");

        assert.notEqual(tx.events.AudienceRequested, undefined, "AudienceRequested wasn't triggered");
    
        let tx2 = await MessageTribute.methods.grantAudience(accounts[7], false, secret).send({from: accounts[0]});

        assert.notEqual(tx2.events.AudienceGranted, undefined, "AudienceGranted wasn't triggered");

        let afterDeny7DepBalance = (await MessageTribute.methods.balance().call({from: accounts[7]})).toString();
        
        assert.equal(
            initial7DepBalance,
            afterDeny7DepBalance,
            accounts[7] + "SNT deposit balance error");

        assert.equal(
                await MessageTribute.methods.hasPendingAudience(accounts[0], accounts[7]).call(),
                false,
                "Must not have a pending audience");
     });
     
     it("Requesting a non permanent tribute from specific account", async() => {
        await MessageTribute.methods.setRequiredTribute(accounts[6], 100, true, false).send({from: accounts[0]});
        let amount1 = (await MessageTribute.methods.getRequiredFee(accounts[0]).call({from: accounts[6]})).fee.toString();
        
        await SNT.methods.approve(MessageTribute.address, 200).send({from: accounts[6]});
        await MessageTribute.methods.deposit(200).send({from: accounts[6]});

        let hashedSecret = web3.utils.soliditySha3(accounts[0], accounts[6], secret);
        
        let tx = await MessageTribute.methods.requestAudience(accounts[0], hashedSecret).send({from: accounts[6]});
    
        assert.notEqual(tx.events.AudienceRequested, undefined, "AudienceRequested wasn't triggered");
    
        assert.equal(
            await MessageTribute.methods.balance().call({from: accounts[6]}),
            100,
            "Deposited balance must be 100"); 

        let tx2 = await MessageTribute.methods.grantAudience(accounts[6], false, secret).send({from: accounts[0]});
        assert.notEqual(tx2.events.AudienceGranted, undefined, "AudienceGranted wasn't triggered");

        let amount = (await MessageTribute.methods.getRequiredFee(accounts[0]).call({from: accounts[6]})).fee.toString();
        
        assert.equal(
            amount,
            0,
            "Amount should be 0"); 


     });

     it("Other tests", async () => {
        /*
        TODO

        // Granting an audience that requires 200 tribute non permanent
        await MessageTribute.methods.setRequiredTribute(accounts[4], 200, true, false).send({from: accounts[0]});

        // Requiring 100 deposit from everyone
        await MessageTribute.methods.setRequiredTribute("0x0", 100, false, true).send({from: accounts[0]});
      
        // Requiring 100 tribute from everyone
        await MessageTribute.methods.setRequiredTribute("0x0", 100, true, true).send({from: accounts[1]});
*/
    });


    
});