jest for remix-tests tests

libs/remix-solidity/src/compiler/compiler.ts

@@ -99,7 +99,7 @@ export class Compiler {
 
   onInternalCompilerLoaded (): void {
     if (this.state.worker === null) {
-      const compiler: any = typeof (window) === 'undefined' ? require('solc') : require('solc/wrapper')(window['Module'])
+      const compiler: any = typeof (window) !== 'undefined' && window['Module'] ? require('solc/wrapper')(window['Module']) : require('solc') 
       this.state.compileJSON = (source: SourceWithTarget) => {
         const missingInputs: string[] = []
         const missingInputsCallback = (path: string) => {

libs/remix-tests/jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+    name: 'remix-tests',
+    preset: '../../jest.config.js',
+    transform: {
+      '^.+\\.[tj]sx?$': 'ts-jest',
+    },
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'html', 'json', 'sol'],
+    coverageDirectory: '../../coverage/libs/remix-tests',
+  };
+  

libs/remix-tests/package.json

@@ -19,7 +19,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "test": "./../../node_modules/.bin/mocha --require ts-node/register --require tsconfig-paths/register tests/*.ts -t 300000"
+    "test": "./../../node_modules/.bin/mocha --require ts-node/register --require tsconfig-paths/register tests/testRunner.ts -t 300000"
   },
   "repository": {
     "type": "git",

libs/remix-tests/tests/testRunner.spec.ts

@@ -0,0 +1,282 @@
+import * as async from 'async'
+import Web3 from 'web3';
+import * as assert from 'assert'
+import { Provider } from '@remix-project/remix-simulator'
+
+import { compileFileOrFiles } from '../src/compiler'
+import { deployAll } from '../src/deployer'
+import { runTest, compilationInterface } from '../src/index'
+import { ResultsInterface, TestCbInterface, ResultCbInterface } from '../src/index'
+
+// deepEqualExcluding allows us to exclude specific keys whose values vary.
+// In this specific test, we'll use this helper to exclude `time` keys.
+// Assertions for the existance of these will be made at the correct places.
+function deepEqualExcluding(a: any, b: any, excludedKeys: string[]) {
+  function removeKeysFromObject(obj: any, excludedKeys: string[]) {
+    if (obj !== Object(obj)) {
+      return obj
+    }
+
+    if(Object.prototype.toString.call(obj) !== '[object Array]') {
+      obj = Object.assign({}, obj)
+      for (const key of excludedKeys) {
+        delete obj[key]
+      }
+
+      return obj
+    }
+
+    let newObj = []
+    for (const idx in obj) {
+      newObj[idx] = removeKeysFromObject(obj[idx], excludedKeys);
+    }
+
+    return newObj
+  }
+
+  let aStripped: any = removeKeysFromObject(a, excludedKeys);
+  let bStripped: any = removeKeysFromObject(b, excludedKeys);
+  assert.deepEqual(aStripped, bStripped)
+}
+
+let accounts: string[]
+let provider = new Provider()
+
+async function compileAndDeploy(filename: string, callback: Function) {
+  let web3: Web3 = new Web3()
+  let sourceASTs: any = {}
+  await provider.init()
+  web3.setProvider(provider)
+  let compilationData: object
+  async.waterfall([
+    function getAccountList(next: Function): void {
+      web3.eth.getAccounts((_err: Error | null | undefined, _accounts: string[]) => {
+        accounts = _accounts
+        web3.eth.defaultAccount = accounts[0]
+        next(_err)
+      })
+    },
+    function compile(next: Function): void {
+      compileFileOrFiles(filename, false, { accounts }, next)
+    },
+    function deployAllContracts(compilationResult: compilationInterface, asts, next: Function): void {
+      for(const filename in asts) {
+        if(filename.endsWith('_test.sol'))
+          sourceASTs[filename] = asts[filename].ast
+      }
+      try {
+        compilationData = compilationResult
+        deployAll(compilationResult, web3, false, next)
+      } catch (e) {
+        throw e
+      }
+    }
+  ], function (_err: Error | null | undefined, contracts: any): void {
+    callback(null, compilationData, contracts, sourceASTs, accounts)
+  })
+}
+
+
+describe('testRunner', () => {
+    let tests: any[] = [], results: ResultsInterface;
+
+    const testCallback: TestCbInterface = (err, test) => {
+      if (err) { throw err }
+
+      if (test.type === 'testPass' || test.type === 'testFailure') {
+        assert.ok(test.time, 'test time not reported')
+        assert.ok(!Number.isInteger(test.time || 0), 'test time should not be an integer')
+      }
+
+      tests.push(test)
+    }
+
+    const resultsCallback: Function = (done) => {
+      return (err, _results) => {
+        if (err) { throw err }
+        results = _results
+        done()
+      }
+    }
+
+    describe('#runTest', () => {
+    describe('test with beforeAll', () => {
+      const filename: string = '../tests/examples_1/simple_storage_test.sol'
+
+      beforeAll((done) => {
+        compileAndDeploy(filename, (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) => {
+          runTest('MyTest', contracts.MyTest, compilationData[filename]['MyTest'], asts[filename], { accounts }, testCallback, resultsCallback(done))
+        })
+      })
+
+      afterAll(() => { tests = [] })
+
+      it('should have 3 passing test', () => {
+        assert.equal(results.passingNum, 3)
+      })
+
+      it('should have 1 failing test', () => {
+        assert.equal(results.failureNum, 1)
+      })
+
+      it('should return 6 messages', () => {
+        deepEqualExcluding(tests, [
+          { type: 'accountList', value: accounts },
+          { type: 'contract', value: 'MyTest', filename: 'tests/examples_1/simple_storage_test.sol' },
+          { type: 'testPass', value: 'Initial value should be100', context: 'MyTest' },
+          { type: 'testPass', value: 'Initial value should not be200', context: 'MyTest' },
+          { type: 'testFailure', value: 'Should trigger one fail', errMsg: 'uint test 1 fails', context: 'MyTest' },
+          { type: 'testPass', value: 'Should trigger one pass', context: 'MyTest' }
+        ], ['time'])
+      })
+    })
+
+    describe('test with beforeEach', () => {
+      const filename: string = 'tests/examples_2/simple_storage_test.sol'
+
+      beforeAll(done => {
+        compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) {
+          runTest('MyTest', contracts.MyTest, compilationData[filename]['MyTest'], asts[filename], { accounts }, testCallback, resultsCallback(done))
+        })
+      })
+
+      afterAll(() => { tests = [] })
+
+      it('should have 2 passing tests', () => {
+        assert.equal(results.passingNum, 2)
+      })
+
+      it('should 0 failing tests', () => {
+        assert.equal(results.failureNum, 0)
+      })
+
+      it('should return 4 messages', () => {
+        deepEqualExcluding(tests, [
+          { type: 'accountList', value: accounts },
+          { type: 'contract', value: 'MyTest', filename: 'tests/examples_2/simple_storage_test.sol' },
+          { type: 'testPass', value: 'Initial value should be100', context: 'MyTest' },
+          { type: 'testPass', value: 'Value is set200', context: 'MyTest' }
+        ], ['time'])
+      })
+    })
+
+    // Test string equality
+    describe('test string equality', () => {
+      const filename: string = 'tests/examples_3/simple_string_test.sol'
+
+      beforeAll(done => {
+        compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) {
+          runTest('StringTest', contracts.StringTest, compilationData[filename]['StringTest'], asts[filename], { accounts }, testCallback, resultsCallback(done))
+        })
+      })
+
+      afterAll(() => { tests = [] })
+
+      it('should 2 passing tests', () => {
+        assert.equal(results.passingNum, 2)
+      })
+
+      it('should return 4 messages', () => {
+        deepEqualExcluding(tests, [
+          { type: 'accountList', value: accounts },
+          { type: 'contract', value: 'StringTest', filename: 'tests/examples_3/simple_string_test.sol' },
+          { type: 'testPass', value: 'Initial value should be hello world', context: 'StringTest' },
+          { type: 'testPass', value: 'Value should not be hello wordl', context: 'StringTest' }
+        ], ['time'])
+      })
+    })
+
+    // Test multiple directory import in test contract
+    describe('test multiple directory import in test contract', () => {
+      const filename: string = 'tests/examples_5/test/simple_storage_test.sol'
+
+      beforeAll(done => {
+        compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) {
+          runTest('StorageResolveTest', contracts.StorageResolveTest, compilationData[filename]['StorageResolveTest'], asts[filename], { accounts }, testCallback, resultsCallback(done))
+        })
+      })
+
+      afterAll(() => { tests = [] })
+
+      it('should 3 passing tests', () => {
+        assert.equal(results.passingNum, 3)
+      })
+
+      it('should return 4 messages', () => {
+        deepEqualExcluding(tests, [
+          { type: 'accountList', value: accounts },
+          { type: 'contract', value: 'StorageResolveTest', filename: 'tests/examples_5/test/simple_storage_test.sol' },
+          { type: 'testPass', value: 'Initial value should be100', context: 'StorageResolveTest' },
+          { type: 'testPass', value: 'Check if even', context: 'StorageResolveTest' },
+          { type: 'testPass', value: 'Check if odd', context: 'StorageResolveTest' }
+        ], ['time'])
+      })
+    })
+
+    //Test signed/unsigned integer weight
+    describe('test number weight', () => {
+      const filename: string = 'tests/number/number_test.sol'
+
+      beforeAll(done => {
+        compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) {
+          runTest('IntegerTest', contracts.IntegerTest, compilationData[filename]['IntegerTest'], asts[filename], { accounts }, testCallback, resultsCallback(done))
+        })
+      })
+
+      afterAll(() => { tests = [] })
+
+      it('should have 6 passing tests', () => {
+        assert.equal(results.passingNum, 6)
+      })
+      it('should have 2 failing tests', () => {
+        assert.equal(results.failureNum, 2)
+      })
+    })
+
+    // Test Transaction with custom sender & value
+    describe('various sender', () => {
+      const filename: string = 'tests/various_sender/sender_and_value_test.sol'
+
+      beforeAll(done => {
+        compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) {
+          runTest('SenderAndValueTest', contracts.SenderAndValueTest, compilationData[filename]['SenderAndValueTest'], asts[filename], { accounts }, testCallback, resultsCallback(done))
+        })
+      })
+
+      afterAll(() => { tests = [] })
+
+      it('should have 17 passing tests', () => {
+        assert.equal(results.passingNum, 17)
+      })
+      it('should have 0 failing tests', () => {
+        assert.equal(results.failureNum, 0)
+      })
+    })
+
+    // Test `runTest` method without sending contract object (should throw error)
+    describe('runTest method without contract json interface', () => {
+      const filename: string = 'tests/various_sender/sender_and_value_test.sol'
+      const errorCallback: Function = (done) => {
+        return (err, _results) => {
+          if (err && err.message.includes('Contract interface not available')) { 
+            results = _results
+            done() 
+          }
+          else throw err
+        }
+      }
+      beforeAll(done => {
+        compileAndDeploy(filename, function (_err: Error | null | undefined, compilationData: object, contracts: any, asts: any, accounts: string[]) {
+          runTest('SenderAndValueTest', undefined, compilationData[filename]['SenderAndValueTest'], asts[filename], { accounts }, testCallback, errorCallback(done))
+        })
+      })
+
+      it('should have 0 passing tests', () => {
+        assert.equal(results.passingNum, 0)
+      })
+      it('should have 0 failing tests', () => {
+        assert.equal(results.failureNum, 0)
+      })
+    })
+  })
+})

