tests for creating new contract with nondefault constructor, added missing files

dist/ethereum-light.js

@@ -1525,7 +1525,7 @@ function Contract(abi, options) {
         var code = options;
         var args = Array.prototype.slice.call(arguments, 2);
         var bytes = solAbi.formatConstructorParams(abi, args);
-        address = web3.eth.sendTransaction({data: code + args});
+        address = web3.eth.sendTransaction({data: code + bytes});
     }
 
     var result = {};

dist/ethereum.js

@@ -1525,7 +1525,7 @@ function Contract(abi, options) {
         var code = options;
         var args = Array.prototype.slice.call(arguments, 2);
         var bytes = solAbi.formatConstructorParams(abi, args);
-        address = web3.eth.sendTransaction({data: code + args});
+        address = web3.eth.sendTransaction({data: code + bytes});
     }
 
     var result = {};

lib/solidity/utils.js

@@ -0,0 +1,68 @@
+/*
+    This file is part of ethereum.js.
+
+    ethereum.js is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    ethereum.js is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with ethereum.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file utils.js
+ * @author Marek Kotewicz <marek@ethdev.com>
+ * @date 2015
+ */
+
+/**
+ * Returns the contstructor with matching number of arguments
+ *
+ * @method getConstructor
+ * @param {Array} abi
+ * @param {Number} numberOfArgs
+ * @returns {Object} constructor function abi
+ */
+var getConstructor = function (abi, numberOfArgs) {
+    return abi.filter(function (f) {
+        return f.type === 'constructor' && f.inputs.length === numberOfArgs;
+    })[0];
+};
+
+/**
+ * Filters all functions from input abi
+ *
+ * @method filterFunctions
+ * @param {Array} abi
+ * @returns {Array} abi array with filtered objects of type 'function'
+ */
+var filterFunctions = function (json) {
+    return json.filter(function (current) {
+        return current.type === 'function'; 
+    }); 
+};
+
+/**
+ * Filters all events from input abi
+ *
+ * @method filterEvents
+ * @param {Array} abi
+ * @returns {Array} abi array with filtered objects of type 'event'
+ */
+var filterEvents = function (json) {
+    return json.filter(function (current) {
+        return current.type === 'event';
+    });
+};
+
+module.exports = {
+    getConstructor: getConstructor,
+    filterFunctions: filterFunctions,
+    filterEvents: filterEvents
+};
+

test/abi.formatConstructorParams.js

@@ -0,0 +1,106 @@
+var chai = require('chai');
+var assert = require('assert');
+var abi = require('../lib/solidity/abi');
+
+describe('lib/solidity/abi', function () {
+    describe('formatConstructorParams', function () {
+        it('should format uint256 properly', function () {
+            // given
+            var description =  [{
+                "name": "test",
+                "type": "constructor",
+                "inputs": [{
+                    "name": "a",
+                    "type": "uint256"
+                }
+                ]
+            }];
+
+            // when 
+            var bytes = abi.formatConstructorParams(description, [2]);
+
+            // then
+            assert.equal(bytes, '0000000000000000000000000000000000000000000000000000000000000002');
+        });
+        
+        it('should not find matching constructor', function () {
+            // given
+            var description =  [{
+                "name": "test",
+                "type": "constructor",
+                "inputs": [{
+                    "name": "a",
+                    "type": "uint256"
+                }
+                ]
+            }];
+
+            // when 
+            var bytes = abi.formatConstructorParams(description, []);
+
+            // then
+            assert.equal(bytes, '');
+        });
+
+        it('should not find matching constructor2', function () {
+            // given
+            var description =  [{
+                "name": "test",
+                "type": "constructor",
+                "inputs": [{
+                    "name": "a",
+                    "type": "uint256"
+                }
+                ]
+            }];
+
+            // when 
+            var bytes = abi.formatConstructorParams(description, [1,2]);
+
+            // then
+            assert.equal(bytes, '');
+        });
+        
+        it('should not find matching constructor3', function () {
+            // given
+            var description =  [{
+                "name": "test",
+                "type": "function",
+                "inputs": [{
+                    "name": "a",
+                    "type": "uint256"
+                }
+                ]
+            }];
+
+            // when 
+            var bytes = abi.formatConstructorParams(description, [2]);
+
+            // then
+            assert.equal(bytes, '');
+        });
+
+        it('should find matching constructor with multiple args', function () {
+            // given
+            var description =  [{
+                "name": "test",
+                "type": "constructor",
+                "inputs": [{
+                    "name": "a",
+                    "type": "uint256"
+                }, {
+                    "name": "b",
+                    "type": "uint256"
+                }]
+            }];
+
+            // when 
+            var bytes = abi.formatConstructorParams(description, ['1', '5']);
+
+            // then
+            assert.equal(bytes, '00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000005');
+        });
+    });
+});
+
+

test/utils.isStrictAddress.js

@@ -0,0 +1,23 @@
+var chai = require('chai');
+var utils = require('../lib/utils/utils.js');
+var assert = chai.assert;
+
+var tests = [
+    { value: function () {}, is: false},
+    { value: new Function(), is: false},
+    { value: 'function', is: false},
+    { value: {}, is: false},
+    { value: '0xc6d9d2cd449a754c494264e1809c50e34d64562b', is: true },
+    { value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', is: false }
+];
+
+describe('lib/utils/utils', function () {
+    describe('isStrictAddress', function () {
+        tests.forEach(function (test) {
+            it('shoud test if value ' + test.value + ' is address: ' + test.is, function () {
+                assert.equal(utils.isStrictAddress(test.value), test.is);
+            });
+        });   
+    });
+});
+

test/web3.eth.contract.js

@@ -1,5 +1,7 @@
 var assert = require('assert');
 var contract = require('../lib/web3/contract.js');
+var FakeHttpProvider = require('./helpers/FakeHttpProvider');
+var web3 = require('../index');
 
 describe('web3.eth.contract', function() {
     it('should create simple contract with one method from abi with explicit type name', function () {
@@ -207,5 +209,32 @@ describe('web3.eth.contract', function() {
 
     });
 
+    it('should create contract with nondefault constructor', function (done) {
+        var provider = new FakeHttpProvider();
+        web3.setProvider(provider);
+        web3.reset(); // reset different polls
+        var address = '0x1234567890123456789012345678901234567890';
+        var code = '0x31241231231123123123123121cf121212i123123123123123512312412512111111';
+        var description =  [{
+            "name": "test",
+            "type": "constructor",
+            "inputs": [{
+                "name": "a",
+                "type": "uint256"
+            }
+            ]
+        }];
+
+        provider.injectResult(address);
+        provider.injectValidation(function (payload) {
+            assert.equal(payload.jsonrpc, '2.0');
+            assert.equal(payload.method, 'eth_sendTransaction');
+            assert.equal(payload.params[0].data, code + '0000000000000000000000000000000000000000000000000000000000000002');
+            done();
+        });
+        
+        var Con = contract(description);
+        var myCon = new Con(code, 2);
+    });
 });