ciphermask/test/unit/app/controllers/permissions/restricted-methods-test.js

import { strict as assert } from 'assert';
import pify from 'pify';

import getRestrictedMethods from '../../../../../app/scripts/controllers/permissions/restrictedMethods';

describe('restricted methods', function () {
  describe('eth_accounts', function () {
    it('should handle getKeyringAccounts error', async function () {
      const restrictedMethods = getRestrictedMethods({
        getKeyringAccounts: async () => {
          throw new Error('foo');
        },
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      const fooError = new Error('foo');
      await assert.rejects(
        ethAccountsMethod(null, res, null),
        fooError,
        'Should reject with expected error',
      );

      assert.deepEqual(
        res,
        { error: fooError },
        'response should have expected error and no result',
      );
    });

    it('should handle missing identity for first account when sorting', async function () {
      const restrictedMethods = getRestrictedMethods({
        getIdentities: () => {
          return { '0x7e57e2': {} };
        },
        getKeyringAccounts: async () => ['0x7e57e2', '0x7e57e3'],
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      await assert.rejects(ethAccountsMethod(null, res, null));
      assert.ok(res.error instanceof Error, 'result should have error');
      assert.deepEqual(
        Object.keys(res),
        ['error'],
        'result should only contain error',
      );
    });

    it('should handle missing identity for second account when sorting', async function () {
      const restrictedMethods = getRestrictedMethods({
        getIdentities: () => {
          return { '0x7e57e3': {} };
        },
        getKeyringAccounts: async () => ['0x7e57e2', '0x7e57e3'],
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      await assert.rejects(ethAccountsMethod(null, res, null));
      assert.ok(res.error instanceof Error, 'result should have error');
      assert.deepEqual(
        Object.keys(res),
        ['error'],
        'result should only contain error',
      );
    });

    it('should return accounts in keyring order when none are selected', async function () {
      const keyringAccounts = ['0x7e57e2', '0x7e57e3', '0x7e57e4', '0x7e57e5'];
      const restrictedMethods = getRestrictedMethods({
        getIdentities: () => {
          return keyringAccounts.reduce((identities, address) => {
            identities[address] = {};
            return identities;
          }, {});
        },
        getKeyringAccounts: async () => [...keyringAccounts],
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      await ethAccountsMethod(null, res, null);
      assert.deepEqual(
        res,
        { result: keyringAccounts },
        'should return accounts in correct order',
      );
    });

    it('should return accounts in keyring order when all have same last selected time', async function () {
      const keyringAccounts = ['0x7e57e2', '0x7e57e3', '0x7e57e4', '0x7e57e5'];
      const restrictedMethods = getRestrictedMethods({
        getIdentities: () => {
          return keyringAccounts.reduce((identities, address) => {
            identities[address] = { lastSelected: 1000 };
            return identities;
          }, {});
        },
        getKeyringAccounts: async () => [...keyringAccounts],
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      await ethAccountsMethod(null, res, null);
      assert.deepEqual(
        res,
        { result: keyringAccounts },
        'should return accounts in correct order',
      );
    });

    it('should return accounts sorted by last selected (descending)', async function () {
      const keyringAccounts = ['0x7e57e2', '0x7e57e3', '0x7e57e4', '0x7e57e5'];
      const expectedResult = keyringAccounts.slice().reverse();
      const restrictedMethods = getRestrictedMethods({
        getIdentities: () => {
          return keyringAccounts.reduce((identities, address, index) => {
            identities[address] = { lastSelected: index * 1000 };
            return identities;
          }, {});
        },
        getKeyringAccounts: async () => [...keyringAccounts],
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      await ethAccountsMethod(null, res, null);
      assert.deepEqual(
        res,
        { result: expectedResult },
        'should return accounts in correct order',
      );
    });

    it('should return accounts sorted by last selected (descending) with unselected accounts last, in keyring order', async function () {
      const keyringAccounts = [
        '0x7e57e2',
        '0x7e57e3',
        '0x7e57e4',
        '0x7e57e5',
        '0x7e57e6',
      ];
      const expectedResult = [
        '0x7e57e4',
        '0x7e57e2',
        '0x7e57e3',
        '0x7e57e5',
        '0x7e57e6',
      ];
      const restrictedMethods = getRestrictedMethods({
        getIdentities: () => {
          return {
            '0x7e57e2': { lastSelected: 1000 },
            '0x7e57e3': {},
            '0x7e57e4': { lastSelected: 2000 },
            '0x7e57e5': {},
            '0x7e57e6': {},
          };
        },
        getKeyringAccounts: async () => [...keyringAccounts],
      });
      const ethAccountsMethod = pify(restrictedMethods.eth_accounts.method);

      const res = {};
      await ethAccountsMethod(null, res, null);
      assert.deepEqual(
        res,
        { result: expectedResult },
        'should return accounts in correct order',
      );
    });
  });
});