libs/remix-tests/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.json",
   "compilerOptions": {
-    "types": ["node"],
+    "types": ["node", "jest"],
     "module": "commonjs",
     "esModuleInterop": true 
   },

libs/remix-tests/tsconfig.spec.json

@@ -0,0 +1,17 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+      "outDir": "../../dist/out-tsc",
+      "module": "commonjs",
+      "types": ["jest", "node"]
+    },
+    "include": [
+        "**/*.sol",
+      "**/*.spec.ts",
+      "**/*.spec.tsx",
+      "**/*.spec.js",
+      "**/*.spec.jsx",
+      "**/*.d.ts"
+    ]
+  }
+  

package.json

@@ -134,6 +134,7 @@
   },
   "dependencies": {
     "@remixproject/engine": "^0.2.3",
+    "@types/jest": "^26.0.5",
     "@types/tape": "^4.2.33",
     "ansi-gray": "^0.1.1",
     "change-case": "^4.1.1",
@@ -142,11 +143,11 @@
     "ethereumjs-tx": "^2.1.2",
     "ethereumjs-vm": "4.1.3",
     "http-server": "^0.11.1",
+    "merge": "^1.2.0",
     "npm-install-version": "^6.0.2",
     "signale": "^1.4.0",
     "time-stamp": "^2.2.0",
-    "winston": "^3.3.3",
+    "winston": "^3.3.3"
-    "merge": "^1.2.0"
   },
   "devDependencies": {
     "@babel/core": "^7.4.5",

workspace.json

@@ -358,6 +358,14 @@
             "cwd": "libs/remix-tests"
           }
         },
+        "test2": {
+          "builder": "@nrwl/jest:jest",
+          "options": {
+            "jestConfig": "libs/remix-tests/jest.config.js",
+            "tsConfig": "libs/remix-tests/tsconfig.spec.json",
+            "passWithNoTests": true
+          }
+        },
         "build": {
           "builder": "@nrwl/node:package",
           "options": {