diff --git a/.babelrc b/.babelrc new file mode 100644 index 0000000..0bddca3 --- /dev/null +++ b/.babelrc @@ -0,0 +1,12 @@ +{ + "presets": [ + [ + "@babel/preset-env", + { + "targets": { + "node": true + } + } + ] + ] +} \ No newline at end of file diff --git a/auth/permission/contracts/EventLogType.sol b/auth/permission/contracts/EventLogType.sol new file mode 100644 index 0000000..aa3b225 --- /dev/null +++ b/auth/permission/contracts/EventLogType.sol @@ -0,0 +1,9 @@ +contract EventLogType { + // event log type + enum EventLogType { // TODO expose -LS + NULL, + GRANT, + REVOKE, + CHECK + } +} \ No newline at end of file diff --git a/auth/permission/contracts/PermissionManager.sol b/auth/permission/contracts/PermissionManager.sol index 8816497..f75f38b 100644 --- a/auth/permission/contracts/PermissionManager.sol +++ b/auth/permission/contracts/PermissionManager.sol @@ -1,9 +1,10 @@ import "../../../rest/contracts/RestStatus.sol"; +import "./EventLogType.sol"; /** * Permission Manager for all */ -contract PermissionManager is RestStatus { +contract PermissionManager is RestStatus, EventLogType { // master account address master; // owner account @@ -30,14 +31,6 @@ contract PermissionManager is RestStatus { uint result; } - // event log type - enum EventLogType { // TODO expose -LS - NULL, - GRANT, - REVOKE, - CHECK - } - // event log EventLogEntry[] eventLog; diff --git a/auth/permission/permissionManager.js b/auth/permission/permissionManager.js index 459cce2..a5f649b 100644 --- a/auth/permission/permissionManager.js +++ b/auth/permission/permissionManager.js @@ -1,12 +1,13 @@ -const ba = require('blockapps-rest'); -const util = ba.common.util; -const BigNumber = ba.common.BigNumber; -const config = ba.common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import RestStatus from 'http-status-codes'; +import { rest, util, importer } from 'blockapps-rest'; +const { createContract, getState, call, RestError } = rest; + +import { getYamlFile } from '../../util/config'; +const config = getYamlFile('config.yaml'); const contractName = 'PermissionManager'; -const contractFilename = `${config.libPath}/auth/permission/contracts/PermissionManager.sol`; -const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`); +const contractFilename = `./auth/permission/contracts/PermissionManager.sol`; +const options = { config } util.bitmaskToEnumString = function (bitmask, bitmaskEnum) { const strings = [] @@ -20,50 +21,53 @@ util.bitmaskToEnumString = function (bitmask, bitmaskEnum) { } -function* uploadContract(admin, master) { +async function uploadContract(admin, master) { // NOTE: in production, the contract is created and owned by the AdminInterface // for testing purposes the creator is the admin user - const args = { - owner: admin.address, - master: master.address, + const args = { master: master.address, owner: admin.address }; + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) } - const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args)); + + const contract = await createContract(admin, contractArgs, options) contract.src = 'removed'; return bind(admin, contract); } -function* createPermissionsAdmin(admin, master, permissions) { - const contract = yield uploadContract(admin, master); +async function createPermissionsAdmin(admin, master, permissions) { + const contract = await uploadContract(admin, master); // add permission to create and modify contracts - const args = {address: admin.address, id: admin.name, permissions: permissions}; - yield contract.grant(args); + const args = { address: admin.address, id: admin.name, permissions: permissions }; + await contract.grant(args); return contract; } function bind(admin, contract) { - contract.getState = function* () { - return yield rest.getState(contract); + contract.getState = async function () { + return await getState(contract, options); } - contract.grant = function* (args) { - return yield grant(admin, contract, args); + contract.grant = async function (args) { + return await grant(admin, contract, args); } - contract.getPermissions = function* (args) { - return yield getPermissions(admin, contract, args); + contract.getPermissions = async function (args) { + return await getPermissions(admin, contract, args); } - contract.revoke = function* (args) { - return yield revoke(admin, contract, args); + contract.revoke = async function (args) { + return await revoke(admin, contract, args); } - contract.check = function* (args) { - return yield check(admin, contract, args); + contract.check = async function (args) { + return await check(admin, contract, args); } - contract.listPermits = function* (args) { - return yield listPermits(admin, contract, args); + contract.listPermits = async function (args) { + return await listPermits(admin, contract, args); } - contract.listEvents = function* (args) { - return yield listEvents(admin, contract, args); + contract.listEvents = async function (args) { + return await listEvents(admin, contract, args); } - contract.transferOwnership = function* (args) { - return yield transferOwnership(admin, contract, args); + contract.transferOwnership = async function (args) { + return await transferOwnership(admin, contract, args); } return contract; } @@ -78,37 +82,49 @@ function bindAddress(admin, address) { // throws: ErrorCodes // returns: updated permissions -function* grant(admin, contract, args) { - rest.verbose('grant', args); +async function grant(admin, contract, args) { // function grant(address _address, uint _permissions) returns (ErrorCodes) { - const method = 'grant'; - const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const callArgs = { + contract, + method: 'grant', + args: util.usc(args) + } + + const [restStatus, permissions] = await call(admin, callArgs, options); if (restStatus != RestStatus.OK) { - throw new Error(restStatus); + throw new RestError(restStatus, callArgs.method, callArgs.args); } return permissions; } // throws: ErrorCodes // returns: permissions -function* getPermissions(admin, contract, args) { - rest.verbose('getPermissions', args); +async function getPermissions(admin, contract, args) { // function getPermissions(address _address) returns (ErrorCodes, uint) { - const method = 'getPermissions'; - const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const callArgs = { + contract, + method: 'getPermissions', + args: util.usc(args) + } + + const [restStatus, permissions] = await call(admin, callArgs, options); if (restStatus != RestStatus.OK) { - throw new rest.RestError(restStatus, method, args); + throw new RestError(restStatus, callArgs.method, callArgs.args); } return permissions; } // throws: ErrorCodes // returns: true if permitted -function* check(admin, contract, args) { - rest.verbose('check', args); +async function check(admin, contract, args) { // function check(address _address, uint _permissions) returns (ErrorCodes) { - const method = 'check'; - const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const callArgs = { + contract, + method: 'check', + args: util.usc(args) + } + + const [restStatus] = await call(admin, callArgs, options); if (restStatus != RestStatus.OK) { return false; } @@ -116,30 +132,39 @@ function* check(admin, contract, args) { } // throws: ErrorCodes -function* revoke(admin, contract, args) { - rest.verbose('revoke', args); +async function revoke(admin, contract, args) { // function revoke(address _address) returns (ErrorCodes) { - const method = 'revoke'; - const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const callArgs = { + contract, + method: 'revoke', + args: util.usc(args) + } + + const [restStatus] = await call(admin, callArgs, options); if (restStatus != RestStatus.OK) { - throw new rest.RestError(restStatus, method, args); + throw new RestError(restStatus, callArgs.method, callArgs.args); } return RestStatus.OK; } // transferOwnership -function* transferOwnership(admin, contract, args) { - const method = "transferOwnership"; - const [restStatus] = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function transferOwnership(admin, contract, args) { + const callArgs = { + contract, + method: 'transferOwnership', + args: util.usc(args) + } + + const [restStatus] = await call(admin, callArgs, {}); if (restStatus != RestStatus.OK) { - throw new rest.RestError(restStatus, method, args); + throw new RestError(restStatus, method, args); } return RestStatus.OK; } // list -function* listPermits(admin, contract, args) { - const { permits } = yield contract.getState() +async function listPermits(admin, contract, args) { + const { permits } = await contract.getState() const permitsJson = permits.map((permit) => { permit.permissionsHex = Number(permit.permissions).toString(16) permit.strings = util.bitmaskToEnumString(permit.permissions, args.enum) @@ -148,8 +173,8 @@ function* listPermits(admin, contract, args) { return permitsJson } -function* listEvents(admin, contract, args) { - const { eventLog } = yield contract.getState() +async function listEvents(admin, contract, args) { + const { eventLog } = await contract.getState() const eventsJson = eventLog.map((event) => { event.permissionsHex = Number(event.permissions).toString(16) event.strings = util.bitmaskToEnumString(event.permissions, args.enum) @@ -158,7 +183,7 @@ function* listEvents(admin, contract, args) { return eventsJson } -module.exports = { +export { bind, bindAddress, uploadContract, diff --git a/auth/permission/permissionedHashmap.js b/auth/permission/permissionedHashmap.js index 9c06b78..03b4d9b 100644 --- a/auth/permission/permissionedHashmap.js +++ b/auth/permission/permissionedHashmap.js @@ -1,41 +1,50 @@ -require('co-mocha') -const ba = require('blockapps-rest') +import { rest, util, importer } from 'blockapps-rest'; +const { createContract, getState, call } = rest; -const { config, util } = ba.common -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import { getYamlFile } from '../../util/config'; +const config = getYamlFile('config.yaml'); const contractName = 'PermissionedHashmap' const contractFilename = `${config.libPath}/auth/permission/contracts/PermissionedHashmap.sol` +const options = { config } -function* uploadContract(admin, permissionManager) { +async function uploadContract(admin, permissionManager) { const args = { permissionManager: permissionManager.address } - const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args)) + + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) + } + + const contract = await createContract(admin, contractArgs, options) contract.src = 'removed' return bind(admin, contract) } function bind(admin, _contract) { const contract = _contract - contract.getState = function* () { - return yield rest.getState(contract) + contract.getState = async function () { + return await getState(contract, options) } - contract.getStateVar = function* (args) { - return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length) + // TODO: it is not in new rest (do we have the same with diffrent name ?) + // contract.getStateVar = async function(args) { + // return await rest.getStateVar(contract, args.name, args.count, args.offset, args.length) + // } + contract.put = async function (args) { + return await put(admin, contract, args) } - contract.put = function* (args) { - return yield put(admin, contract, args) + contract.get = async function (args) { + return await get(admin, contract, args) } - contract.get = function* (args) { - return yield get(admin, contract, args) + contract.contains = async function (args) { + return await contains(admin, contract, args) } - contract.contains = function* (args) { - return yield contains(admin, contract, args) + contract.size = async function (args) { + return await size(admin, contract, args) } - contract.size = function* (args) { - return yield size(admin, contract, args) - } - contract.remove = function* (args) { - return yield remove(admin, contract, args) + contract.remove = async function (args) { + return await remove(admin, contract, args) } return contract @@ -49,41 +58,60 @@ function bindAddress(admin, address) { return bind(admin, contract) } -function* put(admin, contract, args) { - rest.verbose('put', args) - const method = 'put' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function put(admin, contract, args) { + const callArgs = { + contract, + method: 'put', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return result } -function* get(admin, contract, args) { - rest.verbose('get', args) - const method = 'get' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function get(admin, contract, args) { + const callArgs = { + contract, + method: 'get', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return result[0] } -function* contains(admin, contract, args) { - rest.verbose('contains', args) - const method = 'contains' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function contains(admin, contract, args) { + const callArgs = { + contract, + method: 'contains', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return result[0] == true } -function* size(admin, contract, args) { - rest.verbose('size', args) - const method = 'size' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function size(admin, contract, args) { + const callArgs = { + contract, + method: 'size', + args: util.usc(args) + } + const result = await call(admin, callArgs, options) return parseInt(result[0], 10) } -function* remove(admin, contract, args) { - rest.verbose('remove', args) - const method = 'remove' - yield rest.callMethod(admin, contract, method, util.usc(args)) +async function remove(admin, contract, args) { + const callArgs = { + contract, + method: 'remove', + args: util.usc(args) + } + + await call(admin, callArgs, options) } -module.exports = { +export { bind, bindAddress, uploadContract, diff --git a/auth/permission/test/permissionManager.test.js b/auth/permission/test/permissionManager.test.js index 56ba8a9..6d311ed 100644 --- a/auth/permission/test/permissionManager.test.js +++ b/auth/permission/test/permissionManager.test.js @@ -1,253 +1,294 @@ -require('co-mocha') -const ba = require('blockapps-rest') +import { assert } from 'chai'; +import { rest, util, fsUtil, parser } from 'blockapps-rest'; +const { createUser, call } = rest; -const { config, util, assert, cwd } = ba.common -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import { getYamlFile } from '../../../util/config'; +import * as permissionManagerJs from '../permissionManager'; +import { getCredentialArgs } from '../../../util/util'; -const permissionManagerJs = require('../permissionManager') -const RestStatus = rest.getFields(`${cwd}/rest/contracts/RestStatus.sol`) +const config = getYamlFile('config.yaml'); -const adminName = util.uid('Admin') -const adminPassword = '1234' -const masterName = util.uid('Master') -const masterPassword = '5678' +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); +const masterArgs = getCredentialArgs(util.uid(), 'Master', '5678'); -const { EventLogType } = rest.getEnums(`${cwd}/auth/permission/contracts/PermissionManager.sol`); +describe('PermissionManager tests', function () { + this.timeout(config.timeout); + + const options = { config } -describe('PermissionManager tests', function() { - this.timeout(config.timeout) - - let admin, master + let admin, master, EventLogType, RestStatus; // get ready: admin-user and manager-contract - before(function* () { + before(async function () { + // Parse fields + const restStatusSource = fsUtil.get(`${util.cwd}/rest/contracts/RestStatus.sol`) + RestStatus = await parser.parseFields(restStatusSource); + + // parse Enums + const source = fsUtil.get(`${util.cwd}/auth/permission/contracts/EventLogType.sol`) + EventLogType = await parser.parseEnum(source); + console.log('creating admin') - admin = yield rest.createUser(adminName, adminPassword) + admin = await createUser(adminArgs, options) console.log('creating master') - master = yield rest.createUser(masterName, masterPassword) + master = await createUser(masterArgs, options) }) - it('upload', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) - const { eventLog } = yield contract.getState() + it('upload', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) + const { eventLog } = await contract.getState() assert.isDefined(eventLog, 'eventLog') assert.equal(eventLog.length, 0, 'empty') }) - it('Grant (address with permissions)', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Grant (address with permissions)', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const args = yield createPermitArgs(uid) - const permissions = yield contract.grant(args) + const args = await createPermitArgs(uid) + const permissions = await contract.grant(args) assert.equal(permissions, args.permissions, 'permissions added') - const state = yield contract.getState() + const state = await contract.getState() const permit = state.permits[1] assert.equal(permit.adrs, args.address, ' address in array') assert.equal(permit.permissions, args.permissions, ' permissions in array') assert.equal(permit.id, args.id, 'id in array') }) - it('Grant Multiple Permissions', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Grant Multiple Permissions', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const args = yield createPermitArgs(uid) + const args = await createPermitArgs(uid) // add permit { - const permissions = yield contract.grant(args) + const permissions = await contract.grant(args) assert.equal(permissions, args.permissions, 'permissions added') } // add different permission { args.permissions = 0x30 - const permissions = yield contract.grant(args) + const permissions = await contract.grant(args) const expected = 0x30 | 0x03 assert.equal(permissions, expected, 'permissions added') } }) - it('Get permit', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Get permit', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const permitArgs = yield createPermitArgs(uid) - yield contract.grant(permitArgs) + const permitArgs = await createPermitArgs(uid) + await contract.grant(permitArgs) const args = { address: permitArgs.address } - const permissions = yield contract.getPermissions(args) + const permissions = await contract.getPermissions(args) assert.equal(permissions, permitArgs.permissions, 'permissions') { permitArgs.permissions = 0x30 - yield contract.grant(permitArgs) - const permissions2 = yield contract.getPermissions(args) + await contract.grant(permitArgs) + const permissions2 = await contract.getPermissions(args) const expected = 0x03 | 0x30 assert.equal(permissions2, expected, 'new permissions') } }) - it('Get permit 404', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Get permit 404', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const args = { address: 1234 } - yield assert.shouldThrowRest(function* () { - const permissions = yield contract.getPermissions(args) - }, RestStatus.NOT_FOUND) + try { + await contract.getPermissions(args) + } catch (e) { + assert.equal(e.response.status, RestStatus.NOT_FOUND, 'should Throws 404 Not found') + } }) - it.skip('Get permit - history', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it.skip('Get permit - history', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const permitArgs = yield createPermitArgs(uid) - yield contract.grant(permitArgs) + const permitArgs = await createPermitArgs(uid) + await contract.grant(permitArgs) // found { const args = { address: permitArgs.address } - const permissions = yield contract.getPermissions(args) + const permissions = await contract.getPermissions(args) assert.equal(permissions, permitArgs.permissions, 'permissions') } // not found { const args = { address: uid } - yield assert.shouldThrowRest(function* () { - const permissions = yield contract.getPermissions(args) + await assert.shouldThrowRest(async function () { + const permissions = await contract.getPermissions(args) }, RestStatus.NOT_FOUND) } // check the history - const { history } = yield contract.getState() + const { history } = await contract.getState() assert.equal(history[0], permitArgs.address, 'valid call') assert.equal(history[1], uid, 'valid call') }) - it('Check permissions', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Check permissions', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const permitArgs = yield createPermitArgs(uid) - yield contract.grant(permitArgs) + const permitArgs = await createPermitArgs(uid) + await contract.grant(permitArgs) // check const args = { address: permitArgs.address, permissions: permitArgs.permissions } - const isPermitted = yield contract.check(args) + const isPermitted = await contract.check(args) assert.equal(isPermitted, true, 'permitted') { const args = { address: permitArgs.address, permissions: 0xFF } - const isPermitted = yield contract.check(args) + const isPermitted = await contract.check(args) assert.equal(isPermitted, false, 'NOT permitted') } }) - it('Revoke permissions', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Revoke permissions', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const permitArgs = yield createPermitArgs(uid) - yield contract.grant(permitArgs) + const permitArgs = await createPermitArgs(uid) + await contract.grant(permitArgs) // get permissions const args = { address: permitArgs.address } - const permissions = yield contract.getPermissions(args) + const permissions = await contract.getPermissions(args) assert.equal(permissions, permitArgs.permissions, 'permissions') // revoke { const args = { address: permitArgs.address } - yield contract.revoke(args) + await contract.revoke(args) } // get permissions { const args = { address: permitArgs.address } - const permissions = yield contract.getPermissions(args) + const permissions = await contract.getPermissions(args) assert.equal(permissions, 0, 'no permissions') } }) - it('Revoke - 404', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('Revoke - 404', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const args = { address: 1234 } - yield assert.shouldThrowRest(function* () { - yield contract.revoke(args) - }, RestStatus.BAD_REQUEST) + + try { + await contract.revoke(args) + } catch (e) { + assert.equal(e.response.status, RestStatus.BAD_REQUEST, 'should throws 404 Not found') + } }) - it('Transfer Ownership - AUTHORIZED', function* () { + it('Transfer Ownership - AUTHORIZED', async function () { const uid = util.uid() - const newOwner = yield rest.createUser('NewOwner_' + uid, '' + uid) - const contract = yield permissionManagerJs.uploadContract(admin, master) + const newOwner = await createUser({ username: `NewOwner_${uid}`, password: '1234' }, options) + const contract = await permissionManagerJs.uploadContract(admin, master) // transfer ownership to a new admin, by the master { - const args = { newOwner: newOwner.address } - const method = 'transferOwnership' - const [restStatus] = yield rest.callMethod(master, contract, method, util.usc(args)) + const callArgs = { + contract, + method: 'transferOwnership', + args: util.usc({ newOwner: newOwner.address }) + } + + const [restStatus] = await call(master, callArgs, options) assert.equal(restStatus, RestStatus.OK, 'should succeed') } }) - it('Transfer Ownership - positive case', function* () { + it('Transfer Ownership - positive case', async function () { const uid = util.uid() - const newOwner = yield rest.createUser('NewOwner_' + uid, '' + uid) - const contract = yield permissionManagerJs.uploadContract(admin, master) + const newOwner = await createUser({ username: `NewOwner_${uid}`, password: '1234' }, options) + const contract = await permissionManagerJs.uploadContract(admin, master) // admin works - const args = yield createPermitArgs(uid) - yield contract.grant(args) + const args = await createPermitArgs(uid) + await contract.grant(args) // new admin unauthorized { - const method = 'grant' - const [restStatus, permissions] = yield rest.callMethod(newOwner, contract, method, util.usc(args)) + const callArgs = { + contract, + method: 'grant', + args: util.usc(args) + } + const [restStatus, permissions] = await call(newOwner, callArgs, options) assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail') } // transfer ownership - must be master { const args = { newOwner: newOwner.address } - const method = 'transferOwnership' - const [restStatus] = yield rest.callMethod(master, contract, method, util.usc(args)) + const callArgs = { + contract, + method: 'transferOwnership', + args: util.usc(args) + } + + const [restStatus] = await call(master, callArgs, options) assert.equal(restStatus, RestStatus.OK, 'should succeed') } // old admin unauthorized { - const method = 'grant' - const [restStatus, permissions] = yield rest.callMethod(admin, contract, method, util.usc(args)) + const callArgs = { + contract, + method: 'grant', + args: util.usc(args) + } + + const [restStatus] = await call(admin, callArgs, options) assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail') } // new admin works { - const method = 'grant' - const [restStatus, permissions] = yield rest.callMethod(newOwner, contract, method, util.usc(args)) + const callArgs = { + contract, + method: 'grant', + args: util.usc(args) + } + + const [restStatus] = await call(newOwner, callArgs, options) assert.equal(restStatus, RestStatus.OK, 'should succeed') } }) - it('Transfer Ownership - UNAUTHORIZED', function* () { + it('Transfer Ownership - UNAUTHORIZED', async function () { const uid = util.uid() - const contract = yield permissionManagerJs.uploadContract(admin, master) + const contract = await permissionManagerJs.uploadContract(admin, master) // transfer ownership to attacker { - const attacker = yield rest.createUser('Attacker_' + uid, '' + uid) + const attacker = await createUser({ username: `Attacker_${uid}`, password: '1234' }, options) const args = { newOwner: attacker.address } - const method = 'transferOwnership' - const [restStatus, permissions] = yield rest.callMethod(attacker, contract, method, util.usc(args)) + + const callArgs = { + contract, + method: 'transferOwnership', + args: util.usc(args) + } + + const [restStatus] = await call(attacker, callArgs, options) assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail') } }) - it('EventLog - Check permissions', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('EventLog - Check permissions', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const permitArgs = yield createPermitArgs(uid) - yield contract.grant(permitArgs) + const permitArgs = await createPermitArgs(uid) + await contract.grant(permitArgs) // check OK - should not be logged { const args = { address: permitArgs.address, permissions: permitArgs.permissions } - yield contract.check(args) + await contract.check(args) // event log - const { eventLog } = yield contract.getState() + const { eventLog } = await contract.getState() assert.equal(eventLog.length, 1, 'not logged') } // check unauthorized { const args = { address: permitArgs.address, permissions: 0x8 } - yield contract.check(args) + await contract.check(args) // event log - const { eventLog } = yield contract.getState() + const { eventLog } = await contract.getState() assert.equal(eventLog.length, 2, 'one entry') const eventLogEntry = eventLog[1]; assert.equal(eventLogEntry.msgSender, admin.address, 'msg sender') @@ -260,14 +301,14 @@ describe('PermissionManager tests', function() { } }) - it('EventLog - Grant', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('EventLog - Grant', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const args = yield createPermitArgs(uid) - yield contract.grant(args) + const args = await createPermitArgs(uid) + await contract.grant(args) // event log - const { eventLog } = yield contract.getState() + const { eventLog } = await contract.getState() assert.equal(eventLog.length, 1, 'one entry') const eventLogEntry = eventLog[0]; assert.equal(eventLogEntry.msgSender, admin.address, 'msg sender') @@ -279,19 +320,19 @@ describe('PermissionManager tests', function() { assert.equal(eventLogEntry.result, RestStatus.OK, 'result') }) - it('EventLog - Revoke', function* () { - const contract = yield permissionManagerJs.uploadContract(admin, master) + it('EventLog - Revoke', async function () { + const contract = await permissionManagerJs.uploadContract(admin, master) const uid = util.uid() - const permitArgs = yield createPermitArgs(uid) - yield contract.grant(permitArgs) + const permitArgs = await createPermitArgs(uid) + await contract.grant(permitArgs) // revoke { const args = { address: permitArgs.address } - yield contract.revoke(args) + await contract.revoke(args) } // event log - const { eventLog } = yield contract.getState() + const { eventLog } = await contract.getState() assert.equal(eventLog.length, 2, 'two entries') const eventLogEntry = eventLog[1]; assert.equal(eventLogEntry.msgSender, admin.address, 'msg sender') @@ -305,8 +346,13 @@ describe('PermissionManager tests', function() { }) -function* createPermitArgs(uid) { - const user = yield rest.createUser(uid, uid) +async function createPermitArgs(uid) { + const userArgs = { + username: `username_${uid}`, + password: '1234' + }; + + const user = await createUser(userArgs, { config }) const permissions = 0x3 const args = { diff --git a/auth/permission/test/permissionedHashmap.test.js b/auth/permission/test/permissionedHashmap.test.js index a3a80ee..48796fe 100644 --- a/auth/permission/test/permissionedHashmap.test.js +++ b/auth/permission/test/permissionedHashmap.test.js @@ -1,138 +1,148 @@ -require('co-mocha') -const ba = require('blockapps-rest') +import { assert } from 'chai'; +import { rest, util, importer } from 'blockapps-rest'; +const { createUser, call, createContract } = rest; -const { config, util, assert, cwd } = ba.common -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import { getYamlFile } from '../../../util/config'; +import * as permissionedHashmapJs from '../permissionedHashmap'; +import { getCredentialArgs } from '../../../util/util'; -const permissionedHashmapJs = require('../permissionedHashmap') +const config = getYamlFile('config.yaml'); -const adminName = util.uid('Admin') -const adminPassword = '1234' -const masterName = util.uid('Master') -const masterPassword = '5678' -const attackerName = util.uid('Attacker') -const attackerPassword = '9090' +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); +const masterArgs = getCredentialArgs(util.uid(), 'Master', '5678'); +const attackerArgs = getCredentialArgs(util.uid(), 'Attacker', '9090'); -describe('PermissionedHashmap tests', function() { +describe('PermissionedHashmap tests', function () { this.timeout(config.timeout) + const options = { config } let admin, master, attacker, hashmapPermissionManager // get ready: admin-user and manager-contract - before(function* () { + before(async function () { console.log('creating admin') - admin = yield rest.createUser(adminName, adminPassword) + admin = await createUser(adminArgs, options) console.log('creating master') - master = yield rest.createUser(masterName, masterPassword) + master = await createUser(masterArgs, options) console.log('creating attacker') - attacker = yield rest.createUser(attackerName, attackerPassword) + attacker = await createUser(attackerArgs, options) // pm - hashmapPermissionManager = yield createHashmapPermissionManager(admin, master) + hashmapPermissionManager = await createHashmapPermissionManager(admin, master) }) - it('put', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('put', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield contract.put(args); - const state = yield contract.getState(); + await contract.put(args); + const state = await contract.getState(); assert.equal(state.values.length, 2, 'length 2'); assert.equal(parseInt(state.values[1]), parseInt(args.value), 'value'); }); - it('put - unauthorized', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('put - unauthorized', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const args = factory.createEntity(iuid); - const method = 'put' - const result = yield rest.callMethod(attacker, contract, method, util.usc(args)) - const state = yield contract.getState(); + const callArgs = { + contract, + method: 'put', + args: util.usc(args) + } + + const result = await call(attacker, callArgs, options) + + const state = await contract.getState(); assert.equal(state.values.length, 1, 'length 1 - did not put'); assert.equal(parseInt(state.values[0]), 0, 'empty'); }); - it('get', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('get', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const args = factory.createEntity(iuid); // put - yield contract.put(args); + await contract.put(args); // get - const value = yield contract.get({key: args.key}); + const value = await contract.get({ key: args.key }); assert.equal(parseInt(value), parseInt(args.value), 'value'); - const notFound = yield contract.get({key: '666'}); + const notFound = await contract.get({ key: '666' }); assert.equal(parseInt(notFound), 0, 'not found'); }); - it('contains', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('contains', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const args = factory.createEntity(iuid); //put - yield contract.put(args); + await contract.put(args); // contains - const result = yield contract.contains({key: args.key}); + const result = await contract.contains({ key: args.key }); assert.equal(result, true, 'contains: true'); - const notFound = yield contract.contains({key: '666'}); + const notFound = await contract.contains({ key: '666' }); assert.equal(notFound, false, 'contains: false'); }); - it('size', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('size', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield contract.put(args); - const size1 = yield contract.size(); + await contract.put(args); + const size1 = await contract.size({}); assert.equal(size1, 1, 'size: 1'); args.key += 'x'; - yield contract.put(args); - const size2 = yield contract.size(); + await contract.put(args); + const size2 = await contract.size({}); assert.equal(size2, 2, 'size: 2'); }); - it('remove', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('remove', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const putArgs = factory.createEntity(iuid); // put - yield contract.put(putArgs); - const args = {key: putArgs.key} + await contract.put(putArgs); + const args = { key: putArgs.key } // contains { - const result = yield contract.contains(args); + const result = await contract.contains(args); assert.equal(result, true, 'contains: true'); } // remove - yield contract.remove(args); - yield contract.getState() + await contract.remove(args); + await contract.getState() // contains not { - const result = yield contract.contains(args); + const result = await contract.contains(args); assert.equal(result, false, 'contains: not'); } }); - it('remove - unauthorized', function*() { - const contract = yield permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) + it('remove - unauthorized', async function () { + const contract = await permissionedHashmapJs.uploadContract(admin, hashmapPermissionManager) const iuid = util.iuid(); const putArgs = factory.createEntity(iuid); // put - yield contract.put(putArgs); - const args = {key: putArgs.key} + await contract.put(putArgs); + const args = { key: putArgs.key } // contains { - const result = yield contract.contains(args); + const result = await contract.contains(args); assert.equal(result, true, 'contains: true'); } // remove - const method = 'remove' - const result = yield rest.callMethod(attacker, contract, method, util.usc(args)) + const callArgs = { + contract, + method: 'remove', + args: util.usc(args) + } + const result = await call(attacker, callArgs, options) - yield contract.getState() + await contract.getState() // still contained - was not removed { - const result = yield contract.contains(args); + const result = await contract.contains(args); assert.equal(result, true, 'contains: true'); } }); @@ -146,14 +156,21 @@ describe('PermissionedHashmap tests', function() { * @returns {object} the contract */ -function* createHashmapPermissionManager(admin, master) { +async function createHashmapPermissionManager(admin, master) { const contractName = 'HashmapPermissionManager'; const contractFilename = `${config.libPath}/auth/permission/test/fixtures/HashmapPermissionManager.sol`; const args = { owner: admin.address, master: master.address, } - const hashmapPermissionManager = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args)); + + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) + } + + const hashmapPermissionManager = await createContract(admin, contractArgs, { config }); return hashmapPermissionManager } diff --git a/auth/user/test/user.factory.js b/auth/user/test/user.factory.js index e974b9e..7c7eb2a 100644 --- a/auth/user/test/user.factory.js +++ b/auth/user/test/user.factory.js @@ -1,7 +1,4 @@ -const ba = require('blockapps-rest'); -const util = ba.common.util; - -const createUserArgs = function(accountAddress, uid, role=1) { +const createUserArgs = function (accountAddress, uid, role = 1) { const username = `User_${uid}` // function User(address _account, string _username, uint _role) @@ -13,6 +10,6 @@ const createUserArgs = function(accountAddress, uid, role=1) { return args; } -module.exports = { - createUserArgs: createUserArgs, +export { + createUserArgs } diff --git a/auth/user/test/user.test.js b/auth/user/test/user.test.js index 2ad036e..a5bfe63 100644 --- a/auth/user/test/user.test.js +++ b/auth/user/test/user.test.js @@ -1,47 +1,44 @@ -require('co-mocha'); -const ba = require('blockapps-rest'); -const common = ba.common; -const api = common.api; -const config = common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; -const util = common.util; -const should = common.should; -const assert = common.assert; -const Promise = common.Promise; - -const userJs = require('../user'); -const factory = require('./user.factory'); - -const adminName = util.uid('Admin'); -const adminPassword = '1234'; - -describe('User tests', function() { +import { assert } from 'chai'; +import { rest, util } from 'blockapps-rest'; +const { createUser } = rest; + +import { getYamlFile } from '../../../util/config'; +const config = getYamlFile('config.yaml'); + +import { uploadContract, getUser } from '../user'; +import { createUserArgs } from './user.factory'; +import { getCredentialArgs } from '../../../util/util'; + +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); + +describe('User tests', function () { this.timeout(config.timeout); + const options = { config } let admin; - before(function*() { - admin = yield rest.createUser(adminName, adminPassword); + before(async function () { + admin = await createUser(adminArgs, options); }); - it('Create Contract', function* () { + it('Create Contract', async function () { const uid = util.uid(); // create the user with constructor args - const args = factory.createUserArgs(admin.address, uid); - const contract = yield userJs.uploadContract(admin, args); - const user = yield contract.getState(); + const args = createUserArgs(admin.address, uid); + const contract = await uploadContract(admin, args); + const user = await contract.getState(); assert.equal(user.account, args.account, 'account'); assert.equal(user.username, args.username, 'username'); assert.equal(user.role, args.role, 'role'); }); - it('Search Contract', function* () { + it('Search Contract', async function () { const uid = util.uid(); // create the user with constructor args - const args = factory.createUserArgs(admin.address, uid); - const contract = yield userJs.uploadContract(admin, args); + const args = createUserArgs(admin.address, uid); + const contract = await uploadContract(admin, args); // search - const user = yield userJs.getUser(args.username); + const user = await getUser(args.username); assert.equal(user.account, args.account, 'account'); assert.equal(user.username, args.username, 'username'); assert.equal(user.role, args.role, 'role'); diff --git a/auth/user/test/userManager-load.test.js b/auth/user/test/userManager-load.test.js index dd02994..cc1cea6 100644 --- a/auth/user/test/userManager-load.test.js +++ b/auth/user/test/userManager-load.test.js @@ -1,60 +1,65 @@ -require('co-mocha'); -const ba = require('blockapps-rest'); -const common = ba.common; -const config = common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; -const util = common.util; -const should = common.should; -const assert = common.assert; -const constants = common.constants; -const BigNumber = common.BigNumber; -const Promise = common.Promise; - -const ErrorCodes = rest.getEnums(`${config.libPath}/error/ErrorCodes.sol`).ErrorCodes; -const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`); -const UserRole = rest.getEnums(`${config.libPath}/auth/user/contracts/UserRole.sol`).UserRole; - -const adminName = util.uid('Admin'); -const adminPassword = '1234'; -const userManagerJs = require('../userManager'); -const factory = require('./user.factory'); - -describe('UserManager LOAD tests', function() { +import { assert } from 'chai'; +import { rest, util } from 'blockapps-rest'; +const { createUser } = rest; + +import { getYamlFile } from '../../../util/config'; +const config = getYamlFile('config.yaml'); +import { uploadContract } from '../userManager'; +import { createUserArgs } from './user.factory'; +import { getCredentialArgs } from '../../../util/util'; + +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); + +describe('UserManager LOAD tests', function () { this.timeout(config.timeout); const count = util.getArgInt('--count', 4); + const options = { config } let admin; let contract; // get ready: admin-user and manager-contract - before(function* () { - admin = yield rest.createUser(adminName, adminPassword); - contract = yield userManagerJs.uploadContract(admin); + before(async function () { + admin = await createUser(adminArgs, options); + contract = await uploadContract(admin); }); - it('User address leading zeros - load test - count:' + count, function *() { - this.timeout(60*60*1000); + it('User address leading zeros - load test - count:' + count, async function () { + this.timeout(60 * 60 * 1000); const users = []; const uid = util.uid() * 100; const accountAddress = 1234500; // create users for (let i = 0; i < count; i++) { - const args = factory.createUserArgs(accountAddress+i, uid+i); - const user = yield contract.createUser(args); + const args = createUserArgs(accountAddress + i, uid + i); + const user = await contract.createUser(args); users.push(user); } // get single user for (let user of users) { - const resultUser = yield contract.getUser(user.username); + const resultUser = await contract.getUser(user.username); } // get all users - const resultUsers = yield contract.getUsers(admin, contract); - const comparator = function(a, b) { return a.username == b.username; }; - const notFound = util.filter.isContained(users, resultUsers, comparator, true); + const resultUsers = await contract.getUsers(admin, contract); + const comparator = function (a, b) { return a.username == b.username; }; + const notFound = filter_isContained(users, resultUsers, comparator); assert.equal(notFound.length, 0, JSON.stringify(notFound)); }); }); + +function filter_isContained(setA, setB, comparator, isDebug) { + if (isDebug) { + console.log('setA', setA); + console.log('setB', setB); + } + return setA.filter(function (memberA) { + return !setB.filter(function (memberB) { + // compare + return comparator(memberA, memberB); + }).length > 0; // some items were found in setA that are not included in setB + }); +} \ No newline at end of file diff --git a/auth/user/test/userManager.test.js b/auth/user/test/userManager.test.js index 1bdc944..1b9f0c9 100644 --- a/auth/user/test/userManager.test.js +++ b/auth/user/test/userManager.test.js @@ -1,176 +1,187 @@ -require('co-mocha'); -const ba = require('blockapps-rest'); -const common = ba.common; -const config = common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; -const util = common.util; -const should = common.should; -const assert = common.assert; -const constants = common.constants; -const BigNumber = common.BigNumber; -const Promise = common.Promise; - -const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`); -const UserRole = rest.getEnums(`${config.libPath}/auth/user/contracts/UserRole.sol`).UserRole; - -const adminName = util.uid('Admin'); -const adminPassword = '1234'; -const blocName = util.uid('Bloc'); -const blocPassword = '4567'; -const userManagerJs = require('../userManager'); -const factory = require('./user.factory'); - -describe('UserManager tests', function() { +import { assert } from 'chai'; +import { rest, util, fsUtil, parser } from 'blockapps-rest'; +const { createUser, call } = rest; + +import { getYamlFile } from '../../../util/config'; +const config = getYamlFile('config.yaml'); + +import { uploadContract } from '../userManager'; +import { createUserArgs } from './user.factory'; +import { getCredentialArgs } from '../../../util/util'; + +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); +const blocArgs = getCredentialArgs(util.uid(), 'Bloc', '4567'); + +describe('UserManager tests', function () { this.timeout(config.timeout); + const options = { config } + let admin; let contract; let account; + let RestStatus; // get ready: admin-user and manager-contract - before(function* () { - admin = yield rest.createUser(adminName, adminPassword); - contract = yield userManagerJs.uploadContract(admin); + before(async function () { + // Parse fields + const restStatusSource = fsUtil.get(`${util.cwd}/rest/contracts/RestStatus.sol`) + RestStatus = await parser.parseFields(restStatusSource); + + admin = await createUser(adminArgs, options); + contract = await uploadContract(admin); // bloc account must be created separately - account = yield rest.createUser(blocName, blocPassword); + account = await createUser(blocArgs, options); }); - it('Create User', function* () { + it('Create User', async function () { const uid = util.uid(); // create user with the bloc account - const args = factory.createUserArgs(account.address, uid); - const user = yield contract.createUser(args); + const args = createUserArgs(account.address, uid); + const user = await contract.createUser(args); assert.equal(user.account, args.account, 'account'); assert.equal(user.username, args.username, 'username'); assert.equal(user.role, args.role, 'role'); }); - it('Create User - UNAUTHORIZED', function*() { + it('Create User - UNAUTHORIZED', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); - const attacker = yield rest.createUser('Attacker_'+uid, ''+uid); + const args = createUserArgs(account.address, uid); + const attackerArgs = getCredentialArgs(uid, 'Attacker', '1234'); + const attacker = await rest.createUser(attackerArgs, options); + + const callArgs = { + contract, + method: 'createUser', + args: util.usc(args) + } // create user UNAUTHORIZED - const method = 'createUser'; - const [restStatus, address] = yield rest.callMethod(attacker, contract, method, util.usc(args)); + const [restStatus] = await call(attacker, callArgs, options); assert.equal(restStatus, RestStatus.UNAUTHORIZED, 'should fail'); }); - it('Create User - illegal name', function* () { + it('Create User - illegal name', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); args.username = '123456789012345678901234567890123'; // 33 chars - yield assert.shouldThrowRest(function*() { - return yield contract.createUser(args); - }, RestStatus.BAD_REQUEST); + + try { + await contract.createUser(args); + } catch (e) { + assert.equal(e.response.status, RestStatus.BAD_REQUEST, 'should Throws 404 Not found') + } }); - it('Test exists()', function* () { + it('Test exists()', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); let exists; // should not exist - exists = yield contract.exists(args.username); + exists = await contract.exists(args.username); assert.isDefined(exists, 'should be defined'); assert.isNotOk(exists, 'should not exist'); // create user - const user = yield contract.createUser(args); + const user = await contract.createUser(args); // should exist - exists = yield contract.exists(args.username); + exists = await contract.exists(args.username); assert.equal(exists, true, 'should exist') }); - it('Test exists() with special characters', function* () { + it('Test exists() with special characters', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); args.username += ' ?#%!@*'; let exists; // should not exist - exists = yield contract.exists(args.username); + exists = await contract.exists(args.username); assert.isDefined(exists, 'should be defined'); assert.isNotOk(exists, 'should not exist'); // create user - const user = yield contract.createUser(args); + const user = await contract.createUser(args); // should exist - exists = yield contract.exists(args.username); + exists = await contract.exists(args.username); assert.equal(exists, true, 'should exist') }); - it('Create Duplicate User', function* () { + it('Create Duplicate User', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); - // create user - const user = yield contract.createUser(args); - yield assert.shouldThrowRest(function*() { - const user = yield contract.createUser(args); - }, RestStatus.BAD_REQUEST); + try { + await contract.createUser(args); + } catch (e) { + assert.equal(e.response.status, RestStatus.BAD_REQUEST, 'should Throws 404 Not found') + } }); - it('Get User', function *() { + it('Get User', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); // get non-existing user - yield assert.shouldThrowRest(function*() { - const user = yield contract.getUser(args.username); - }, RestStatus.NOT_FOUND); + try { + await contract.getUser(args.username); + } catch (e) { + assert.equal(e.response.status, RestStatus.NOT_FOUND, 'should Throws 404 Not found') + } // create user - yield contract.createUser(args); + await contract.createUser(args); // get user - should exist - const user = yield contract.getUser(args.username); + const user = await contract.getUser(args.username); assert.equal(user.username, args.username, 'username should be found'); }); - it('Get Users', function* () { + it('Get Users', async function () { const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); // get users - should not exist { - const users = yield contract.getUsers(); - const found = users.filter(function(user) { + const users = await contract.getUsers(); + const found = users.filter(function (user) { return user.username === args.username; }); assert.equal(found.length, 0, 'user list should NOT contain ' + args.username); } // create user - const user = yield contract.createUser(args); + const user = await contract.createUser(args); // get user - should exist { - const users = yield contract.getUsers(admin, contract); - const found = users.filter(function(user) { + const users = await contract.getUsers(admin, contract); + const found = users.filter(function (user) { return user.username === args.username; }); assert.equal(found.length, 1, 'user list should contain ' + args.username); } }); - it.skip('User address leading zeros - load test - skipped', function *() { - this.timeout(60*60*1000); + // TODO: we can remove this as we are checking the same in userManager-load.test.js. @lior please confirm + it.skip('User address leading zeros - load test - skipped', async function () { + this.timeout(60 * 60 * 1000); const uid = util.uid(); - const args = factory.createUserArgs(account.address, uid); + const args = createUserArgs(account.address, uid); const username = args.username; - const count = 16*4; // leading 0 once every 16 + const count = 16 * 4; // leading 0 once every 16 const users = []; // create users for (let i = 0; i < count; i++) { args.username = username + '_' + i; - const user = yield contract.createUser(args); + const user = await contract.createUser(args); users.push(user); } // get single user for (let user of users) { - const resultUser = yield contract.getUser(user.username); + const resultUser = await contract.getUser(user.username); } // get all users - const resultUsers = yield contract.getUsers(admin, contract); - const comparator = function(a, b) { return a.username == b.username; }; + const resultUsers = await contract.getUsers(admin, contract); + const comparator = function (a, b) { return a.username == b.username; }; const notFound = util.filter.isContained(users, resultUsers, comparator, true); assert.equal(notFound.length, 0, JSON.stringify(notFound)); }); diff --git a/auth/user/user.js b/auth/user/user.js index 0f149a6..e87a29a 100644 --- a/auth/user/user.js +++ b/auth/user/user.js @@ -1,79 +1,104 @@ -const ba = require('blockapps-rest'); -const util = ba.common.util; -const config = ba.common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import { rest, util, importer } from 'blockapps-rest'; +const { createContract, getState, call, searchUntil } = rest; + +import { getYamlFile } from '../../util/config'; +const config = getYamlFile('config.yaml'); + +const options = { config }; const contractName = 'User'; -const contractFilename = `${ba.common.cwd}/${config.libPath}/auth/user/contracts/User.sol`; +const contractFilename = `${util.cwd}/${config.libPath}/auth/user/contracts/User.sol`; -const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`); -const UserRole = rest.getEnums(`${config.libPath}/auth/user/contracts/UserRole.sol`).UserRole; +async function uploadContract(admin, args) { + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) + } -function* uploadContract(admin, args) { - const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args)); - yield compileSearch(contract); + const contract = await createContract(admin, contractArgs, options); contract.src = 'removed'; return bind(admin, contract); } function bind(admin, contract) { - contract.getState = function* () { - return yield rest.getState(contract); + contract.getState = async function () { + return await getState(contract, options); } - contract.authenticate = function* (pwHash) { - return yield authenticate(admin, contract, pwHash); + contract.authenticate = async function (pwHash) { + return await authenticate(admin, contract, pwHash); } return contract; } -function* compileSearch(contract) { - rest.verbose('compileSearch', contractName); +async function getUsers(addresses) { // FIXME must break to batches of 50 addresses + const csv = util.toCsv(addresses); // generate csv string - if (yield rest.isSearchable(contract.codeHash)) { - return; + function predicate(response) { + return response; } - const searchable = [contractName]; - yield rest.compileSearch(searchable, contractName, contractFilename); -} -function* getUsers(addresses) { // FIXME must break to batches of 50 addresses - const csv = util.toCsv(addresses); // generate csv string - const results = yield rest.query(`${contractName}?address=in.${csv}`); + const contract = { + name: contractName + } + const results = await searchUntil(contract, predicate, { config, query: { address: `in.${csv}` } }); return results; } -function* getUser(username) { - return (yield rest.waitQuery(`${contractName}?username=eq.${username}`, 1))[0]; +async function getUser(username) { + function predicate(response) { + if (response.length >= 1) { + return response; + } + } + + const contract = { + name: contractName + } + + const response = (await searchUntil(contract, predicate, { config, query: { username: `eq.${username}` } }))[0]; + return response; } -function* getUserByAddress(address) { - return (yield rest.waitQuery(`${contractName}?address=eq.${address}`, 1))[0]; +async function getUserByAddress(address) { + function predicate(response) { + if (response.length >= 1) { + return response; + } + } + + const contract = { + name: contractName, address + } + const response = (await searchUntil(contract, predicate, { config, query: { address: `eq.${address}` } }))[0]; + return response; } -function* authenticate(admin, contract, pwHash) { - rest.verbose('authenticate', pwHash); +async function authenticate(admin, contract, pwHash) { // function authenticate(bytes32 _pwHash) return (bool) { - const method = 'authenticate'; const args = { - _pwHash: pwHash, + pwHash: pwHash, }; - const result = yield rest.callMethod(admin, contract, method, args); + const callArgs = { + contract, + method: 'authenticate', + args: util.usc(args) + } + const result = await call(admin, callArgs, options); const isAuthenticated = (result[0] === true); return isAuthenticated; } -module.exports = { - uploadContract: uploadContract, - bind: bind, - compileSearch: compileSearch, - +export { + uploadContract, + bind, // constants - contractName: contractName, + contractName, // business logic - authenticate: authenticate, - getUserByAddress: getUserByAddress, - getUsers: getUsers, - getUser: getUser, + authenticate, + getUserByAddress, + getUsers, + getUser }; diff --git a/auth/user/userManager.js b/auth/user/userManager.js index 31a168a..f1fcb23 100644 --- a/auth/user/userManager.js +++ b/auth/user/userManager.js @@ -1,128 +1,132 @@ -const ba = require('blockapps-rest'); -const util = ba.common.util; -const BigNumber = ba.common.BigNumber; -const config = ba.common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; -const cwd = ba.common.cwd; +import RestStatus from 'http-status-codes'; +import { rest, util, importer } from 'blockapps-rest'; +const { createContract, getState, call, RestError } = rest; + +import { getYamlFile } from '../../util/config'; +const config = getYamlFile('config.yaml'); const contractName = 'UserManager'; -const contractFilename = `${cwd}/${config.libPath}/auth/user/contracts/UserManager.sol`; +const contractFilename = `${util.cwd}/${config.libPath}/auth/user/contracts/UserManager.sol`; + +const options = { config }; -const RestStatus = rest.getFields(`${config.libPath}/rest/contracts/RestStatus.sol`); -const UserRole = rest.getEnums(`${config.libPath}/auth/user/contracts/UserRole.sol`).UserRole; -const userJs = require(`${cwd}/${config.libPath}/auth/user/user`); +import * as userJs from './user'; -function* uploadContract(admin) { +async function uploadContract(admin) { // NOTE: in production, the contract is created and owned by the AdminInterface // for testing purposes the creator is the admin user - const args = { _owner: admin.address }; - const contract = yield rest.uploadContract(admin, contractName, contractFilename, args); - yield compileSearch(contract); + const args = { owner: admin.address }; + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) + } + const contract = await createContract(admin, contractArgs, options); contract.src = 'removed'; return bind(admin, contract); } function bind(admin, contract) { - contract.getState = function* () { - return yield rest.getState(contract); + contract.getState = async function () { + return await getState(contract, options); } - contract.createUser = function* (args) { - return yield createUser(admin, contract, args); + contract.createUser = async function (args) { + return await createUser(admin, contract, args); } - contract.exists = function* (username) { - return yield exists(admin, contract, username); + contract.exists = async function (username) { + return await exists(admin, contract, username); } - contract.getUser = function* (username) { - return yield getUser(admin, contract, username); + contract.getUser = async function (username) { + return await getUser(admin, contract, username); } - contract.getUsers = function* () { - return yield getUsers(admin, contract); + contract.getUsers = async function () { + return await getUsers(admin, contract); } - contract.authenticate = function* (args) { - return yield authenticate(admin, contract, args); + contract.authenticate = async function (args) { + return await authenticate(admin, contract, args); } return contract; } -function* compileSearch(contract) { - rest.verbose('compileSearch', contractName); - if (yield rest.isSearchable(contract.codeHash)) { - return; - } - // compile + dependencies - const searchable = [userJs.contractName, contractName]; - yield rest.compileSearch(searchable, contractName, contractFilename); - -} - // throws: RestStatus // returns: user record from search -function* createUser(admin, contract, args) { - rest.verbose('createUser', args); - +async function createUser(admin, contract, args) { // function createUser(address account, string username, bytes32 pwHash, uint role) returns (ErrorCodes) { - const method = 'createUser'; + const callArgs = { + contract, + method: 'createUser', + args: util.usc(args) + } // create the user, with the eth account - const [restStatus, address] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const [restStatus] = await call(admin, callArgs, options); if (restStatus != RestStatus.CREATED) { - throw new rest.RestError(restStatus, method, args); + throw new RestError(restStatus, callArgs.method, callArgs.args); } // block until the user shows up in search - const user = yield getUser(admin, contract, args.username); + const user = await getUser(admin, contract, args.username); return user; } -function* exists(admin, contract, username) { - rest.verbose('exists', username); +async function exists(admin, contract, username) { // function exists(string username) returns (bool) { - const method = 'exists'; const args = { username: username, }; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); + + const callArgs = { + contract, + method: 'exists', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); const exist = (result[0] === true); return exist; } -function* getUser(admin, contract, username) { - rest.verbose('getUser', username); +async function getUser(admin, contract, username) { // function getUser(string username) returns (address) { - const method = 'getUser'; const args = { username: username, }; + const callArgs = { + contract, + method: 'getUser', + args: util.usc(args) + } + // get the use address - const [address] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const [address] = await call(admin, callArgs, options); if (address == 0) { - throw new rest.RestError(RestStatus.NOT_FOUND, method, args); + throw new RestError(RestStatus.NOT_FOUND, callArgs.method, args); } // found - query for the full user record - return yield userJs.getUserByAddress(address); + return await userJs.getUserByAddress(address); } -function* getUsers(admin, contract) { - rest.verbose('getUsers'); - const {users: usersHashmap} = yield rest.getState(contract); - const {values} = yield rest.getState({name: 'Hashmap', address:usersHashmap}); +async function getUsers(admin, contract) { + const { users: usersHashmap } = await rest.getState(contract, options); + const { values } = await getState({ name: 'Hashmap', address: usersHashmap }, options); const addresses = values.slice(1); - return yield userJs.getUsers(addresses); + return await userJs.getUsers(addresses); } -function* authenticate(admin, contract, args) { - rest.verbose('authenticate', args); - +async function authenticate(admin, contract, args) { // function authenticate(string _username, bytes32 _pwHash) returns (bool) { - const method = 'authenticate'; - const [result] = yield rest.callMethod(admin, contract, method, util.usc(args)); + const callArgs = { + contract, + method: 'authenticate', + args: util.usc(args) + } + const [result] = await call(admin, callArgs, options); const isOK = (result == true); return isOK; } -module.exports = { - uploadContract: uploadContract, - compileSearch: compileSearch, - contractName: contractName, - bind: bind, +export default { + uploadContract, + contractName, + bind }; diff --git a/collections/hashmap/hashmap.js b/collections/hashmap/hashmap.js index 383f803..92f631b 100644 --- a/collections/hashmap/hashmap.js +++ b/collections/hashmap/hashmap.js @@ -1,96 +1,130 @@ -const ba = require('blockapps-rest'); -const util = ba.common.util; -const config = ba.common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import { rest, util, importer } from 'blockapps-rest'; +const { createContract, getState, call } = rest; + +import { getYamlFile } from '../../util/config'; +const config = getYamlFile('config.yaml'); const contractName = 'Hashmap'; const contractFilename = `${config.libPath}/collections/hashmap/contracts/Hashmap.sol`; -function* uploadContract(admin) { +const options = { config }; + +async function uploadContract(admin) { const args = {}; - const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args)); + + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) + } + + const contract = await createContract(admin, contractArgs, options); contract.src = 'removed'; return bind(admin, contract); } function bind(admin, contract) { - contract.getState = function* () { - return yield rest.getState(contract); + contract.getState = async function () { + return await getState(contract, options); } - contract.getStateVar = function* (args) { - return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length); + contract.getStateVar = async function (args) { + return await rest.getStateVar(contract, args.name, args.count, args.offset, args.length); } - contract.put = function* (args) { - return yield put(admin, contract, args); + contract.put = async function (args) { + return await put(admin, contract, args); } - contract.get = function* (args) { - return yield get(admin, contract, args); + contract.get = async function (args) { + return await get(admin, contract, args); } - contract.contains = function* (args) { - return yield contains(admin, contract, args); + contract.contains = async function (args) { + return await contains(admin, contract, args); } - contract.size = function* (args) { - return yield size(admin, contract, args); + contract.size = async function (args) { + return await size(admin, contract, args); } - contract.transferOwnership = function* (args) { - return yield transferOwnership(admin, contract, args); + contract.transferOwnership = async function (args) { + return await transferOwnership(admin, contract, args); } - contract.getOwner = function* (args) { - return yield getOwner(admin, contract, args); + contract.getOwner = async function (args) { + return await getOwner(admin, contract, args); } return contract; } -function* put(admin, contract, args) { - rest.verbose('put', args); - const method = 'put'; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function put(admin, contract, args) { + const callArgs = { + contract, + method: 'put', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); return result; } -function* get(admin, contract, args) { - rest.verbose('get', args); - const method = 'get'; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function get(admin, contract, args) { + const callArgs = { + contract, + method: 'get', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); return result[0]; } -function* contains(admin, contract, args) { - rest.verbose('contains', args); - const method = 'contains'; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function contains(admin, contract, args) { + const callArgs = { + contract, + method: 'contains', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); return result[0] == true; } -function* size(admin, contract, args) { - rest.verbose('size', args); - const method = 'size'; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function size(admin, contract, args) { + const callArgs = { + contract, + method: 'size', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); return parseInt(result[0]); } -function* transferOwnership(admin, contract, args) { - rest.verbose('transferOwnership', args); - const method = 'transferOwnership'; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function transferOwnership(admin, contract, args) { + const callArgs = { + contract, + method: 'transferOwnership', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); return result[0] == true; } -function* getOwner(admin, contract, args) { - rest.verbose('getOwner', args); - const method = 'getOwner'; - const result = yield rest.callMethod(admin, contract, method, util.usc(args)); +async function getOwner(admin, contract, args) { + const callArgs = { + contract, + method: 'getOwner', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options); return result[0]; } -module.exports = { - bind: bind, - uploadContract: uploadContract, - put: put, - get: get, - contains: contains, - size: size, - transferOwnership: transferOwnership, - getOwner: getOwner, +export { + bind, + uploadContract, + put, + get, + contains, + size, + transferOwnership, + getOwner, }; diff --git a/collections/hashmap/test/hashmap.test.js b/collections/hashmap/test/hashmap.test.js index 9c10ade..1fcfefa 100644 --- a/collections/hashmap/test/hashmap.test.js +++ b/collections/hashmap/test/hashmap.test.js @@ -1,142 +1,141 @@ -require('co-mocha'); -const ba = require('blockapps-rest'); -const common = ba.common; -const config = common.config; -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; -const util = common.util; -const assert = common.assert; +import { assert } from 'chai'; +import { rest, util } from 'blockapps-rest'; +import { getYamlFile } from '../../../util/config'; +import * as hashmapJs from '../hashmap'; +import { getCredentialArgs } from '../../../util/util'; -const hashmapJs = require('../hashmap'); +const { createUser } = rest; +const config = getYamlFile('config.yaml'); -const adminName = util.uid('Admin'); -const adminPassword = '1234'; +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); +const otherAdminArgs = getCredentialArgs(util.uid(), 'OtherAdmin', '5678'); -const otherAdminName = util.uid('OtherAdmin'); -const otherAdminPassword = '5678'; - -describe('Hashmap', function() { +describe('Hashmap', function () { this.timeout(config.timeout); + const options = { config }; let admin; let otherAdmin; - before(function*() { - admin = yield rest.createUser(adminName, adminPassword); - otherAdmin = yield rest.createUser(otherAdminName, otherAdminPassword); + before(async function () { + console.log('creating admin') + admin = await createUser(adminArgs, options); + console.log('creating user') + otherAdmin = await createUser(otherAdminArgs, options); }); - it('getOwner', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); - const owner = yield hashmap.getOwner(); + it('getOwner', async function () { + const hashmap = await hashmapJs.uploadContract(admin); + const owner = await hashmap.getOwner({}); assert.equal(owner.toString(), admin.address); }); - it('put', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('put', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - const state = yield hashmap.getState(); + await hashmap.put(args); + const state = await hashmap.getState(); assert.equal(state.values.length, 2, 'length 2'); assert.equal(parseInt(state.values[1]), parseInt(args.value), 'value'); }); - it('get', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('get', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - const value = yield hashmap.get({key: args.key}); + await hashmap.put(args); + const value = await hashmap.get({ key: args.key }); assert.equal(parseInt(value), parseInt(args.value), 'value'); - const notFound = yield hashmap.get({key: '666'}); + const notFound = await hashmap.get({ key: '666' }); assert.equal(parseInt(notFound), 0, 'not found'); }); - it('contains', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('contains', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - const result = yield hashmap.contains({key: args.key}); + await hashmap.put(args); + const result = await hashmap.contains({ key: args.key }); assert.equal(result, true, 'contains: true'); - const notFound = yield hashmap.contains({key: '666'}); + const notFound = await hashmap.contains({ key: '666' }); assert.equal(notFound, false, 'contains: false'); }); - it('size', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('size', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - const size1 = yield hashmap.size(); + await hashmap.put(args); + const size1 = await hashmap.size({}); assert.equal(size1, 1, 'size: 1'); args.key += 'x'; - yield hashmap.put(args); - const size2 = yield hashmap.size(); + await hashmap.put(args); + const size2 = await hashmap.size({}); assert.equal(size2, 2, 'size: 2'); }); - it('transferOwnership to otherAdmin', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); - yield hashmap.transferOwnership({newOwner: otherAdmin.address}); - const owner = yield hashmap.getOwner(); + it('transferOwnership to otherAdmin', async function () { + const hashmap = await hashmapJs.uploadContract(admin); + await hashmap.transferOwnership({ newOwner: otherAdmin.address }); + const owner = await hashmap.getOwner({}); assert.notEqual(owner.toString(), admin.address); assert.equal(owner.toString(), otherAdmin.address); }); - it('reject get from original admin', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('reject get from original admin', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - yield hashmap.transferOwnership({newOwner: otherAdmin.address}); + await hashmap.put(args); + await hashmap.transferOwnership({ newOwner: otherAdmin.address }); - const result = yield hashmap.get({key: args.key}); + const result = await hashmap.get({ key: args.key }); assert.equal(result.toString(), "0000000000000000000000000000000000000000"); }); - it('reject put from original admin', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); - yield hashmap.transferOwnership({newOwner: otherAdmin.address}); + it('reject put from original admin', async function () { + const hashmap = await hashmapJs.uploadContract(admin); + await hashmap.transferOwnership({ newOwner: otherAdmin.address }); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - const result = yield hashmapJs.get(otherAdmin, hashmap, {key: args.key}) + await hashmap.put(args); + const result = await hashmapJs.get(otherAdmin, hashmap, { key: args.key }) assert.equal(result.toString(), "0000000000000000000000000000000000000000"); - const result2 = yield hashmapJs.size(otherAdmin, hashmap, {key: args.key}) + const result2 = await hashmapJs.size(otherAdmin, hashmap, { key: args.key }) assert.equal(result2, 0); }); - it('reject contains from original admin', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('reject contains from original admin', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - yield hashmap.transferOwnership({newOwner: otherAdmin.address}); + await hashmap.put(args); + await hashmap.transferOwnership({ newOwner: otherAdmin.address }); - const result = yield hashmap.contains({key: args.key}); + const result = await hashmap.contains({ key: args.key }); assert.equal(result, false); }); - it('reject size from original admin', function*() { - const hashmap = yield hashmapJs.uploadContract(admin); + it('reject size from original admin', async function () { + const hashmap = await hashmapJs.uploadContract(admin); const iuid = util.iuid(); const args = factory.createEntity(iuid); - yield hashmap.put(args); - yield hashmap.transferOwnership({newOwner: otherAdmin.address}); + await hashmap.put(args); + await hashmap.transferOwnership({ newOwner: otherAdmin.address }); - const result = yield hashmap.size(); + const result = await hashmap.size({}); assert.equal(result, 0) }); - it('reject transferOwnership from original admin', function*() { - const newAdmin = yield rest.createUser(util.uid('newAdmin'), '4321'); - const hashmap = yield hashmapJs.uploadContract(admin); - yield hashmap.transferOwnership({newOwner: otherAdmin.address}); + it('reject transferOwnership from original admin', async function () { + const newAdmin = await createUser({ username: util.uid('newAdmin'), password: '4321' }, options); + const hashmap = await hashmapJs.uploadContract(admin); + await hashmap.transferOwnership({ newOwner: otherAdmin.address }); - const result = yield hashmap.transferOwnership({newOwner: newAdmin.address}); + const result = await hashmap.transferOwnership({ newOwner: newAdmin.address }); assert.equal(result, false); }); }); diff --git a/collections/hashmap/test/unsafeHashmap.test.js b/collections/hashmap/test/unsafeHashmap.test.js index 2d61120..44f653e 100644 --- a/collections/hashmap/test/unsafeHashmap.test.js +++ b/collections/hashmap/test/unsafeHashmap.test.js @@ -1,90 +1,92 @@ -require('co-mocha') +import { assert } from 'chai'; +import { rest, util } from 'blockapps-rest'; +import { getYamlFile } from '../../../util/config'; +import * as unsafeHashmapJs from '../unsafeHashmap'; +import { getCredentialArgs } from '../../../util/util'; -const ba = require('blockapps-rest') -const { config, util, assert } = ba.common -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +const { createUser } = rest; +const config = getYamlFile('config.yaml'); -const unsafeHashmapJs = require('../unsafeHashmap') - -const adminName = util.uid('Admin') -const adminPassword = '1234' +const adminArgs = getCredentialArgs(util.uid(), 'Admin', '1234'); describe('UnsafeHashmap', function () { this.timeout(config.timeout) + const options = { config }; let admin - before(function* () { - admin = yield rest.createUser(adminName, adminPassword) + before(async function () { + console.log('creating admin') + admin = await createUser(adminArgs, options) }) - it('put', function* () { - const hashmap = yield unsafeHashmapJs.uploadContract(admin) + it('put', async function () { + const hashmap = await unsafeHashmapJs.uploadContract(admin) const iuid = util.iuid() const args = factory.createEntity(iuid) - yield hashmap.put(args) - const state = yield hashmap.getState() + await hashmap.put(args) + const state = await hashmap.getState() assert.equal(state.values.length, 2, 'length 2') assert.equal(parseInt(state.values[1]), parseInt(args.value), 'value') }) - it('get', function* () { - const hashmap = yield unsafeHashmapJs.uploadContract(admin) + it('get', async function () { + const hashmap = await unsafeHashmapJs.uploadContract(admin) const iuid = util.iuid() const args = factory.createEntity(iuid) - yield hashmap.put(args) - const value = yield hashmap.get({ key: args.key }) + await hashmap.put(args) + const value = await hashmap.get({ key: args.key }) assert.equal(parseInt(value), parseInt(args.value), 'value') - const notFound = yield hashmap.get({ key: '666' }) + const notFound = await hashmap.get({ key: '666' }) assert.equal(parseInt(notFound), 0, 'not found') }) - it('contains', function* () { - const hashmap = yield unsafeHashmapJs.uploadContract(admin) + it('contains', async function () { + const hashmap = await unsafeHashmapJs.uploadContract(admin) const iuid = util.iuid() const args = factory.createEntity(iuid) - yield hashmap.put(args) - const result = yield hashmap.contains({ key: args.key }) + await hashmap.put(args) + const result = await hashmap.contains({ key: args.key }) assert.equal(result, true, 'contains: true') - const notFound = yield hashmap.contains({ key: '666' }) + const notFound = await hashmap.contains({ key: '666' }) assert.equal(notFound, false, 'contains: false') }) - it('size', function* () { - const hashmap = yield unsafeHashmapJs.uploadContract(admin) + it('size', async function () { + const hashmap = await unsafeHashmapJs.uploadContract(admin) const iuid = util.iuid() const args = factory.createEntity(iuid) - yield hashmap.put(args) - const size1 = yield hashmap.size() + await hashmap.put(args) + const size1 = await hashmap.size({}) assert.equal(size1, 1, 'size: 1') args.key += 'x' - yield hashmap.put(args) - const size2 = yield hashmap.size() + await hashmap.put(args) + const size2 = await hashmap.size({}) assert.equal(size2, 2, 'size: 2') }) - it('remove', function* () { - const hashmap = yield unsafeHashmapJs.uploadContract(admin) + it('remove', async function () { + const hashmap = await unsafeHashmapJs.uploadContract(admin) const iuid = util.iuid() const count = 5; for (let i = 0; i < count; i++) { const args = factory.createEntity(iuid * 10 + i) - yield hashmap.put(args) + await hashmap.put(args) } - const { values } = yield hashmap.getState() + const { values } = await hashmap.getState() assert.equal(values.length, count + 1, 'length') // remove { const target = 2; const args = factory.createEntity(iuid * 10 + target) - yield hashmap.remove({ key: args.key }) - const { values } = yield hashmap.getState() - assert.equal(parseInt(values[target+1]), 0, 'zero now') + await hashmap.remove({ key: args.key }) + const { values } = await hashmap.getState() + assert.equal(parseInt(values[target + 1]), 0, 'zero now') // get removed element - const value = yield hashmap.get({ key: args.key }) + const value = await hashmap.get({ key: args.key }) assert.equal(parseInt(value), 0, 'zero') // contains removed element - const contains = yield hashmap.contains({ key: args.key }) + const contains = await hashmap.contains({ key: args.key }) assert.equal(contains, false, 'not contained') } }) diff --git a/collections/hashmap/unsafeHashmap.js b/collections/hashmap/unsafeHashmap.js index cb77542..b68aacc 100644 --- a/collections/hashmap/unsafeHashmap.js +++ b/collections/hashmap/unsafeHashmap.js @@ -1,79 +1,109 @@ -const ba = require('blockapps-rest') -const { config, util } = ba.common -const rest = ba[`rest${config.restVersion ? config.restVersion : ''}`]; +import { rest, util, importer } from 'blockapps-rest'; +const { createContract, getState, call } = rest; + +import { getYamlFile } from '../../util/config'; +const config = getYamlFile('config.yaml'); const contractName = 'UnsafeHashmap' const contractFilename = `${config.libPath}/collections/hashmap/contracts/UnsafeHashmap.sol` +const options = { config } -function* uploadContract(admin) { +async function uploadContract(admin) { const args = {} - const contract = yield rest.uploadContract(admin, contractName, contractFilename, util.usc(args)) + + const contractArgs = { + name: contractName, + source: await importer.combine(contractFilename), + args: util.usc(args) + } + + const contract = await createContract(admin, contractArgs, options) contract.src = 'removed' return bind(admin, contract) } function bind(admin, _contract) { const contract = _contract - contract.getState = function* () { - return yield rest.getState(contract) + contract.getState = async function () { + return await getState(contract, options) } - contract.getStateVar = function* (args) { - return yield rest.getStateVar(contract, args.name, args.count, args.offset, args.length) + contract.getStateVar = async function (args) { + return await rest.getStateVar(contract, args.name, args.count, args.offset, args.length) } - contract.put = function* (args) { - return yield put(admin, contract, args) + contract.put = async function (args) { + return await put(admin, contract, args) } - contract.get = function* (args) { - return yield get(admin, contract, args) + contract.get = async function (args) { + return await get(admin, contract, args) } - contract.contains = function* (args) { - return yield contains(admin, contract, args) + contract.contains = async function (args) { + return await contains(admin, contract, args) } - contract.size = function* (args) { - return yield size(admin, contract, args) + contract.size = async function (args) { + return await size(admin, contract, args) } - contract.remove = function* (args) { - return yield remove(admin, contract, args) + contract.remove = async function (args) { + return await remove(admin, contract, args) } return contract } -function* put(admin, contract, args) { - rest.verbose('put', args) - const method = 'put' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function put(admin, contract, args) { + const callArgs = { + contract, + method: 'put', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return result } -function* get(admin, contract, args) { - rest.verbose('get', args) - const method = 'get' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function get(admin, contract, args) { + const callArgs = { + contract, + method: 'get', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return result[0] } -function* contains(admin, contract, args) { - rest.verbose('contains', args) - const method = 'contains' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function contains(admin, contract, args) { + const callArgs = { + contract, + method: 'contains', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return result[0] == true } -function* size(admin, contract, args) { - rest.verbose('size', args) - const method = 'size' - const result = yield rest.callMethod(admin, contract, method, util.usc(args)) +async function size(admin, contract, args) { + const callArgs = { + contract, + method: 'size', + args: util.usc(args) + } + + const result = await call(admin, callArgs, options) return parseInt(result[0]) } -function* remove(admin, contract, args) { - rest.verbose('remove', args) - const method = 'remove' - yield rest.callMethod(admin, contract, method, util.usc(args)) +async function remove(admin, contract, args) { + const callArgs = { + contract, + method: 'remove', + args: util.usc(args) + } + + await call(admin, callArgs, options) } -module.exports = { +export { bind, uploadContract, } diff --git a/config.yaml b/config.yaml index 92561cc..4635868 100644 --- a/config.yaml +++ b/config.yaml @@ -8,7 +8,6 @@ restVersion: 5 # node 0 is the default url for all single node api calls nodes: - id: 0 - explorerUrl: 'http://localhost:9000' - stratoUrl: 'http://localhost/strato-api' - blocUrl: 'http://localhost/bloc/v2.2' - searchUrl: 'http://localhost/cirrus' + url: 'http://localhost' + publicKey: '6d8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0' + port: 30303 diff --git a/package.json b/package.json index 43608e3..db796ac 100644 --- a/package.json +++ b/package.json @@ -4,10 +4,11 @@ "description": "BlockApps Solidity Lib", "main": "", "scripts": { - "test": "find . -type f -name '*.test.js' ! -path './node_modules/*' | xargs mocha ", - "test:hashmap": "mocha collections/hashmap/test/hashmap.test.js --config config.yaml -b", - "test:permission": "mocha auth/permission-manager/test/ --config config.yaml -b --api-debug", - "test:user": "mocha auth/user/test/ --config config.yaml -b ", + "mocha-babel": "node_modules/.bin/mocha --require @babel/register", + "test": "yarn test:hashmap && yarn test:permission && yarn test:user", + "test:hashmap": "yarn mocha-babel collections/hashmap/test/ --config config.yaml -b", + "test:permission": "yarn mocha-babel auth/permission/test/ --config config.yaml -b --api-debug", + "test:user": "yarn mocha-babel auth/user/test/ --config config.yaml -b ", "test:solc": "find . -name '*.sol' -print | xargs solc --allow-paths '.' 2>&1" }, "repository": { @@ -21,15 +22,21 @@ }, "homepage": "https://github.com/blockapps/blockapps-sol#readme", "dependencies": { - "blockapps-rest": "git://github.com/blockapps/blockapps-rest.git", + "@babel/cli": "^7.2.3", + "@babel/core": "^7.3.4", + "@babel/node": "^7.2.2", + "@babel/preset-env": "^7.3.4", + "@babel/register": "^7.0.0", + "blockapps-rest": "alpha", + "chai": "^4.0.2", "eslint": "^4.19.1", "eslint-config-airbnb": "^17.0.0", "eslint-plugin-import": "^2.13.0", "eslint-plugin-jsx-a11y": "^6.0.3", "eslint-plugin-react": "^7.10.0", - "chai": "^4.0.2", - "co": "^4.6.0", - "co-mocha": "^1.2.0", + "fs": "^0.0.1-security", + "http-status-codes": "^1.3.2", + "js-yaml": "^3.12.2", "mocha": "^3.4.2" } } diff --git a/rest/contracts/RestStatus.sol b/rest/contracts/RestStatus.sol index 1bd148f..b546900 100644 --- a/rest/contracts/RestStatus.sol +++ b/rest/contracts/RestStatus.sol @@ -6,13 +6,15 @@ contract RestStatus { uint constant OK = 200; uint constant CREATED = 201; uint constant ACCEPTED = 202; - uint constant CLIENT_ERROR = 400; // 4xx + // TODO: Geting: Duplicate expressions value. var:INTERNAL_SERVER_ERROR value:500 (that's why commented out) + // uint constant CLIENT_ERROR = 400; // 4xx uint constant BAD_REQUEST = 400; uint constant UNAUTHORIZED = 401; uint constant FORBIDDEN = 403; uint constant NOT_FOUND = 404; uint constant CONFLICT = 409; - uint constant SERVER_ERROR = 500; // 5xx + // TODO: Geting: Duplicate expressions value. var:INTERNAL_SERVER_ERROR value:500 (that's why commented out) + // uint constant SERVER_ERROR = 500; // 5xx uint constant INTERNAL_SERVER_ERROR = 500; uint constant BAD_GATEWAY = 502; uint constant GATEWAY_TIMEOUT = 504; diff --git a/util/config.js b/util/config.js new file mode 100644 index 0000000..33f2f96 --- /dev/null +++ b/util/config.js @@ -0,0 +1,12 @@ +// QUEST: is this function is good to be here or we can move to rest ? +import fs from 'fs'; +import yaml from 'js-yaml'; + +// read a yaml or die +function getYamlFile(yamlFilename) { + return yaml.safeLoad(fs.readFileSync(yamlFilename, 'utf8')); +} + +export { + getYamlFile +}; diff --git a/util/util.js b/util/util.js new file mode 100644 index 0000000..30173e9 --- /dev/null +++ b/util/util.js @@ -0,0 +1,12 @@ +const getCredentialArgs = function (uid, name, password) { + const username = `${name}_${uid}`; + + return { + username, + password + }; +} + +export { + getCredentialArgs +}