crowetic/protocol
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add tests for sol-cov

Browse Source
This commit is contained in:
Leonid Logvinov
2018-03-15 15:42:48 +01:00
parent 40ebb533b3
commit f6c01520ae
18 changed files with 370 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
.circleci/config.yml
View File

@@ -111,6 +111,10 @@ jobs:
key: coverage-subproviders-{{ .Environment.CIRCLE_SHA1 }}
paths:
- ~/repo/packages/subproviders/coverage/lcov.info
- save_cache:
key: coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
paths:
- ~/repo/packages/sol-cov/coverage/lcov.info
lint:
working_directory: ~/repo
docker:
@@ -155,6 +159,9 @@ jobs:
- restore_cache:
keys:
- coverage-subproviders-{{ .Environment.CIRCLE_SHA1 }}
- restore_cache:
keys:
- coverage-sol-cov-{{ .Environment.CIRCLE_SHA1 }}
- restore_cache:
keys:
- coverage-deployer-{{ .Environment.CIRCLE_SHA1 }}

0
packages/sol-cov/coverage/.gitkeep Normal file
View File

18
packages/sol-cov/package.json
View File

@@ -2,13 +2,18 @@
"name": "@0xproject/sol-cov",
"version": "0.0.1",
"description": "Generate coverage reports for Solidity code",
"main": "lib/index.js",
"types": "lib/index.d.ts",
"main": "lib/src/index.js",
"types": "lib/src/index.d.ts",
"scripts": {
"build:watch": "tsc -w",
"lint": "tslint --project . 'src/**/*.ts'",
"test": "run-s clean build run_mocha",
"test:coverage": "nyc npm run test --all && yarn coverage:report:lcov",
"coverage:report:lcov": "nyc report --reporter=text-lcov > coverage/lcov.info",
"test:circleci": "yarn test:coverage",
"run_mocha": "mocha lib/test/**/*_test.js",
"clean": "shx rm -rf lib scripts",
"build": "tsc && copyfiles -u 2 './lib/monorepo_scripts/**/*' ./scripts"
"build": "copyfiles 'test/fixtures/**/*' ./lib && tsc && copyfiles -u 2 './lib/monorepo_scripts/**/*' ./scripts"
},
"repository": {
"type": "git",
@@ -37,7 +42,14 @@
"@0xproject/tslint-config": "^0.4.9",
"@types/istanbul": "^0.4.29",
"@types/node": "^8.0.53",
"@types/mocha": "^2.2.42",
"sinon": "^4.0.0",
"copyfiles": "^1.2.0",
"nyc": "^11.0.1",
"chai": "^4.0.1",
"dirty-chai": "^2.0.1",
"chai-typescript-typings": "^0.0.4",
"mocha": "^4.0.1",
"npm-run-all": "^4.1.2",
"shx": "^0.2.2",
"tslint": "5.8.0",

4
packages/sol-cov/src/ast_visitor.ts
View File

@@ -113,8 +113,8 @@ export class ASTVisitor {
this._statementMap[this._entryId++] = this._getExpressionRange(ast);
}
private _getExpressionRange(ast: Parser.ASTNode): SingleFileSourceRange {
const start = this._locationByOffset[ast.range[0] - 1];
const end = this._locationByOffset[ast.range[1]];
const start = this._locationByOffset[ast.range[0]];
const end = this._locationByOffset[ast.range[1] + 1];
const range = {
start,
end,

2
packages/sol-cov/src/collect_coverage_entries.ts
View File

@@ -10,7 +10,7 @@ import { getLocationByOffset } from './source_maps';
// Parsing source code for each transaction/code is slow and therefore we cache it
const coverageEntriesBySourceHash: { [sourceHash: string]: CoverageEntriesDescription } = {};
export const collectCoverageEntries = (contractSource: string, fileName: string) => {
export const collectCoverageEntries = (contractSource: string) => {
const sourceHash = ethUtil.sha3(contractSource).toString('hex');
if (_.isUndefined(coverageEntriesBySourceHash[sourceHash])) {
const ast = parser.parse(contractSource, { range: true });

2
packages/sol-cov/src/coverage_manager.ts
View File

@@ -39,7 +39,7 @@ export class CoverageManager {
fileIndex: number,
): Coverage {
const fileName = contractData.sources[fileIndex];
const coverageEntriesDescription = collectCoverageEntries(contractData.sourceCodes[fileIndex], fileName);
const coverageEntriesDescription = collectCoverageEntries(contractData.sourceCodes[fileIndex]);
let sourceRanges = _.map(coveredPcs, coveredPc => pcToSourceRange[coveredPc]);
sourceRanges = _.compact(sourceRanges); // Some PC's don't map to a source range and we just ignore them.
// By default lodash does a shallow object comparasion. We JSON.stringify them and compare as strings.

3
packages/sol-cov/src/globals.d.ts vendored
View File

@@ -1,5 +1,6 @@
// tslint:disable:completed-docs
declare module 'dirty-chai';
// tslint:disable:completed-docs
declare module '*.json' {
const json: any;
/* tslint:disable */

11
packages/sol-cov/src/source_maps.ts
View File

@@ -12,12 +12,12 @@ export interface SourceLocation {
}
export function getLocationByOffset(str: string): LocationByOffset {
const locationByOffset: LocationByOffset = {};
const locationByOffset: LocationByOffset = { 0: { line: 1, column: 0 } };
let currentOffset = 0;
for (const char of str.split('')) {
const location = locationByOffset[currentOffset - 1] || { line: 1, column: 0 };
const location = locationByOffset[currentOffset];
const isNewline = char === '\n';
locationByOffset[currentOffset] = {
locationByOffset[currentOffset + 1] = {
line: location.line + (isNewline ? 1 : 0),
column: isNewline ? 0 : location.column + 1,
};
@@ -59,9 +59,8 @@ export function parseSourceMap(
if (parsedEntry.fileIndex !== -1) {
const sourceRange = {
location: {
start: locationByOffsetByFileIndex[parsedEntry.fileIndex][parsedEntry.offset - 1],
end:
locationByOffsetByFileIndex[parsedEntry.fileIndex][parsedEntry.offset + parsedEntry.length - 1],
start: locationByOffsetByFileIndex[parsedEntry.fileIndex][parsedEntry.offset],
end: locationByOffsetByFileIndex[parsedEntry.fileIndex][parsedEntry.offset + parsedEntry.length],
},
fileName: sources[parsedEntry.fileIndex],
};

30
packages/sol-cov/test/collect_contracts_data_test.ts Normal file
View File

@@ -0,0 +1,30 @@
import * as chai from 'chai';
import * as _ from 'lodash';
import 'mocha';
import * as path from 'path';
import { collectContractsData } from '../src/collect_contract_data';
const expect = chai.expect;
describe('Collect contracts data', () => {
describe('#collectContractsData', () => {
it('correctly collects contracts data', () => {
const artifactsPath = path.resolve(__dirname, 'fixtures/artifacts');
const sourcesPath = path.resolve(__dirname, 'fixtures/contracts');
const networkId = 50;
const contractsData = collectContractsData(artifactsPath, sourcesPath, networkId);
_.forEach(contractsData, contractData => {
expect(contractData).to.have.keys([
'baseName',
'sourceCodes',
'sources',
'sourceMap',
'sourceMapRuntime',
'bytecode',
'runtimeBytecode',
]);
});
});
});
});

64
packages/sol-cov/test/collect_coverage_entries_test.ts Normal file
View File

@@ -0,0 +1,64 @@
import * as chai from 'chai';
import * as fs from 'fs';
import * as _ from 'lodash';
import 'mocha';
import * as path from 'path';
import { collectCoverageEntries } from '../src/collect_coverage_entries';
import { SingleFileSourceRange } from '../src/types';
const expect = chai.expect;
const getRange = (sourceCode: string, range: SingleFileSourceRange) => {
const lines = sourceCode.split('\n').slice(range.start.line - 1, range.end.line);
lines[lines.length - 1] = lines[lines.length - 1].slice(0, range.end.column);
lines[0] = lines[0].slice(range.start.column);
return lines.join('\n');
};
describe('Collect coverage entries', () => {
describe('#collectCoverageEntries', () => {
it('correctly collects coverage entries for Simplest contract', () => {
const simplestContractBaseName = 'Simplest.sol';
const simplestContractFileName = path.resolve(__dirname, 'fixtures/contracts', simplestContractBaseName);
const simplestContract = fs.readFileSync(simplestContractFileName).toString();
const coverageEntries = collectCoverageEntries(simplestContract);
expect(coverageEntries.fnMap).to.be.deep.equal({});
expect(coverageEntries.branchMap).to.be.deep.equal({});
expect(coverageEntries.statementMap).to.be.deep.equal({});
expect(coverageEntries.modifiersStatementIds).to.be.deep.equal([]);
});
it('correctly collects coverage entries for SimpleStorage contract', () => {
const simpleStorageContractBaseName = 'SimpleStorage.sol';
const simpleStorageContractFileName = path.resolve(
__dirname,
'fixtures/contracts',
simpleStorageContractBaseName,
);
const simpleStorageContract = fs.readFileSync(simpleStorageContractFileName).toString();
const coverageEntries = collectCoverageEntries(simpleStorageContract);
const fnIds = _.keys(coverageEntries.fnMap);
expect(coverageEntries.fnMap[fnIds[0]].name).to.be.equal('set');
expect(coverageEntries.fnMap[fnIds[0]].line).to.be.equal(3);
const setFunction = `function set(uint x) {
storedData = x;
}`;
expect(getRange(simpleStorageContract, coverageEntries.fnMap[fnIds[0]].loc)).to.be.equal(setFunction);
expect(coverageEntries.fnMap[fnIds[1]].name).to.be.equal('get');
expect(coverageEntries.fnMap[fnIds[1]].line).to.be.equal(6);
const getFunction = `function get() constant returns (uint retVal) {
return storedData;
}`;
expect(getRange(simpleStorageContract, coverageEntries.fnMap[fnIds[1]].loc)).to.be.equal(getFunction);
expect(coverageEntries.branchMap).to.be.deep.equal({});
const statementIds = _.keys(coverageEntries.statementMap);
expect(getRange(simpleStorageContract, coverageEntries.statementMap[statementIds[1]])).to.be.equal(
'storedData = x',
);
expect(getRange(simpleStorageContract, coverageEntries.statementMap[statementIds[3]])).to.be.equal(
'return storedData;',
);
expect(coverageEntries.modifiersStatementIds).to.be.deep.equal([]);
});
});
});

64
packages/sol-cov/test/fixtures/artifacts/SimpleStorage.json vendored Normal file
View File

@@ -0,0 +1,64 @@
{
"contract_name": "SimpleStorage",
"networks": {
"50": {
"solc_version": "0.4.21",
"keccak256": "0x18dc5b5a0e813c17e49936d2f2f7c07c51f050c09ba5e7206f17c855f23f4b6a",
"source_tree_hash": "0x18dc5b5a0e813c17e49936d2f2f7c07c51f050c09ba5e7206f17c855f23f4b6a",
"optimizer_enabled": 0,
"abi": [
{
"constant": true,
"inputs": [],
"name": "storedData",
"outputs": [
{
"name": "",
"type": "uint256"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "x",
"type": "uint256"
}
],
"name": "set",
"outputs": [],
"payable": false,
"stateMutability": "nonpayable",
"type": "function"
},
{
"constant": true,
"inputs": [],
"name": "get",
"outputs": [
{
"name": "retVal",
"type": "uint256"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
}
],
"bytecode":
"0x6060604052341561000f57600080fd5b6101098061001e6000396000f3006060604052600436106053576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632a1afcd914605857806360fe47b114607e5780636d4ce63c14609e575b600080fd5b3415606257600080fd5b606860c4565b6040518082815260200191505060405180910390f35b3415608857600080fd5b609c600480803590602001909190505060ca565b005b341560a857600080fd5b60ae60d4565b6040518082815260200191505060405180910390f35b60005481565b8060008190555050565b600080549050905600a165627a7a723058207f743855fd0c71699620424a21a257cd197ed05032d6768eb9b874e4898f44c60029",
"runtime_bytecode":
"0x6060604052600436106053576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632a1afcd914605857806360fe47b114607e5780636d4ce63c14609e575b600080fd5b3415606257600080fd5b606860c4565b6040518082815260200191505060405180910390f35b3415608857600080fd5b609c600480803590602001909190505060ca565b005b341560a857600080fd5b60ae60d4565b6040518082815260200191505060405180910390f35b60005481565b8060008190555050565b600080549050905600a165627a7a723058207f743855fd0c71699620424a21a257cd197ed05032d6768eb9b874e4898f44c60029",
"updated_at": 1521118350895,
"source_map": "26:196:0:-;;;;;;;;;;;;;;;;;",
"source_map_runtime":
"26:196:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83:52;;;;;;;;;;;;;;;;;;;;;;;;;;140:80;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55:22;;;;:::o;83:52::-;127:1;114:10;:14;;;;83:52;:::o;140:80::-;173:11;203:10;;196:17;;140:80;:::o",
"sources": ["SimpleStorage.sol"]
}
}
}

20
packages/sol-cov/test/fixtures/artifacts/Simplest.json vendored Normal file
View File

@@ -0,0 +1,20 @@
{
"contract_name": "Simplest",
"networks": {
"50": {
"solc_version": "0.4.21",
"keccak256": "0x8e7d62e19c7c7b8bf9a4a43749e111605950cc877574fb9640a1a07d1c3749f9",
"source_tree_hash": "0x8e7d62e19c7c7b8bf9a4a43749e111605950cc877574fb9640a1a07d1c3749f9",
"optimizer_enabled": 0,
"abi": [],
"bytecode":
"0x60606040523415600e57600080fd5b603580601b6000396000f3006060604052600080fd00a165627a7a7230582097cfe05b4d18d6ffb3a8d8fab0570cf09640d3131b9677ddb9be4e9fbcb65f010029",
"runtime_bytecode":
"0x6060604052600080fd00a165627a7a7230582097cfe05b4d18d6ffb3a8d8fab0570cf09640d3131b9677ddb9be4e9fbcb65f010029",
"updated_at": 1521118525393,
"source_map": "26:21:0:-;;;;;;;;;;;;;;;;;",
"source_map_runtime": "26:21:0:-;;;;;",
"sources": ["Simplest.sol"]
}
}
}

9
packages/sol-cov/test/fixtures/contracts/SimpleStorage.sol vendored Normal file
View File

@@ -0,0 +1,9 @@
contract SimpleStorage {
uint public storedData;
function set(uint x) {
storedData = x;
}
function get() constant returns (uint retVal) {
return storedData;
}
}

2
packages/sol-cov/test/fixtures/contracts/Simplest.sol vendored Normal file
View File

@@ -0,0 +1,2 @@
contract Simplest {
}

22
packages/sol-cov/test/instructions_test.ts Normal file
View File

@@ -0,0 +1,22 @@
import * as chai from 'chai';
import * as fs from 'fs';
import 'mocha';
import * as path from 'path';
import { getPcToInstructionIndexMapping } from '../src/instructions';
const expect = chai.expect;
describe('instructions', () => {
describe('#getPcToInstructionIndexMapping', () => {
it('correctly maps pcs to instruction indexed', () => {
const PUSH1 = 0x60;
const PUSH2 = 0x61;
const TIMESTAMP = 0x42;
const bytecode = new Uint8Array([PUSH1, 42, PUSH2, 1, 2, TIMESTAMP]);
const pcToInstruction = getPcToInstructionIndexMapping(bytecode);
const expectedPcToInstruction = { '0': 0, '2': 1, '5': 2 };
expect(pcToInstruction).to.be.deep.equal(expectedPcToInstruction);
});
});
});

71
packages/sol-cov/test/source_maps_test.ts Normal file
View File

@@ -0,0 +1,71 @@
import * as chai from 'chai';
import * as fs from 'fs';
import * as _ from 'lodash';
import 'mocha';
import * as path from 'path';
import { getLocationByOffset, parseSourceMap } from '../src/source_maps';
const expect = chai.expect;
const simplestContractBaseName = 'Simplest.sol';
const simplestContractFileName = path.resolve(__dirname, 'fixtures/contracts', simplestContractBaseName);
const simplestContract = fs.readFileSync(simplestContractFileName).toString();
describe('source maps', () => {
describe('#getLocationByOffset', () => {
it('correctly computes location by offset', () => {
const locationByOffset = getLocationByOffset(simplestContract);
const expectedLocationByOffset = {
'0': { line: 1, column: 0 },
'1': { line: 1, column: 1 },
'2': { line: 1, column: 2 },
'3': { line: 1, column: 3 },
'4': { line: 1, column: 4 },
'5': { line: 1, column: 5 },
'6': { line: 1, column: 6 },
'7': { line: 1, column: 7 },
'8': { line: 1, column: 8 },
'9': { line: 1, column: 9 },
'10': { line: 1, column: 10 },
'11': { line: 1, column: 11 },
'12': { line: 1, column: 12 },
'13': { line: 1, column: 13 },
'14': { line: 1, column: 14 },
'15': { line: 1, column: 15 },
'16': { line: 1, column: 16 },
'17': { line: 1, column: 17 },
'18': { line: 1, column: 18 },
'19': { line: 1, column: 19 },
'20': { line: 2, column: 0 },
'21': { line: 2, column: 1 },
'22': { line: 3, column: 0 },
};
expect(locationByOffset).to.be.deep.equal(expectedLocationByOffset);
});
});
describe('#parseSourceMap', () => {
it('correctly parses the source map', () => {
// This is the source map and bytecode for an empty contract like Example.sol
const srcMap = '0:21:0:-;;;;;;;;;;;;;;;;;';
const bytecodeHex =
'60606040523415600e57600080fd5b603580601b6000396000f3006060604052600080fd00a165627a7a72305820377cdef690e46589f40efeef14d8ef73504af059fb3fd46f1da3cd2fc52ef7890029';
const sources = [simplestContractBaseName];
const pcToSourceRange = parseSourceMap([simplestContract], srcMap, bytecodeHex, sources);
const expectedSourceRange = {
location: {
start: { line: 1, column: 0 },
end: { line: 2, column: 1 },
},
fileName: simplestContractBaseName,
};
_.forEach(pcToSourceRange, sourceRange => {
// Solidity source maps are too short and we map some instructions to undefined
// Source: https://github.com/ethereum/solidity/issues/3741
if (!_.isUndefined(sourceRange)) {
expect(sourceRange).to.be.deep.equal(expectedSourceRange);
}
});
});
});
});

53
packages/sol-cov/test/utils_test.ts Normal file
View File

@@ -0,0 +1,53 @@
import * as chai from 'chai';
import * as dirtyChai from 'dirty-chai';
import 'mocha';
import { utils } from '../src/utils';
chai.use(dirtyChai);
const expect = chai.expect;
describe('utils', () => {
describe('#compareLineColumn', () => {
it('correctly compares LineColumns', () => {
expect(utils.compareLineColumn({ line: 1, column: 3 }, { line: 1, column: 4 })).to.be.lessThan(0);
expect(utils.compareLineColumn({ line: 1, column: 4 }, { line: 1, column: 3 })).to.be.greaterThan(0);
expect(utils.compareLineColumn({ line: 1, column: 3 }, { line: 1, column: 3 })).to.be.equal(0);
expect(utils.compareLineColumn({ line: 0, column: 2 }, { line: 1, column: 0 })).to.be.lessThan(0);
expect(utils.compareLineColumn({ line: 1, column: 0 }, { line: 0, column: 2 })).to.be.greaterThan(0);
});
});
describe('#isRangeInside', () => {
it('returns true if inside', () => {
expect(
utils.isRangeInside(
{ start: { line: 1, column: 3 }, end: { line: 1, column: 4 } },
{ start: { line: 1, column: 2 }, end: { line: 1, column: 5 } },
),
).to.be.true();
});
it('returns true if the same', () => {
expect(
utils.isRangeInside(
{ start: { line: 1, column: 3 }, end: { line: 1, column: 4 } },
{ start: { line: 1, column: 3 }, end: { line: 1, column: 4 } },
),
).to.be.true();
});
it('returns false if not inside', () => {
expect(
utils.isRangeInside(
{ start: { line: 1, column: 3 }, end: { line: 1, column: 4 } },
{ start: { line: 1, column: 4 }, end: { line: 1, column: 4 } },
),
).to.be.false();
expect(
utils.isRangeInside(
{ start: { line: 1, column: 3 }, end: { line: 1, column: 4 } },
{ start: { line: 1, column: 4 }, end: { line: 1, column: 5 } },
),
).to.be.false();
});
});
});

2
packages/sol-cov/tsconfig.json
View File

@@ -5,8 +5,10 @@
},
"include": [
"./src/**/*",
"./test/**/*",
"../../node_modules/types-bn/index.d.ts",
"../../node_modules/web3-typescript-typings/index.d.ts",
"../../node_modules/chai-typescript-typings/index.d.ts",
"../../node_modules/types-ethereumjs-util/index.d.ts"
]
}