.eslintrc.js

@@ -28,5 +28,6 @@ module.exports = {
       named: 'always',
       asyncArrow: 'always',
     }],
+    'indent': ['error', 2]
   }
 }

.travis.yml

@@ -12,7 +12,7 @@ install:
 script:
   - npm run lint:wrapper
   - npm run lint:contract-tests
-  # - yarn lint:contracts
+  - npm test
 
 branches:
   only:

apps/contributor/contracts/Contributor.sol

@@ -64,10 +64,13 @@ contract Contributor is AragonApp {
   }
 
   function updateContributorAccount(uint32 id, address oldAccount, address newAccount) public auth(MANAGE_CONTRIBUTORS_ROLE) {
+    require(newAccount != address(0), "invalid new account address");
+    require(getContributorAddressById(id) == oldAccount, "contributor does not exist");
+
     contributorIds[oldAccount] = 0;
     contributorIds[newAccount] = id;
     contributors[id].account = newAccount;
-    ContributorAccountUpdated(id, oldAccount, newAccount);
+    emit ContributorAccountUpdated(id, oldAccount, newAccount);
   }
 
   function updateContributorProfileHash(uint32 id, bytes32 hashDigest, uint8 hashFunction, uint8 hashSize) public isInitialized auth(MANAGE_CONTRIBUTORS_ROLE) {

apps/contributor/contracts/test/Spoof.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.4.24;
+
+import "@aragon/os/contracts/acl/ACL.sol";
+import "@aragon/os/contracts/kernel/Kernel.sol";
+import "@aragon/os/contracts/factory/DAOFactory.sol";
+
+// You might think this file is a bit odd, but let me explain.
+// We only use for now those imported contracts in our tests, which
+// means Truffle will not compile them for us, because they are from
+// an external dependency.
+
+
+// solium-disable-next-line no-empty-blocks
+contract Spoof {
+  // ...
+}

apps/contributor/package.json

@@ -7,7 +7,6 @@
     "@aragon/cli": "^5.9.6"
   },
   "devDependencies": {
-    "@aragon/test-helpers": "^1.1.0",
     "eth-gas-reporter": "^0.2.0",
     "ganache-cli": "^6.4.3",
     "solidity-coverage": "^0.5.11"
@@ -29,7 +28,7 @@
     "test": "TRUFFLE_TEST=true PORT=7545 npm run ganache-cli:test",
     "test:gas": "GAS_REPORTER=true npm test",
     "coverage": "SOLIDITY_COVERAGE=true npm run ganache-cli:test",
-    "ganache-cli:test": "./node_modules/@aragon/test-helpers/ganache-cli.sh"
+    "ganache-cli:test": "../../scripts/ganache-cli.sh"
   },
   "keywords": []
 }

apps/contributor/test/app.js

@@ -1,5 +0,0 @@
-// const Contributor = artifacts.require('Contributor.sol');
-
-contract('Contributor', (_accounts) => {
-  it('should be tested');
-});

apps/contributor/test/contributor.js

