1
0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-12-23 09:52:26 +01:00
metamask-extension/test/unit/app/controllers/permissions/helpers.js
Erik Marks b1d090ac4d
Add permissions controller unit tests (#7969)
* add permissions controller, log, middleware, and restricted method unit tests

* fix permissions-related bugs

* convert permissions log to controller-like class

* add permissions unit test coverage requirements

* update rpc-cap

Co-Authored-By: Whymarrh Whitby <whymarrh.whitby@gmail.com>
Co-Authored-By: Mark Stacey <markjstacey@gmail.com>
2020-03-16 10:13:22 -07:00

118 lines
3.3 KiB
JavaScript

import { strict as assert } from 'assert'
import { noop } from './mocks'
/**
* Grants the given permissions to the given origin, using the given permissions
* controller.
*
* Just a wrapper for an rpc-cap middleware function.
*
* @param {PermissionsController} permController - The permissions controller.
* @param {string} origin - The origin to grant permissions to.
* @param {Object} permissions - The permissions to grant.
*/
export function grantPermissions (permController, origin, permissions) {
permController.permissions.grantNewPermissions(
origin, permissions, {}, noop
)
}
/**
* Sets the underlying rpc-cap requestUserApproval function, and returns
* a promise that's resolved once it has been set.
*
* This function must be called on the given permissions controller every
* time you want such a Promise. As of writing, it's only called once per test.
*
* @param {PermissionsController} - A permissions controller.
* @returns {Promise<void>} A Promise that resolves once a pending approval
* has been set.
*/
export function getUserApprovalPromise (permController) {
return new Promise((resolveForCaller) => {
permController.permissions.requestUserApproval = async (req) => {
const { origin, metadata: { id } } = req
return new Promise((resolve, reject) => {
permController.pendingApprovals.set(id, { origin, resolve, reject })
resolveForCaller()
})
}
})
}
/**
* Validates an activity log entry with respect to a request, response, and
* relevant metadata.
*
* @param {Object} entry - The activity log entry to validate.
* @param {Object} req - The request that generated the entry.
* @param {Object} [res] - The response for the request, if any.
* @param {'restricted'|'internal'} methodType - The method log controller method type of the request.
* @param {boolean} success - Whether the request succeeded or not.
*/
export function validateActivityEntry (
entry, req, res, methodType, success
) {
assert.doesNotThrow(
() => {
_validateActivityEntry(
entry, req, res, methodType, success
)
},
'should have expected activity entry'
)
}
function _validateActivityEntry (
entry, req, res, methodType, success
) {
assert.ok(entry, 'entry should exist')
assert.equal(entry.id, req.id)
assert.equal(entry.method, req.method)
assert.equal(entry.origin, req.origin)
assert.equal(entry.methodType, methodType)
assert.deepEqual(
entry.request, req,
'entry.request should equal the request'
)
if (res) {
assert.ok(
(
Number.isInteger(entry.requestTime) &&
Number.isInteger(entry.responseTime)
),
'request and response times should be numbers'
)
assert.ok(
(entry.requestTime <= entry.responseTime),
'request time should be less than response time'
)
assert.equal(entry.success, success)
assert.deepEqual(
entry.response, res,
'entry.response should equal the response'
)
} else {
assert.ok(
Number.isInteger(entry.requestTime) && entry.requestTime > 0,
'entry should have non-zero request time'
)
assert.ok(
(
entry.success === null &&
entry.responseTime === null &&
entry.response === null
),
'entry response values should be null'
)
}
}