Issue 1114: New datatype module

Current status:
- moved number(), float(), hexaDecimal(), boolean(), uuid() from random to datatype
- moved respective test from random.unit to datatype.unit
- tests of moved methods in random now check if DeprecationWarning is printed and respective method in datatype module is called
- adapted all lib files that use moved methods (mostly number)
- adapted tests of respective files to spy on the correct method
- adapted README in order to promote usage of method that logs a DeprecationWarning

8 files changed, 313 insertions, 242 deletions

diff --git a/test/address.unit.js b/test/address.unit.js
index 5b56266c..0306f4f1 100644
--- a/test/address.unit.js
+++ b/test/address.unit.js
@@ -14,7 +14,7 @@ describe("address.js", function () {
         });
 
         afterEach(function () {
-            faker.random.number.restore();
+            faker.datatype.number.restore();
             faker.address.cityPrefix.restore();
             faker.name.firstName.restore();
             faker.name.lastName.restore();
@@ -22,7 +22,7 @@ describe("address.js", function () {
         });
 
         it("occasionally returns prefix + first name + suffix", function () {
-            sinon.stub(faker.random, 'number').returns(0);
+            sinon.stub(faker.datatype, 'number').returns(0);
 
             var city = faker.address.city();
             assert.ok(city);
@@ -33,7 +33,7 @@ describe("address.js", function () {
         });
 
         it("occasionally returns prefix + first name", function () {
-            sinon.stub(faker.random, 'number').returns(1);
+            sinon.stub(faker.datatype, 'number').returns(1);
 
             var city = faker.address.city();
             assert.ok(city);
@@ -43,7 +43,7 @@ describe("address.js", function () {
         });
 
         it("occasionally returns first name + suffix", function () {
-            sinon.stub(faker.random, 'number').returns(2);
+            sinon.stub(faker.datatype, 'number').returns(2);
 
             var city = faker.address.city();
             assert.ok(city);
@@ -52,7 +52,7 @@ describe("address.js", function () {
         });
 
         it("occasionally returns last name + suffix", function () {
-            sinon.stub(faker.random, 'number').returns(3);
+            sinon.stub(faker.datatype, 'number').returns(3);
 
             var city = faker.address.city();
             assert.ok(city);
@@ -79,7 +79,7 @@ describe("address.js", function () {
         });
 
         it("occasionally returns last name + suffix", function () {
-            sinon.stub(faker.random, 'number').returns(0);
+            sinon.stub(faker.datatype, 'number').returns(0);
 
             var street_name = faker.address.streetName();
             assert.ok(street_name);
@@ -87,11 +87,11 @@ describe("address.js", function () {
             assert.ok(faker.name.lastName.calledOnce);
             assert.ok(faker.address.streetSuffix.calledOnce);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("occasionally returns first name + suffix", function () {
-            sinon.stub(faker.random, 'number').returns(1);
+            sinon.stub(faker.datatype, 'number').returns(1);
 
             var street_name = faker.address.streetName();
             assert.ok(street_name);
@@ -100,7 +100,7 @@ describe("address.js", function () {
             assert.ok(!faker.name.lastName.called);
             assert.ok(faker.address.streetSuffix.calledOnce);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("trims trailing whitespace from the name", function() {
@@ -131,7 +131,7 @@ describe("address.js", function () {
         });
 
         it("occasionally returns a 5-digit street number", function () {
-            sinon.stub(faker.random, 'number').returns(0);
+            sinon.stub(faker.datatype, 'number').returns(0);
             var address = faker.address.streetAddress();
             var expected = 5
             var parts = address.split(' ');
@@ -139,11 +139,11 @@ describe("address.js", function () {
             assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
             assert.ok(faker.address.streetName.called);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("occasionally returns a 4-digit street number", function () {
-            sinon.stub(faker.random, 'number').returns(1);
+            sinon.stub(faker.datatype, 'number').returns(1);
             var address = faker.address.streetAddress();
             var parts = address.split(' ');
             var expected = 4
@@ -151,11 +151,11 @@ describe("address.js", function () {
             assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
             assert.ok(faker.address.streetName.called);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("occasionally returns a 3-digit street number", function () {
-            sinon.stub(faker.random, 'number').returns(2);
+            sinon.stub(faker.datatype, 'number').returns(2);
             var address = faker.address.streetAddress();
             var parts = address.split(' ');
             var expected = 3
@@ -164,7 +164,7 @@ describe("address.js", function () {
             assert.ok(faker.address.streetName.called);
             assert.ok(!faker.address.secondaryAddress.called);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         context("when useFulladdress is true", function () {
@@ -307,42 +307,42 @@ describe("address.js", function () {
     describe("latitude()", function () {
         it("returns random latitude", function () {
             for (var i = 0; i < 100; i++) {
-                sinon.spy(faker.random, 'number');
+                sinon.spy(faker.datatype, 'number');
                 var latitude = faker.address.latitude();
                 assert.ok(typeof latitude === 'string');
                 var latitude_float = parseFloat(latitude);
                 assert.ok(latitude_float >= -90.0);
                 assert.ok(latitude_float <= 90.0);
-                assert.ok(faker.random.number.called);
-                faker.random.number.restore();
+                assert.ok(faker.datatype.number.called);
+                faker.datatype.number.restore();
             }
         });
 
         it("returns latitude with min and max and default precision", function () {
             for (var i = 0; i < 100; i++) {
-                sinon.spy(faker.random, 'number');
+                sinon.spy(faker.datatype, 'number');
                 var latitude = faker.address.latitude(-5, 5);
                 assert.ok(typeof latitude === 'string');
                 assert.strictEqual(latitude.split('.')[1].length, 4, "The precision of latitude should be had of 4 digits");
                 var latitude_float = parseFloat(latitude);
                 assert.ok(latitude_float >= -5);
                 assert.ok(latitude_float <= 5);
-                assert.ok(faker.random.number.called);
-                faker.random.number.restore();
+                assert.ok(faker.datatype.number.called);
+                faker.datatype.number.restore();
             }
         });
 
         it("returns random latitude with custom precision", function () {
             for (var i = 0; i < 100; i++) {
-                sinon.spy(faker.random, 'number');
+                sinon.spy(faker.datatype, 'number');
                 var latitude = faker.address.latitude(undefined, undefined, 7);
                 assert.ok(typeof latitude === 'string');
                 assert.strictEqual(latitude.split('.')[1].length, 7, "The precision of latitude should be had of 7 digits");
                 var latitude_float = parseFloat(latitude);
                 assert.ok(latitude_float >= -180);
                 assert.ok(latitude_float <= 180);
-                assert.ok(faker.random.number.called);
-                faker.random.number.restore();
+                assert.ok(faker.datatype.number.called);
+                faker.datatype.number.restore();
             }
         });
     });
@@ -350,42 +350,42 @@ describe("address.js", function () {
     describe("longitude()", function () {
         it("returns random longitude", function () {
             for (var i = 0; i < 100; i++) {
-                sinon.spy(faker.random, 'number');
+                sinon.spy(faker.datatype, 'number');
                 var longitude = faker.address.longitude();
                 assert.ok(typeof longitude === 'string');
                 var longitude_float = parseFloat(longitude);
                 assert.ok(longitude_float >= -180.0);
                 assert.ok(longitude_float <= 180.0);
-                assert.ok(faker.random.number.called);
-                faker.random.number.restore();
+                assert.ok(faker.datatype.number.called);
+                faker.datatype.number.restore();
             }
         });
 
         it("returns random longitude with min and max and default precision", function () {
             for (var i = 0; i < 100; i++) {
-                sinon.spy(faker.random, 'number');
+                sinon.spy(faker.datatype, 'number');
                 var longitude = faker.address.longitude(100, -30);
                 assert.ok(typeof longitude === 'string');
                 assert.strictEqual(longitude.split('.')[1].length, 4, "The precision of longitude should be had of 4 digits");
                 var longitude_float = parseFloat(longitude);
                 assert.ok(longitude_float >= -30);
                 assert.ok(longitude_float <= 100);
-                assert.ok(faker.random.number.called);
-                faker.random.number.restore();
+                assert.ok(faker.datatype.number.called);
+                faker.datatype.number.restore();
             }
         });
 
         it("returns random longitude with custom precision", function () {
             for (var i = 0; i < 100; i++) {
-                sinon.spy(faker.random, 'number');
+                sinon.spy(faker.datatype, 'number');
                 var longitude = faker.address.longitude(undefined, undefined, 7);
                 assert.ok(typeof longitude === 'string');
                 assert.strictEqual(longitude.split('.')[1].length, 7, "The precision of longitude should be had of 7 digits");
                 var longitude_float = parseFloat(longitude);
                 assert.ok(longitude_float >= -180);
                 assert.ok(longitude_float <= 180);
-                assert.ok(faker.random.number.called);
-                faker.random.number.restore();
+                assert.ok(faker.datatype.number.called);
+                faker.datatype.number.restore();
             }
         });
     });
diff --git a/test/company.unit.js b/test/company.unit.js
index 06292b35..df8b5a2c 100644
--- a/test/company.unit.js
+++ b/test/company.unit.js
@@ -9,34 +9,34 @@ describe("company.js", function () {
 
         it("sometimes returns three last names", function () {
             sinon.spy(faker.name, 'lastName');
-            sinon.stub(faker.random, 'number').returns(2);
+            sinon.stub(faker.datatype, 'number').returns(2);
             var name = faker.company.companyName();
             var parts = name.split(' ');
 
             assert.strictEqual(parts.length, 4); // account for word 'and'
             assert.ok(faker.name.lastName.calledThrice);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
             faker.name.lastName.restore();
         });
 
         it("sometimes returns two last names separated by a hyphen", function () {
             sinon.spy(faker.name, 'lastName');
-            sinon.stub(faker.random, 'number').returns(1);
+            sinon.stub(faker.datatype, 'number').returns(1);
             var name = faker.company.companyName();
             var parts = name.split('-');
 
             assert.ok(parts.length >= 2);
             assert.ok(faker.name.lastName.calledTwice);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
             faker.name.lastName.restore();
         });
 
         it("sometimes returns a last name with a company suffix", function () {
             sinon.spy(faker.company, 'companySuffix');
             sinon.spy(faker.name, 'lastName');
-            sinon.stub(faker.random, 'number').returns(0);
+            sinon.stub(faker.datatype, 'number').returns(0);
             var name = faker.company.companyName();
             var parts = name.split(' ');
 
@@ -44,7 +44,7 @@ describe("company.js", function () {
             assert.ok(faker.name.lastName.calledOnce);
             assert.ok(faker.company.companySuffix.calledOnce);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
             faker.name.lastName.restore();
             faker.company.companySuffix.restore();
         });
diff --git a/test/datatype.unit.js b/test/datatype.unit.js
new file mode 100644
index 00000000..7300d26f
--- /dev/null
+++ b/test/datatype.unit.js
@@ -0,0 +1,214 @@
+if (typeof module !== 'undefined') {

+    var assert = require('assert');

+    var sinon = require('sinon');

+    var _ = require('lodash');

+    var faker = require('../index');

+    var mersenne = require('../vendor/mersenne');

+}

+

+

+describe("datatype.js", function () {

+

+    describe("number", function() {

+

+        it("returns a random number given a maximum value as Number", function() {

+            var max = 10;

+            assert.ok(faker.datatype.number(max) <= max);

+        });

+

+        it("returns a random number given a maximum value as Object", function() {

+            var options = { max: 10 };

+            assert.ok(faker.datatype.number(options) <= options.max);

+        });

+

+        it("returns a random number given a maximum value of 0", function() {

+            var options = { max: 0 };

+            assert.ok(faker.datatype.number(options) === 0);

+        });

+

+        it("returns a random number given a negative number minimum and maximum value of 0", function() {

+            var options = { min: -100, max: 0 };

+            assert.ok(faker.datatype.number(options) <= options.max);

+        });

+

+        it("returns a random number between a range", function() {

+            var options = { min: 22, max: 33 };

+            for(var i = 0; i < 100; i++) {

+                var randomNumber = faker.datatype.number(options);

+                assert.ok(randomNumber >= options.min);

+                assert.ok(randomNumber <= options.max);

+            }

+        });

+

+        it("provides numbers with a given precision", function() {

+            var options = { min: 0, max: 1.5, precision: 0.5 };

+            var results = _.chain(_.range(50))

+                .map(function() {

+                    return faker.datatype.number(options);

+                })

+                .uniq()

+                .value()

+                .sort();

+

+            assert.ok(_.includes(results, 0.5));

+            assert.ok(_.includes(results, 1.0));

+

+            assert.strictEqual(results[0], 0);

+            assert.strictEqual(_.last(results), 1.5);

+

+        });

+

+        it("provides numbers with a with exact precision", function() {

+            var options = { min: 0.5, max: 0.99, precision: 0.01 };

+            for(var i = 0; i < 100; i++) {

+                var number = faker.datatype.number(options);

+                assert.strictEqual(number, Number(number.toFixed(2)));

+            }

+        });

+

+        it("should not modify the input object", function() {

+            var min = 1;

+            var max = 2;

+            var opts = {

+                min: min,

+                max: max

+            };

+

+            faker.datatype.number(opts);

+

+            assert.strictEqual(opts.min, min);

+            assert.strictEqual(opts.max, max);

+        });

+

+        it('should return deterministic results when seeded with integer', function() {

+            faker.seed(100);

+            var name = faker.name.findName();

+            assert.strictEqual(name, 'Eva Jenkins');

+        })

+

+        it('should return deterministic results when seeded with 0', function() {

+            faker.seed(0);

+            var name = faker.name.findName();

+            assert.strictEqual(name, 'Lola Sporer');

+        })

+

+        it('should return deterministic results when seeded with array - one element', function() {

+            faker.seed([10]);

+            var name = faker.name.findName();

+            assert.strictEqual(name, 'Duane Kub');

+        })

+

+        it('should return deterministic results when seeded with array - multiple elements', function() {

+            faker.seed([10, 100, 1000]);

+            var name = faker.name.findName();

+            assert.strictEqual(name, 'Alma Shanahan');

+        })

+

+    });

+

+    describe("float", function() {

+

+        it("returns a random float with a default precision value (0.01)", function() {

+            var number = faker.datatype.float();

+            assert.strictEqual(number, Number(number.toFixed(2)));

+        });

+

+        it("returns a random float given a precision value", function() {

+            var number = faker.datatype.float(0.001);

+            assert.strictEqual(number, Number(number.toFixed(3)));

+        });

+

+        it("returns a random number given a maximum value as Object", function() {

+            var options = { max: 10 };

+            assert.ok(faker.datatype.float(options) <= options.max);

+        });

+

+        it("returns a random number given a maximum value of 0", function() {

+            var options = { max: 0 };

+            assert.ok(faker.datatype.float(options) === 0);

+        });

+

+        it("returns a random number given a negative number minimum and maximum value of 0", function() {

+            var options = { min: -100, max: 0 };

+            assert.ok(faker.datatype.float(options) <= options.max);

+        });

+

+        it("returns a random number between a range", function() {

+            var options = { min: 22, max: 33 };

+            for(var i = 0; i < 5; i++) {

+                var randomNumber = faker.datatype.float(options);

+                assert.ok(randomNumber >= options.min);

+                assert.ok(randomNumber <= options.max);

+            }

+        });

+

+        it("provides numbers with a given precision", function() {

+            var options = { min: 0, max: 1.5, precision: 0.5 };

+            var results = _.chain(_.range(50))

+                .map(function() {

+                    return faker.datatype.float(options);

+                })

+                .uniq()

+                .value()

+                .sort();

+

+            assert.ok(_.includes(results, 0.5));

+            assert.ok(_.includes(results, 1.0));

+

+            assert.strictEqual(results[0], 0);

+            assert.strictEqual(_.last(results), 1.5);

+

+        });

+

+        it("provides numbers with a with exact precision", function() {

+            var options = { min: 0.5, max: 0.99, precision: 0.01 };

+            for(var i = 0; i < 100; i++) {

+                var number = faker.datatype.float(options);

+                assert.strictEqual(number, Number(number.toFixed(2)));

+            }

+        });

+

+        it("should not modify the input object", function() {

+            var min = 1;

+            var max = 2;

+            var opts = {

+                min: min,

+                max: max

+            };

+

+            faker.datatype.float(opts);

+

+            assert.strictEqual(opts.min, min);

+            assert.strictEqual(opts.max, max);

+        });

+    });

+

+    describe('boolean', function() {

+        it('should generate a boolean value', function() {

+            var bool = faker.datatype.boolean();

+            assert.ok(typeof bool == 'boolean');

+        });

+    });

+

+    describe('UUID', function() {

+        it('should generate a valid UUID', function() {

+            var UUID = faker.datatype.uuid();

+            var RFC4122 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;

+            assert.ok(RFC4122.test(UUID));

+        })

+    })

+

+    describe('hexaDecimal', function() {

+        var hexaDecimal = faker.datatype.hexaDecimal;

+

+        it('should generate single hex character when no additional argument was provided', function() {

+            var hex = hexaDecimal();

+            assert.ok(hex.match(/^(0x)[0-9a-f]{1}$/i));

+        })

+

+        it('should generate a random hex string', function() {

+            var hex = hexaDecimal(5);

+            assert.ok(hex.match(/^(0x)[0-9a-f]+$/i));

+        })

+    })

+})
\ No newline at end of file
diff --git a/test/finance.unit.js b/test/finance.unit.js
index 47c457c9..aa617d0a 100644
--- a/test/finance.unit.js
+++ b/test/finance.unit.js
@@ -85,7 +85,7 @@ describe('finance.js', function () {
 
         it("should set a specified length", function () {
 
-            var expected = faker.random.number(20);
+            var expected = faker.datatype.number(20);
 
             expected = (expected == 0 || !expected || typeof expected == 'undefined') ? 4 : expected;
 
@@ -138,7 +138,7 @@ describe('finance.js', function () {
 
         it("should work when random variables are passed into the arguments", function () {
 
-            var length = faker.random.number(20);
+            var length = faker.datatype.number(20);
             var ellipsis = (length % 2 === 0) ? true : false;
             var parens = !ellipsis;
 
diff --git a/test/git.unit.js b/test/git.unit.js
index df86be0b..46e25724 100644
--- a/test/git.unit.js
+++ b/test/git.unit.js
@@ -31,7 +31,7 @@ describe("git.js", function() {
       sinon.spy(faker.internet, 'email');
       sinon.spy(faker.name, 'firstName');
       sinon.spy(faker.name, 'lastName');
-      sinon.spy(faker.random, 'number');
+      sinon.spy(faker.datatype, 'number');
     });
 
     afterEach(function() {
@@ -40,13 +40,13 @@ describe("git.js", function() {
       faker.internet.email.restore();
       faker.name.firstName.restore();
       faker.name.lastName.restore();
-      faker.random.number.restore();
+      faker.datatype.number.restore();
     });
 
     it("returns merge entry at random", function() {
       faker.git.commitEntry();
 
-      assert.ok(faker.random.number.called);
+      assert.ok(faker.datatype.number.called);
     });
 
     it("returns a commit entry with git commit message and sha", function() {
diff --git a/test/helpers.unit.js b/test/helpers.unit.js
index 5bbe0fcc..7436da03 100644
--- a/test/helpers.unit.js
+++ b/test/helpers.unit.js
@@ -32,11 +32,11 @@ describe("helpers.js", function () {
 
     describe("shuffle()", function () {
         it("the output is the same length as the input", function () {
-            sinon.spy(faker.random, 'number');
+            sinon.spy(faker.datatype, 'number');
             var shuffled = faker.helpers.shuffle(["a", "b"]);
             assert.ok(shuffled.length === 2);
-            assert.ok(faker.random.number.calledWith(1));
-            faker.random.number.restore();
+            assert.ok(faker.datatype.number.calledWith(1));
+            faker.datatype.number.restore();
         });
 
         it("empty array returns empty array", function () {
diff --git a/test/name.unit.js b/test/name.unit.js
index 40291d2b..89d7effa 100644
--- a/test/name.unit.js
+++ b/test/name.unit.js
@@ -99,28 +99,28 @@ describe("name.js", function () {
 
     describe("findName()", function () {
         it("usually returns a first name and last name", function () {
-            sinon.stub(faker.random, 'number').returns(5);
+            sinon.stub(faker.datatype, 'number').returns(5);
             var name = faker.name.findName();
             assert.ok(name);
             var parts = name.split(' ');
 
             assert.strictEqual(parts.length, 2);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("occasionally returns a first name and last name with a prefix", function () {
-            sinon.stub(faker.random, 'number').returns(0);
+            sinon.stub(faker.datatype, 'number').returns(0);
             var name = faker.name.findName();
             var parts = name.split(' ');
 
             assert.ok(parts.length >= 3);
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("occasionally returns a male full name with a prefix", function () {
-            sinon.stub(faker.random, 'number')
+            sinon.stub(faker.datatype, 'number')
                 .withArgs(8).returns(0) // with prefix
                 .withArgs(1).returns(0); // gender male
 
@@ -132,14 +132,14 @@ describe("name.js", function () {
 
             assert.strictEqual(name, 'X Y Z');
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
             faker.name.prefix.restore();
             faker.name.firstName.restore();
             faker.name.lastName.restore();
         });
 
         it("occasionally returns a female full name with a prefix", function () {
-            sinon.stub(faker.random, 'number')
+            sinon.stub(faker.datatype, 'number')
                 .withArgs(8).returns(0) // with prefix
                 .withArgs(1).returns(1); // gender female
 
@@ -151,14 +151,14 @@ describe("name.js", function () {
 
             assert.strictEqual(name, 'J K L');
 
-            faker.random.number.restore();
+            faker.datatype.number.restore();
             faker.name.prefix.restore();
             faker.name.firstName.restore();
             faker.name.lastName.restore();
         });
 
         it("occasionally returns a first name and last name with a suffix", function () {
-            sinon.stub(faker.random, 'number').returns(1);
+            sinon.stub(faker.datatype, 'number').returns(1);
             sinon.stub(faker.name, 'suffix').returns('Jr.');
             var name = faker.name.findName();
             var parts = name.split(' ');
@@ -167,7 +167,7 @@ describe("name.js", function () {
             assert.strictEqual(parts[parts.length-1], 'Jr.');
 
             faker.name.suffix.restore();
-            faker.random.number.restore();
+            faker.datatype.number.restore();
         });
 
         it("needs to work with specific locales and respect the fallbacks", function () {
diff --git a/test/random.unit.js b/test/random.unit.js
index e068c905..28675c31 100644
--- a/test/random.unit.js
+++ b/test/random.unit.js
@@ -9,176 +9,26 @@ if (typeof module !== 'undefined') {
 
 describe("random.js", function () {
   describe("number", function() {
-
-    it("returns a random number given a maximum value as Number", function() {
-      var max = 10;
-      assert.ok(faker.random.number(max) <= max);
-    });
-
-    it("returns a random number given a maximum value as Object", function() {
-      var options = { max: 10 };
-      assert.ok(faker.random.number(options) <= options.max);
+    it("random.number() uses datatype module and prints deprecation warning", function() {
+      sinon.spy(console, 'log')
+      sinon.spy(faker.datatype, 'number');
+      faker.random.number();
+      assert.ok(faker.datatype.number.called);
+      assert.ok(console.log.calledWith('DeprecationWarning: Method is now located in faker.datatype.number'));
+      faker.datatype.number.restore()
+      console.log.restore();
     });
-
-    it("returns a random number given a maximum value of 0", function() {
-      var options = { max: 0 };
-      assert.ok(faker.random.number(options) === 0);
-    });
-
-    it("returns a random number given a negative number minimum and maximum value of 0", function() {
-      var options = { min: -100, max: 0 };
-      assert.ok(faker.random.number(options) <= options.max);
-    });
-
-    it("returns a random number between a range", function() {
-      var options = { min: 22, max: 33 };
-      for(var i = 0; i < 100; i++) {
-        var randomNumber = faker.random.number(options);
-        assert.ok(randomNumber >= options.min);
-        assert.ok(randomNumber <= options.max);
-      }
-    });
-
-    it("provides numbers with a given precision", function() {
-      var options = { min: 0, max: 1.5, precision: 0.5 };
-      var results = _.chain(_.range(50))
-        .map(function() {
-          return faker.random.number(options);
-        })
-        .uniq()
-        .value()
-        .sort();
-
-      assert.ok(_.includes(results, 0.5));
-      assert.ok(_.includes(results, 1.0));
-
-      assert.strictEqual(results[0], 0);
-      assert.strictEqual(_.last(results), 1.5);
-
-    });
-
-    it("provides numbers with a with exact precision", function() {
-      var options = { min: 0.5, max: 0.99, precision: 0.01 };
-      for(var i = 0; i < 100; i++) {
-        var number = faker.random.number(options);
-        assert.strictEqual(number, Number(number.toFixed(2)));
-      }
-    });
-
-    it("should not modify the input object", function() {
-      var min = 1;
-      var max = 2;
-      var opts = {
-        min: min,
-        max: max
-      };
-
-      faker.random.number(opts);
-
-      assert.strictEqual(opts.min, min);
-      assert.strictEqual(opts.max, max);
-    });
-
-    it('should return deterministic results when seeded with integer', function() {
-      faker.seed(100);
-      var name = faker.name.findName();
-      assert.strictEqual(name, 'Eva Jenkins');
-    })
-
-    it('should return deterministic results when seeded with 0', function() {
-      faker.seed(0);
-      var name = faker.name.findName();
-      assert.strictEqual(name, 'Lola Sporer');
-    })
-
-    it('should return deterministic results when seeded with array - one element', function() {
-      faker.seed([10]);
-      var name = faker.name.findName();
-      assert.strictEqual(name, 'Duane Kub');
-    })
-
-    it('should return deterministic results when seeded with array - multiple elements', function() {
-      faker.seed([10, 100, 1000]);
-      var name = faker.name.findName();
-      assert.strictEqual(name, 'Alma Shanahan');
-    })
-
   });
 
   describe("float", function() {
-
-    it("returns a random float with a default precision value (0.01)", function() {
-      var number = faker.random.float();
-      assert.strictEqual(number, Number(number.toFixed(2)));
-    });
-
-    it("returns a random float given a precision value", function() {
-      var number = faker.random.float(0.001);
-      assert.strictEqual(number, Number(number.toFixed(3)));
-    });
-
-    it("returns a random number given a maximum value as Object", function() {
-      var options = { max: 10 };
-      assert.ok(faker.random.float(options) <= options.max);
-    });
-
-    it("returns a random number given a maximum value of 0", function() {
-      var options = { max: 0 };
-      assert.ok(faker.random.float(options) === 0);
-    });
-
-    it("returns a random number given a negative number minimum and maximum value of 0", function() {
-      var options = { min: -100, max: 0 };
-      assert.ok(faker.random.float(options) <= options.max);
-    });
-
-    it("returns a random number between a range", function() {
-      var options = { min: 22, max: 33 };
-      for(var i = 0; i < 5; i++) {
-        var randomNumber = faker.random.float(options);
-        assert.ok(randomNumber >= options.min);
-        assert.ok(randomNumber <= options.max);
-      }
-    });
-
-    it("provides numbers with a given precision", function() {
-      var options = { min: 0, max: 1.5, precision: 0.5 };
-      var results = _.chain(_.range(50))
-        .map(function() {
-          return faker.random.float(options);
-        })
-        .uniq()
-        .value()
-        .sort();
-
-      assert.ok(_.includes(results, 0.5));
-      assert.ok(_.includes(results, 1.0));
-
-      assert.strictEqual(results[0], 0);
-      assert.strictEqual(_.last(results), 1.5);
-
-    });
-
-    it("provides numbers with a with exact precision", function() {
-      var options = { min: 0.5, max: 0.99, precision: 0.01 };
-      for(var i = 0; i < 100; i++) {
-        var number = faker.random.float(options);
-        assert.strictEqual(number, Number(number.toFixed(2)));
-      }
-    });
-
-    it("should not modify the input object", function() {
-      var min = 1;
-      var max = 2;
-      var opts = {
-        min: min,
-        max: max
-      };
-
-      faker.random.float(opts);
-
-      assert.strictEqual(opts.min, min);
-      assert.strictEqual(opts.max, max);
+    it("random.float() uses datatype module and prints deprecation warning", function() {
+      sinon.spy(console, 'log')
+      sinon.spy(faker.datatype, 'float');
+      faker.random.float();
+      assert.ok(faker.datatype.float.called);
+      assert.ok(console.log.calledWith('DeprecationWarning: Method is now located in faker.datatype.float'));
+      faker.datatype.float.restore()
+      console.log.restore();
     });
   });
 
@@ -235,17 +85,26 @@ describe("random.js", function () {
   });
 
   describe('UUID', function() {
-    it('should generate a valid UUID', function() {
-      var UUID = faker.random.uuid();
-      var RFC4122 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-      assert.ok(RFC4122.test(UUID));
-    })
+    it("random.uuid() uses datatype module and prints deprecation warning", function() {
+      sinon.spy(console, 'log')
+      sinon.spy(faker.datatype, 'uuid');
+      faker.random.uuid();
+      assert.ok(faker.datatype.uuid.called);
+      assert.ok(console.log.calledWith('DeprecationWarning: Method is now located in faker.datatype.uuid'));
+      faker.datatype.uuid.restore()
+      console.log.restore();
+    });
   })
 
   describe('boolean', function() {
-    it('should generate a boolean value', function() {
-      var bool = faker.random.boolean();
-      assert.ok(typeof bool == 'boolean');
+    it("random.boolean() uses datatype module and prints deprecation warning", function() {
+      sinon.spy(console, 'log')
+      sinon.spy(faker.datatype, 'boolean');
+      faker.random.boolean();
+      assert.ok(faker.datatype.boolean.called);
+      assert.ok(console.log.calledWith('DeprecationWarning: Method is now located in faker.datatype.boolean'));
+      faker.datatype.boolean.restore()
+      console.log.restore();
     });
   });
 
@@ -316,17 +175,15 @@ describe("random.js", function () {
   });
 
   describe('hexaDecimal', function() {
-    var hexaDecimal = faker.random.hexaDecimal;
-
-    it('should generate single hex character when no additional argument was provided', function() {
-      var hex = hexaDecimal();
-      assert.ok(hex.match(/^(0x)[0-9a-f]{1}$/i));
-    })
-
-    it('should generate a random hex string', function() {
-      var hex = hexaDecimal(5);
-      assert.ok(hex.match(/^(0x)[0-9a-f]+$/i));
-    })
+    it("random.hexaDecimal() uses datatype module and prints deprecation warning", function() {
+      sinon.spy(console, 'log')
+      sinon.spy(faker.datatype, 'hexaDecimal');
+      faker.random.hexaDecimal();
+      assert.ok(faker.datatype.hexaDecimal.called);
+      assert.ok(console.log.calledWith('DeprecationWarning: Method is now located in faker.datatype.hexaDecimal'));
+      faker.datatype.hexaDecimal.restore()
+      console.log.restore();
+    });
   })
 
   describe("mersenne twister", function() {