@@ -0,0 +1,170 @@
+const namehash = require('ethers').utils.namehash;
+
+// eslint-disable-next-line no-undef
+const Contributor = artifacts.require("Contributor.sol");
+
+// eslint-disable-next-line no-undef
+const getContract = name => artifacts.require(name);
+const { assertRevert } = require('@aragon/test-helpers/assertThrow');
+
+const ZERO_ADDR = '0x0000000000000000000000000000000000000000';
+
+contract('Contributor app', (accounts) => {
+  let kernelBase, aclBase, daoFactory, r, dao, acl, contributor;
+
+  const root = accounts[0];
+  const member1 = accounts[1];
+
+  // eslint-disable-next-line no-undef
+  before(async () => {
+    kernelBase = await getContract('Kernel').new(true); // petrify immediately
+    aclBase = await getContract('ACL').new();
+    daoFactory = await getContract('DAOFactory').new(kernelBase.address, aclBase.address, ZERO_ADDR);
+    r = await daoFactory.newDAO(root);
+    dao = getContract('Kernel').at(r.logs.filter(l => l.event == 'DeployDAO')[0].args.dao);
+    acl = getContract('ACL').at(await dao.acl());
+
+    //create dao mamnager permission for coin owner
+    await acl.createPermission(
+      root,
+      dao.address,
+      await dao.APP_MANAGER_ROLE(),
+      root,
+      { from: root }
+    );
+
+    //get new app instance from DAO
+    const receipt = await dao.newAppInstance(
+      '0x1234',
+      (await Contributor.new()).address,
+      0x0,
+      false,
+      { from: root }
+    );
+    contributor = Contributor.at(
+      receipt.logs.filter(l => l.event == 'NewAppProxy')[0].args.proxy
+    );
+
+    //apps id
+    let appsId = [];
+    appsId[0] = namehash("kredits-contribution");
+    appsId[1] = namehash("kredits-contributor");
+    appsId[2] = namehash("kredits-proposal");
+    appsId[3] = namehash("kredits-token");
+
+    //init contributor (app)
+    await contributor.initialize(root, appsId);
+
+    //create manage contributors role
+    await acl.createPermission(
+      root,
+      contributor.address,
+      await contributor.MANAGE_CONTRIBUTORS_ROLE(),
+      root,
+      { from: root }
+    );
+  
+  });
+
+  describe("Owner default space permissions", async () => {
+    it('check owner is token issuer', async () => {
+      let manageContributorPermission = await acl.hasPermission(root, contributor.address, await contributor.MANAGE_CONTRIBUTORS_ROLE());
+      // eslint-disable-next-line no-undef
+      assert.equal(manageContributorPermission, true);
+    });  
+  });
+
+  describe("Add contributor", async () => {
+    let account = root;
+    let hashDigest = '0x0';
+    let hashFunction = 0;
+    let hashSize = 0;
+
+    it("should revert when add contributor from an address that does not have permission", async () => {
+      return assertRevert(async () => {
+        await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
+        'sender does not have permission';
+      });
+    });
+
+    it('add contributor', async () => {
+      let contributorCount = await contributor.coreContributorsCount();
+      await contributor.addContributor(account, hashDigest, hashFunction, hashSize);
+      // eslint-disable-next-line no-undef
+      assert.equal(await contributor.addressExists(account), true);
+      let contributorCountAfter = await contributor.coreContributorsCount();
+      // eslint-disable-next-line no-undef
+      assert.equal(await contributorCountAfter.toNumber(), parseInt(contributorCount)+1);
+    });
+
+    it("should revert when add contributor with an address that already exist", async () => {
+      return assertRevert(async () => {
+        await contributor.addContributor(account, hashDigest, hashFunction, hashSize, { from: member1});
+        'address already exist';
+      });
+    });
+  });
+
+  describe("Update contributor", async () => {
+    let id;
+    let oldAccount;
+    let newAccount;
+    let hashDigest;
+    let hashFunction;
+    let hashSize;
+
+    // eslint-disable-next-line no-undef
+    before(async () =>  {
+      id = await contributor.coreContributorsCount();
+      oldAccount = root;
+      newAccount = member1;
+      hashDigest = '0x1000000000000000000000000000000000000000000000000000000000000000';
+      hashFunction = 1;
+      hashSize = 1;
+    });
+
+    it('update contributor account', async () => {
+      await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount);
+      let contributorId = await contributor.getContributorIdByAddress(oldAccount);
+      // eslint-disable-next-line no-undef
+      assert.equal(contributorId.toNumber(), 0);
+    });
+
+    it("should revert when update contributor account from address that does not have permission", async () => {
+      return assertRevert(async () => {
+        await contributor.updateContributorAccount(id.toNumber(), oldAccount, newAccount, {from: member1});
+        'sender does not have permission';
+      });
+    });
+
+    it("should revert when update contributor account that does not exist", async () => {
+      return assertRevert(async () => {
+        await contributor.updateContributorAccount(id.toNumber(), accounts[3], newAccount);
+        'contributor does not exist';
+      });
+    });
+
+    it("should revert when update contributor account with address(0)", async () => {
+      return assertRevert(async () => {
+        await contributor.updateContributorAccount(id.toNumber(), oldAccount, ZERO_ADDR);
+        'contributor does not exist';
+      });
+    });
+
+    it('update contributor profile hash', async () => {
+      await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize);
+      let contributorProfile = await contributor.contributors(id.toNumber());
+      assert.equal(hashDigest, contributorProfile[1]);    // eslint-disable-line no-undef
+      assert.equal(hashFunction, contributorProfile[2].toNumber());   // eslint-disable-line no-undef
+      assert.equal(hashSize, contributorProfile[3].toNumber());   // eslint-disable-line no-undef
+    });
+
+    it("should revert when update contributor profile hash from address that does not have permission", async () => {
+      return assertRevert(async () => {
+        await contributor.updateContributorProfileHash(id.toNumber(), hashDigest, hashFunction, hashSize, {from: member1});
+        'sender does not have permission';
+      });
+    });
+
+  });
+});

