1  /*globals describe, it*/
  2  let ContractsManager = require('../lib/modules/contracts_manager/index.js');
  3  let Compiler = require('../lib/modules/compiler/');
  4  let Logger = require('../lib/core/logger.js');
  5  let File = require('../lib/core/file.js');
  6  let TestLogger = require('../lib/utils/test_logger');
  7  let Events = require('../lib/core/events');
  8  let Ipc = require('../lib/core/ipc.js');
  9  let assert = require('assert');
 10  
 11  //let SolidityCompiler = require('../lib/modules/solidity');
 12  let Plugins = require('../lib/core/plugins.js');
 13  
 14  let readFile = function(file) {
 15    return new File({filename: file, type: File.types.dapp_file, path: file});
 16  };
 17  
 18  const currentSolcVersion = require('../package.json').dependencies.solc;
 19  const TestEvents = {
 20    request: (cmd, cb) => {
 21      cb(currentSolcVersion);
 22    },
 23    emit: (_ev, _data) => {}
 24  };
 25  
 26  describe('embark.Contracts', function() {
 27    this.timeout(0);
 28    describe('simple', function() {
 29      let plugins = new Plugins({
 30        logger: new TestLogger({}),
 31        events: TestEvents,
 32        config: {
 33          contractDirectories: ['app/contracts/'],
 34          embarkConfig: {
 35            options: {
 36              solc: {
 37                "optimize": true,
 38                "optimize-runs": 200
 39              }
 40            }
 41          }
 42        }
 43      });
 44      let ipcObject = new Ipc({
 45        ipcRole: 'none'
 46      });
 47      plugins.loadInternalPlugin('solidity', {ipc: ipcObject});
 48  
 49      let events = new Events();
 50      let embarkObject = {
 51        events: events,
 52        logger: plugins.logger,
 53        embarkConfig: {
 54          options: {
 55            solc: {
 56              "optimize": true,
 57              "optimize-runs": 200
 58            }
 59          }
 60        }
 61      };
 62  
 63      let compiler = new Compiler(embarkObject, {plugins: plugins});
 64  
 65      events.setCommandHandler("config:contractsConfig", function(cb) {
 66        cb(contractsConfig);
 67      });
 68  
 69      events.setCommandHandler("config:contractsFiles", (cb) => {
 70        cb([
 71          readFile('test/contracts/simple_storage.sol'),
 72          readFile('test/contracts/token.sol')
 73        ]);
 74      });
 75  
 76      events.setCommandHandler("blockchain:gasPrice", (cb) => {
 77        cb(null, 100);
 78      });
 79  
 80      let contractsConfig = {
 81        "versions": {
 82          "web3.js": "1.0.0-beta",
 83          "solc": "0.4.17"
 84        },
 85        "deployment": {
 86          "host": "localhost",
 87          "port": 8545,
 88          "type": "rpc"
 89        },
 90        "dappConnection": [
 91          "$WEB3",
 92          "localhost:8545"
 93        ],
 94        "gas": "auto",
 95        "contracts": {
 96          "Token": {
 97            "args": [
 98              100
 99            ]
100          },
101          "SimpleStorage": {
102            "args": [
103              200
104            ]
105          }
106        }
107      };
108  
109      let embarkObj = {
110        logger: new Logger({}),
111        events: events
112      };
113  
114      let contractsManager = new ContractsManager(embarkObj, {
115        contractDirectories: ['app/contracts']
116      });
117  
118      describe('#build', function() {
119        it('generate contracts', function(done) {
120          contractsManager.build(function(err, result) {
121            if (err) {
122              throw err;
123            }
124  
125            let contracts = contractsManager.listContracts();
126            assert.equal(contracts.length, 2);
127  
128            assert.equal(contracts[0].deploy, true);
129            assert.deepEqual(contracts[0].args, [100]);
130            assert.equal(contracts[0].className, "Token");
131            //assert.deepEqual(contracts[0].gas, 725000);
132            assert.deepEqual(contracts[0].gas, 'auto');
133            //assert.equal(contracts[0].gasPrice, []); // TODO: test this one
134            assert.equal(contracts[0].type, 'file');
135            //assert.equal(contracts[0].abiDefinition, '');
136            //assert.equal(contracts[0].code, '');
137            //assert.equal(contracts[0].runtimeBytecode, '');
138  
139            assert.equal(contracts[1].deploy, true);
140            assert.deepEqual(contracts[1].args, [200]);
141            assert.equal(contracts[1].className, "SimpleStorage");
142            //assert.deepEqual(contracts[1].gas, 725000);
143            assert.deepEqual(contracts[1].gas, 'auto');
144            //assert.equal(contracts[1].gasPrice, []); // TODO: test this one
145            assert.equal(contracts[1].type, 'file');
146            //assert.equal(contracts[1].abiDefinition, '');
147            //assert.equal(contracts[1].code, '');
148            //assert.equal(contracts[1].runtimeBytecode, '');
149            done();
150          });
151        });
152      });
153    });
154  
155    describe('config with contract instances', function() {
156      let plugins = new Plugins({
157        logger: new TestLogger({}),
158        events: TestEvents,
159        config: {
160          contractDirectories: ['app/contracts/'],
161          embarkConfig: {
162            options: {
163              solc: {
164                "optimize": true,
165                "optimize-runs": 200
166              }
167            }
168          }
169        }
170      });
171      let ipcObject = new Ipc({
172        ipcRole: 'none'
173      });
174      plugins.loadInternalPlugin('solidity', {ipc: ipcObject});
175  
176      let events = new Events();
177      let compiler = new Compiler({events: events, logger: plugins.logger}, {plugins: plugins});
178  
179      events.setCommandHandler("config:contractsConfig", function(cb) {
180        cb(contractsConfig);
181      });
182  
183      events.setCommandHandler("config:contractsFiles", (cb) => {
184        cb([
185          readFile('test/contracts/simple_storage.sol'),
186          readFile('test/contracts/token_storage.sol')
187        ]);
188      });
189  
190      events.setCommandHandler("blockchain:gasPrice", (cb) => {
191        cb(null, 100);
192      });
193  
194      let contractsConfig = {
195        "versions": {
196          "web3.js": "1.0.0-beta",
197          "solc": "0.4.17"
198        },
199        "deployment": {
200          "host": "localhost",
201          "port": 8545,
202          "type": "rpc"
203        },
204        "dappConnection": [
205          "$WEB3",
206          "localhost:8545"
207        ],
208        "gas": "auto",
209        "contracts": {
210          "TokenStorage": {
211            "args": [
212              100,
213              "$SimpleStorage"
214            ]
215          },
216          "MySimpleStorage": {
217            "instanceOf": "SimpleStorage",
218            "args": [
219              300
220            ]
221          },
222          "SimpleStorage": {
223            "args": [
224              200
225            ]
226          },
227          "AnotherSimpleStorage": {
228            "instanceOf": "SimpleStorage"
229          }
230        }
231      }
232  
233      let embarkObj = {
234        logger: new Logger({}),
235        events: events
236      }
237  
238      let contractsManager = new ContractsManager(embarkObj, {
239        contractDirectories: ['app/contracts']
240      });
241  
242      describe('#build', function() {
243        it('generate contracts', function(done) {
244          contractsManager.build(function(err, result) {
245            if (err) {
246              throw err;
247            }
248  
249            let contracts = contractsManager.listContracts();
250            assert.equal(contracts.length, 4);
251  
252            assert.equal(contracts[0].className, "MySimpleStorage");
253            assert.equal(contracts[1].className, "AnotherSimpleStorage");
254            assert.equal(contracts[2].className, "SimpleStorage");
255            assert.equal(contracts[3].className, "TokenStorage");
256  
257            // TokenStorage
258            assert.equal(contracts[3].deploy, true);
259            assert.deepEqual(contracts[3].args, [100, '$SimpleStorage']);
260            //assert.deepEqual(contracts[3].gas, 725000);
261            assert.deepEqual(contracts[3].gas, 'auto');
262            assert.equal(contracts[3].type, 'file');
263            //assert.equal(contracts[3].abiDefinition, '');
264            //assert.equal(contracts[3].code, '');
265            //assert.equal(contracts[3].runtimeBytecode, '');
266  
267            let parentContract = contracts[2];
268  
269            //MySimpleStorage
270            assert.equal(contracts[0].deploy, true);
271            assert.deepEqual(contracts[0].args, [300]);
272            //assert.deepEqual(contracts[0].gas, 725000);
273            assert.deepEqual(contracts[0].gas, 'auto');
274            assert.equal(contracts[0].type, 'instance');
275            assert.equal(contracts[0].abiDefinition, parentContract.abiDefinition);
276            assert.equal(contracts[0].code, parentContract.code);
277            assert.equal(contracts[0].runtimeBytecode, parentContract.runtimeBytecode);
278  
279            // SimpleStorage
280            assert.equal(contracts[2].deploy, true);
281            assert.deepEqual(contracts[2].args, [200]);
282            //assert.deepEqual(contracts[2].gas, 725000);
283            assert.deepEqual(contracts[2].gas, 'auto');
284            assert.equal(contracts[2].type, 'file');
285            //assert.equal(contracts[2].abiDefinition, '');
286            //assert.equal(contracts[2].code, '');
287            //assert.equal(contracts[2].runtimeBytecode, '');
288  
289            // AnotherSimpleStorage
290            assert.equal(contracts[1].deploy, true);
291            assert.deepEqual(contracts[1].args, [200]);
292            //assert.deepEqual(contracts[1].gas, 725000);
293            assert.deepEqual(contracts[1].gas, 'auto');
294            assert.equal(contracts[1].type, 'instance');
295            assert.equal(contracts[1].abiDefinition, parentContract.abiDefinition);
296            assert.equal(contracts[1].code, parentContract.code);
297            assert.equal(contracts[1].runtimeBytecode, parentContract.runtimeBytecode);
298            done();
299          });
300        });
301      });
302    });
303  
304  });