package.json

@@ -24,6 +24,7 @@
     "lint:contracts": "solhint \"contracts/**/*.sol\" \"apps/*/contracts/**/*.sol\"",
     "lint:contract-tests": "eslint apps/*/test",
     "lint:wrapper": "eslint lib/",
+    "test": "npm run test:token && npm run test:contributor && npm run test:contribution && npm run test:proposal",
     "test:token": "cd apps/token && npm run test",
     "test:contributor": "cd apps/contributor && npm run test",
     "test:contribution": "cd apps/contribution && npm run test",

scripts/ganache-cli.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+
+# Exit script as soon as a command fails.
+set -o errexit
+
+# Executes cleanup function at script exit.
+trap cleanup EXIT
+
+cleanup() {
+  # Kill the RPC instance that we started (if we started one and if it's still running).
+  if [ -n "$rpc_pid" ] && ps -p $rpc_pid > /dev/null; then
+    kill -9 $rpc_pid
+  fi
+}
+
+setup_coverage_variables() {
+  PORT=${PORT-8555}
+  BALANCE=${BALANCE-100000}
+  GAS_LIMIT=${GAS_LIMIT-0xfffffffffff}
+  NETWORK_ID=${NETWORK_ID-16}
+}
+
+setup_testing_variables() {
+  PORT=${PORT-8545}
+  BALANCE=${BALANCE-100000}
+  GAS_LIMIT=${GAS_LIMIT-8000000}
+  NETWORK_ID=${NETWORK_ID-15}
+}
+
+start_ganache() {
+  echo "Starting ganache-cli..."
+  npx ganache-cli -i ${NETWORK_ID} -l ${GAS_LIMIT} -e ${BALANCE} -p ${PORT} > /dev/null &
+  rpc_pid=$!
+  sleep 3
+  echo "Running ganache-cli with pid ${rpc_pid} in port ${PORT}"
+}
+
+start_testrpc() {
+  echo "Starting testrpc-sc..."
+  npx testrpc-sc -i ${NETWORK_ID} -l ${GAS_LIMIT} -e ${BALANCE} -p ${PORT} > /dev/null &
+  rpc_pid=$!
+  sleep 3
+  echo "Running testrpc-sc with pid ${rpc_pid} in port ${PORT}"
+}
+
+measure_coverage() {
+  echo "Measuring coverage..."
+  npx solidity-coverage "$@"
+}
+
+run_tests() {
+  echo "Running tests..."
+  npx aragon contracts test --network rpc "$@"
+}
+
+if [ "$SOLIDITY_COVERAGE" = true ]; then
+  setup_coverage_variables
+  start_testrpc
+  measure_coverage
+else
+  setup_testing_variables
+  start_ganache
+  run_tests
+fi