namespacing with 'Faker'

7 files changed, 184 insertions, 186 deletions

diff --git a/lib/address.js b/lib/address.js
index e87c1c89..852d50cb 100644
--- a/lib/address.js
+++ b/lib/address.js
@@ -1,5 +1,5 @@
 var helpers = require('./helpers');
-var random = require('./random');
+var Faker = require('../index');
 var definitions = require('../lib/definitions');
 
 exports.zipCode = function () {
@@ -11,24 +11,24 @@ exports.zipCodeFormat = function (format) {
 };
 
 exports.city = function () {
-    switch (random.number(3)) {
+    switch (Faker.random.number(3)) {
     case 0:
-        return random.city_prefix() + " " + random.first_name() + random.city_suffix();
+        return Faker.random.city_prefix() + " " + Faker.random.first_name() + Faker.random.city_suffix();
     case 1:
-        return random.city_prefix() + " " + random.first_name();
+        return Faker.random.city_prefix() + " " + Faker.random.first_name();
     case 2:
-        return random.first_name() + random.city_suffix();
+        return Faker.random.first_name() + Faker.random.city_suffix();
     case 3:
-        return random.last_name() + random.city_suffix();
+        return Faker.random.last_name() + Faker.random.city_suffix();
     }
 };
 
 exports.streetName = function () {
-    switch (random.number(1)) {
+    switch (Faker.random.number(1)) {
     case 0:
-        return random.last_name() + " " + random.street_suffix();
+        return Faker.random.last_name() + " " + Faker.random.street_suffix();
     case 1:
-        return random.first_name() + " " + random.street_suffix();
+        return Faker.random.first_name() + " " + Faker.random.street_suffix();
     }
 };
 
@@ -38,7 +38,7 @@ exports.streetName = function () {
 exports.streetAddress = function (useFullAddress) {
     if (useFullAddress === undefined) { useFullAddress = false; }
     var address = "";
-    switch (random.number(2)) {
+    switch (Faker.random.number(2)) {
     case 0:
         address = helpers.replaceSymbolWithNumber("#####") + " " + this.streetName();
         break;
@@ -62,17 +62,17 @@ exports.secondaryAddress = function () {
 };
 
 exports.brState = function (useAbbr) {
-    return useAbbr ? random.br_state_abbr() : random.br_state();
+    return useAbbr ? Faker.random.br_state_abbr() : Faker.random.br_state();
 };
 
 exports.ukCounty = function () {
-    return random.uk_county();
+    return Faker.random.uk_county();
 };
 
 exports.ukCountry = function () {
-    return random.uk_country();
+    return Faker.random.uk_country();
 };
 
 exports.usState = function (useAbbr) {
-    return useAbbr ? random.us_state_abbr() : random.us_state();
+    return useAbbr ? Faker.random.us_state_abbr() : Faker.random.us_state();
 };
diff --git a/lib/company.js b/lib/company.js
index 959988fb..d33ffb46 100644
--- a/lib/company.js
+++ b/lib/company.js
@@ -1,34 +1,33 @@
-var Name = require('./name');
-var random = require('../lib/random');
+var Faker = require('../index');
 
 var company = {
     suffixes: ["Inc", "and Sons", "LLC", "Group", "and Daughters"],
 
     companyName: function (format) {
-        switch ((format ? format : random.number(3))) {
+        switch ((format ? format : Faker.random.number(3))) {
         case 0:
-            return Name.lastName() + " " + this.companySuffix();
+            return Faker.Name.lastName() + " " + this.companySuffix();
         case 1:
-            return Name.lastName() + "-" + Name.lastName();
+            return Faker.Name.lastName() + "-" + Faker.Name.lastName();
         case 2:
-            return Name.lastName() + ", " + Name.lastName() + " and " + Name.lastName();
+            return Faker.Name.lastName() + ", " + Faker.Name.lastName() + " and " + Faker.Name.lastName();
         }
     },
 
     companySuffix: function () {
-        return random.array_rand(this.suffixes);
+        return Faker.random.array_rand(this.suffixes);
     },
 
     catchPhrase: function () {
-        return random.catch_phrase_adjective() + " " +
-            random.catch_phrase_descriptor() + " " +
-            random.catch_phrase_noun();
+        return Faker.random.catch_phrase_adjective() + " " +
+            Faker.random.catch_phrase_descriptor() + " " +
+            Faker.random.catch_phrase_noun();
     },
 
     bs: function () {
-        return random.bs_adjective() + " " +
-            random.bs_buzz() + " " +
-            random.bs_noun();
+        return Faker.random.bs_adjective() + " " +
+            Faker.random.bs_buzz() + " " +
+            Faker.random.bs_noun();
     }
 };
 
diff --git a/lib/helpers.js b/lib/helpers.js
index 55c107e9..6a86eb37 100644
--- a/lib/helpers.js
+++ b/lib/helpers.js
@@ -1,14 +1,13 @@
-var Faker = require('../Faker');
-var random = require('./random');
+var Faker = require('../index');
 
 // temporary backword-compatibility
 exports.randomNumber = function (range) {
-    return random.number(range);
+    return Faker.random.number(range);
 };
 
 // temporary backword-compatibility
 exports.randomize = function (array) {
-    return random.array_rand(array);
+    return Faker.random.array_rand(array);
 };
 
 // parses string for a symbol and replace it with a random number from 1-10
diff --git a/lib/name.js b/lib/name.js
index bfebe649..ff405c54 100644
--- a/lib/name.js
+++ b/lib/name.js
@@ -1,21 +1,21 @@
-var random = require('./random');
+var Faker = require('../index');
 
 var _name = {
     firstName: function () {
-        return random.first_name();
+        return Faker.random.first_name();
     },
 
     lastName: function () {
-        return random.last_name();
+        return Faker.random.last_name();
     },
 
     findName: function () {
-        var r = random.number(8);
+        var r = Faker.random.number(8);
         switch (r) {
         case 0:
-            return random.name_prefix() + " " + _name.firstName() + " " + _name.lastName();
+            return Faker.random.name_prefix() + " " + _name.firstName() + " " + _name.lastName();
         case 1:
-            return _name.firstName() + " " + _name.lastName() + " " + random.name_suffix();
+            return _name.firstName() + " " + _name.lastName() + " " + Faker.random.name_suffix();
         }
 
         return _name.firstName() + " " + _name.lastName();
diff --git a/test/address.unit.js b/test/address.unit.js
index 0b065495..12ae3f09 100644
--- a/test/address.unit.js
+++ b/test/address.unit.js
@@ -1,159 +1,159 @@
 var assert = require('assert');
 var sinon = require('sinon');
-var faker = require('../index');
+var Faker = require('../index');
 var random = require('../lib/random');
 
 describe("address.js", function () {
     describe("city()", function () {
         beforeEach(function () {
-            sinon.spy(random, 'city_prefix');
-            sinon.spy(random, 'first_name');
-            sinon.spy(random, 'last_name');
-            sinon.spy(random, 'city_suffix');
+            sinon.spy(Faker.random, 'city_prefix');
+            sinon.spy(Faker.random, 'first_name');
+            sinon.spy(Faker.random, 'last_name');
+            sinon.spy(Faker.random, 'city_suffix');
         });
 
         afterEach(function () {
-            random.number.restore();
-            random.city_prefix.restore();
-            random.first_name.restore();
-            random.last_name.restore();
-            random.city_suffix.restore();
+            Faker.random.number.restore();
+            Faker.random.city_prefix.restore();
+            Faker.random.first_name.restore();
+            Faker.random.last_name.restore();
+            Faker.random.city_suffix.restore();
         });
 
         it("occasionally returns prefix + first name + suffix", function () {
-            sinon.stub(random, 'number').returns(0);
+            sinon.stub(Faker.random, 'number').returns(0);
 
-            var city = faker.address.city();
+            var city = Faker.address.city();
             assert.ok(city);
 
-            assert.ok(random.city_prefix.calledOnce);
-            assert.ok(random.first_name.calledOnce);
-            assert.ok(random.city_suffix.calledOnce);
+            assert.ok(Faker.random.city_prefix.calledOnce);
+            assert.ok(Faker.random.first_name.calledOnce);
+            assert.ok(Faker.random.city_suffix.calledOnce);
         });
 
         it("occasionally returns prefix + first name", function () {
-            sinon.stub(random, 'number').returns(1);
+            sinon.stub(Faker.random, 'number').returns(1);
 
-            var city = faker.address.city();
+            var city = Faker.address.city();
             assert.ok(city);
 
-            assert.ok(random.city_prefix.calledOnce);
-            assert.ok(random.first_name.calledOnce);
-            assert.ok(!random.city_suffix.called);
+            assert.ok(Faker.random.city_prefix.calledOnce);
+            assert.ok(Faker.random.first_name.calledOnce);
+            assert.ok(!Faker.random.city_suffix.called);
         });
 
         it("occasionally returns first name + suffix", function () {
-            sinon.stub(random, 'number').returns(2);
+            sinon.stub(Faker.random, 'number').returns(2);
 
-            var city = faker.address.city();
+            var city = Faker.address.city();
             assert.ok(city);
 
-            assert.ok(!random.city_prefix.called);
-            assert.ok(random.first_name.calledOnce);
-            assert.ok(random.city_suffix.calledOnce);
+            assert.ok(!Faker.random.city_prefix.called);
+            assert.ok(Faker.random.first_name.calledOnce);
+            assert.ok(Faker.random.city_suffix.calledOnce);
         });
 
         it("occasionally returns last name + suffix", function () {
-            sinon.stub(random, 'number').returns(3);
+            sinon.stub(Faker.random, 'number').returns(3);
 
-            var city = faker.address.city();
+            var city = Faker.address.city();
             assert.ok(city);
 
-            assert.ok(!random.city_prefix.called);
-            assert.ok(!random.first_name.called);
-            assert.ok(random.last_name.calledOnce);
-            assert.ok(random.city_suffix.calledOnce);
+            assert.ok(!Faker.random.city_prefix.called);
+            assert.ok(!Faker.random.first_name.called);
+            assert.ok(Faker.random.last_name.calledOnce);
+            assert.ok(Faker.random.city_suffix.calledOnce);
         });
     });
 
     describe("streetName()", function () {
         beforeEach(function () {
-            sinon.spy(random, 'first_name');
-            sinon.spy(random, 'last_name');
-            sinon.spy(random, 'street_suffix');
+            sinon.spy(Faker.random, 'first_name');
+            sinon.spy(Faker.random, 'last_name');
+            sinon.spy(Faker.random, 'street_suffix');
         });
 
         afterEach(function () {
-            random.number.restore();
-            random.first_name.restore();
-            random.last_name.restore();
-            random.street_suffix.restore();
+            Faker.random.number.restore();
+            Faker.random.first_name.restore();
+            Faker.random.last_name.restore();
+            Faker.random.street_suffix.restore();
         });
 
         it("occasionally returns last name + suffix", function () {
-            sinon.stub(random, 'number').returns(0);
+            sinon.stub(Faker.random, 'number').returns(0);
 
-            var street_name = faker.address.streetName();
+            var street_name = Faker.address.streetName();
             assert.ok(street_name);
 
-            assert.ok(!random.first_name.called);
-            assert.ok(random.last_name.calledOnce);
-            assert.ok(random.street_suffix.calledOnce);
+            assert.ok(!Faker.random.first_name.called);
+            assert.ok(Faker.random.last_name.calledOnce);
+            assert.ok(Faker.random.street_suffix.calledOnce);
         });
 
         it("occasionally returns first name + suffix", function () {
-            sinon.stub(random, 'number').returns(1);
+            sinon.stub(Faker.random, 'number').returns(1);
 
-            var street_name = faker.address.streetName();
+            var street_name = Faker.address.streetName();
             assert.ok(street_name);
 
-            assert.ok(random.first_name.calledOnce);
-            assert.ok(!random.last_name.called);
-            assert.ok(random.street_suffix.calledOnce);
+            assert.ok(Faker.random.first_name.calledOnce);
+            assert.ok(!Faker.random.last_name.called);
+            assert.ok(Faker.random.street_suffix.calledOnce);
         });
     });
 
     describe("streetAddress()", function () {
         beforeEach(function () {
-            sinon.spy(faker.address, 'streetName');
-            sinon.spy(faker.address, 'secondaryAddress');
+            sinon.spy(Faker.address, 'streetName');
+            sinon.spy(Faker.address, 'secondaryAddress');
         });
 
         afterEach(function () {
-            faker.address.streetName.restore();
-            faker.address.secondaryAddress.restore();
+            Faker.address.streetName.restore();
+            Faker.address.secondaryAddress.restore();
         });
 
         it("occasionally returns a 5-digit street number", function () {
-            sinon.stub(random, 'number').returns(0);
-            var address = faker.address.streetAddress();
+            sinon.stub(Faker.random, 'number').returns(0);
+            var address = Faker.address.streetAddress();
             var parts = address.split(' ');
 
             assert.equal(parts[0].length, 5);
-            assert.ok(faker.address.streetName.called);
+            assert.ok(Faker.address.streetName.called);
 
-            random.number.restore();
+            Faker.random.number.restore();
         });
 
         it("occasionally returns a 4-digit street number", function () {
-            sinon.stub(random, 'number').returns(1);
-            var address = faker.address.streetAddress();
+            sinon.stub(Faker.random, 'number').returns(1);
+            var address = Faker.address.streetAddress();
             var parts = address.split(' ');
 
             assert.equal(parts[0].length, 4);
-            assert.ok(faker.address.streetName.called);
+            assert.ok(Faker.address.streetName.called);
 
-            random.number.restore();
+            Faker.random.number.restore();
         });
 
         it("occasionally returns a 3-digit street number", function () {
-            sinon.stub(random, 'number').returns(2);
-            var address = faker.address.streetAddress();
+            sinon.stub(Faker.random, 'number').returns(2);
+            var address = Faker.address.streetAddress();
             var parts = address.split(' ');
 
             assert.equal(parts[0].length, 3);
-            assert.ok(faker.address.streetName.called);
-            assert.ok(!faker.address.secondaryAddress.called);
+            assert.ok(Faker.address.streetName.called);
+            assert.ok(!Faker.address.secondaryAddress.called);
 
-            random.number.restore();
+            Faker.random.number.restore();
         });
 
         context("when useFulladdress is true", function () {
             it("adds a secondary address to the result", function () {
-                var address = faker.address.streetAddress(true);
+                var address = Faker.address.streetAddress(true);
                 var parts = address.split(' ');
 
-                assert.ok(faker.address.secondaryAddress.called);
+                assert.ok(Faker.address.secondaryAddress.called);
             });
         });
     });
@@ -164,32 +164,32 @@ describe("address.js", function () {
 
     describe("brState()", function() {
         beforeEach(function () {
-            sinon.spy(random, 'br_state_abbr');
-            sinon.spy(random, 'br_state');
+            sinon.spy(Faker.random, 'br_state_abbr');
+            sinon.spy(Faker.random, 'br_state');
         });
 
         afterEach(function () {
-            random.br_state_abbr.restore();
-            random.br_state.restore();
+            Faker.random.br_state_abbr.restore();
+            Faker.random.br_state.restore();
         });
 
         context("when useAbbr is true", function () {
             it("returns a br_state_abbr", function () {
-                var state = faker.address.brState(true);
+                var state = Faker.address.brState(true);
 
                 assert.ok(state);
-                assert.ok(random.br_state_abbr.called);
-                assert.ok(!random.br_state.called);
+                assert.ok(Faker.random.br_state_abbr.called);
+                assert.ok(!Faker.random.br_state.called);
             });
         });
 
         context("when useAbbr is not set", function () {
             it("returns a br_state", function () {
-                var state = faker.address.brState();
+                var state = Faker.address.brState();
 
                 assert.ok(state);
-                assert.ok(!random.br_state_abbr.called);
-                assert.ok(random.br_state.called);
+                assert.ok(!Faker.random.br_state_abbr.called);
+                assert.ok(Faker.random.br_state.called);
             });
         });
     });
diff --git a/test/company.unit.js b/test/company.unit.js
index 5c2f2a15..c99e8725 100644
--- a/test/company.unit.js
+++ b/test/company.unit.js
@@ -1,109 +1,109 @@
 var assert = require('assert');
 var sinon = require('sinon');
-var faker = require('../index');
+var Faker = require('../index');
 var random = require('../lib/random');
 
 describe("company.js", function () {
     describe("companyName()", function () {
         it("lets you specify the type of name to return", function () {
-            sinon.spy(faker.Helpers, 'randomNumber');
-            var name = faker.company.companyName(1);
+            sinon.spy(Faker.Helpers, 'randomNumber');
+            var name = Faker.company.companyName(1);
 
             assert.ok(name.match(/-/));
 
-            assert.ok(!faker.Helpers.randomNumber.called);
-            faker.Helpers.randomNumber.restore();
+            assert.ok(!Faker.Helpers.randomNumber.called);
+            Faker.Helpers.randomNumber.restore();
         });
 
         it("sometimes returns three last names", function () {
-            sinon.spy(random, 'last_name');
-            sinon.stub(random, 'number').returns(2);
-            var name = faker.company.companyName();
+            sinon.spy(Faker.random, 'last_name');
+            sinon.stub(Faker.random, 'number').returns(2);
+            var name = Faker.company.companyName();
             var parts = name.split(' ');
 
             assert.strictEqual(parts.length, 4); // account for word 'and'
-            assert.ok(random.last_name.calledThrice);
+            assert.ok(Faker.random.last_name.calledThrice);
 
-            random.number.restore();
-            random.last_name.restore();
+            Faker.random.number.restore();
+            Faker.random.last_name.restore();
         });
 
         it("sometimes returns two last names separated by a hyphen", function () {
-            sinon.spy(random, 'last_name');
-            sinon.stub(random, 'number').returns(1);
-            var name = faker.company.companyName();
+            sinon.spy(Faker.random, 'last_name');
+            sinon.stub(Faker.random, 'number').returns(1);
+            var name = Faker.company.companyName();
             var parts = name.split('-');
 
             assert.ok(parts.length >= 2);
-            assert.ok(random.last_name.calledTwice);
+            assert.ok(Faker.random.last_name.calledTwice);
 
-            random.number.restore();
-            random.last_name.restore();
+            Faker.random.number.restore();
+            Faker.random.last_name.restore();
         });
 
         it("sometimes returns a last name with a company suffix", function () {
-            sinon.spy(faker.company, 'companySuffix');
-            sinon.spy(random, 'last_name');
-            sinon.stub(random, 'number').returns(0);
-            var name = faker.company.companyName();
+            sinon.spy(Faker.company, 'companySuffix');
+            sinon.spy(Faker.random, 'last_name');
+            sinon.stub(Faker.random, 'number').returns(0);
+            var name = Faker.company.companyName();
             var parts = name.split(' ');
 
             assert.ok(parts.length >= 2);
-            assert.ok(random.last_name.calledOnce);
-            assert.ok(faker.company.companySuffix.calledOnce);
+            assert.ok(Faker.random.last_name.calledOnce);
+            assert.ok(Faker.company.companySuffix.calledOnce);
 
-            random.number.restore();
-            random.last_name.restore();
-            faker.company.companySuffix.restore();
+            Faker.random.number.restore();
+            Faker.random.last_name.restore();
+            Faker.company.companySuffix.restore();
         });
     });
 
     describe("companySuffix()", function () {
         it("returns random value from company.suffixes array", function () {
-            var suffix = faker.company.companySuffix();
-            assert.ok(faker.company.suffixes.indexOf(suffix) !== -1);
+            var suffix = Faker.company.companySuffix();
+            assert.ok(Faker.company.suffixes.indexOf(suffix) !== -1);
         });
     });
 
     describe("catchPhrase()", function () {
         it("returns phrase comprising of a catch phrase adjective, descriptor, and noun", function () {
-            sinon.spy(random, 'array_rand');
-            sinon.spy(random, 'catch_phrase_adjective');
-            sinon.spy(random, 'catch_phrase_descriptor');
-            sinon.spy(random, 'catch_phrase_noun');
-            var phrase = faker.company.catchPhrase();
+            sinon.spy(Faker.random, 'array_rand');
+            sinon.spy(Faker.random, 'catch_phrase_adjective');
+            sinon.spy(Faker.random, 'catch_phrase_descriptor');
+            sinon.spy(Faker.random, 'catch_phrase_noun');
+            var phrase = Faker.company.catchPhrase();
 
             assert.ok(phrase.split(' ').length >= 3);
-            assert.ok(random.array_rand.calledThrice);
-            assert.ok(random.catch_phrase_adjective.calledOnce);
-            assert.ok(random.catch_phrase_descriptor.calledOnce);
-            assert.ok(random.catch_phrase_noun.calledOnce);
-
-            random.array_rand.restore();
-            random.catch_phrase_adjective.restore();
-            random.catch_phrase_descriptor.restore();
-            random.catch_phrase_noun.restore();
+            assert.ok(Faker.random.array_rand.calledThrice);
+            assert.ok(Faker.random.catch_phrase_adjective.calledOnce);
+            assert.ok(Faker.random.catch_phrase_descriptor.calledOnce);
+            assert.ok(Faker.random.catch_phrase_noun.calledOnce);
+
+            Faker.random.array_rand.restore();
+            Faker.random.catch_phrase_adjective.restore();
+            Faker.random.catch_phrase_descriptor.restore();
+            Faker.random.catch_phrase_noun.restore();
         });
     });
 
     describe("bs()", function () {
         it("returns phrase comprising of a BS adjective, buzz, and noun", function () {
-            sinon.spy(random, 'array_rand');
-            sinon.spy(random, 'bs_adjective');
-            sinon.spy(random, 'bs_buzz');
-            sinon.spy(random, 'bs_noun');
-            var bs = faker.company.bs();
+            sinon.spy(Faker.random, 'array_rand');
+            sinon.spy(Faker.random, 'bs_adjective');
+            sinon.spy(Faker.random, 'bs_buzz');
+            sinon.spy(Faker.random, 'bs_noun');
+            var bs = Faker.company.bs();
 
             assert.ok(typeof bs === 'string');
-            assert.ok(random.array_rand.calledThrice);
-            assert.ok(random.bs_adjective.calledOnce);
-            assert.ok(random.bs_buzz.calledOnce);
-            assert.ok(random.bs_noun.calledOnce);
-
-            random.array_rand.restore();
-            random.bs_adjective.restore();
-            random.bs_buzz.restore();
-            random.bs_noun.restore();
+            assert.ok(Faker.random.array_rand.calledThrice);
+            assert.ok(Faker.random.bs_adjective.calledOnce);
+            assert.ok(Faker.random.bs_buzz.calledOnce);
+            assert.ok(Faker.random.bs_noun.calledOnce);
+
+            Faker.random.array_rand.restore();
+            Faker.random.bs_adjective.restore();
+            Faker.random.bs_buzz.restore();
+            Faker.random.bs_noun.restore();
         });
     });
 });
diff --git a/test/name.unit.js b/test/name.unit.js
index c0715023..e054a5a4 100644
--- a/test/name.unit.js
+++ b/test/name.unit.js
@@ -1,62 +1,62 @@
 var assert = require('assert');
 var sinon = require('sinon');
-var faker = require('../index');
+var Faker = require('../index');
 var random = require('../lib/random');
 
 describe("name.js", function () {
     describe("firstName()", function () {
         it("returns a random name", function () {
-            sinon.stub(random, 'first_name').returns('foo');
-            var first_name = faker.name.firstName();
+            sinon.stub(Faker.random, 'first_name').returns('foo');
+            var first_name = Faker.name.firstName();
 
             assert.equal(first_name, 'foo');
 
-            random.first_name.restore();
+            Faker.random.first_name.restore();
         });
     });
 
     describe("lastName()", function () {
         it("returns a random name", function () {
-            sinon.stub(random, 'last_name').returns('foo');
+            sinon.stub(Faker.random, 'last_name').returns('foo');
 
-            var last_name = faker.name.lastName();
+            var last_name = Faker.name.lastName();
 
             assert.equal(last_name, 'foo');
 
-            random.last_name.restore();
+            Faker.random.last_name.restore();
         });
     });
 
     describe("findName()", function () {
         it("usually returns a first name and last name", function () {
-            sinon.stub(random, 'number').returns(5);
-            var name = faker.name.findName();
+            sinon.stub(Faker.random, 'number').returns(5);
+            var name = Faker.name.findName();
             assert.ok(name);
             var parts = name.split(' ');
 
             assert.strictEqual(parts.length, 2);
 
-            random.number.restore();
+            Faker.random.number.restore();
         });
 
         it("occasionally returns a first name and last name with a prefix", function () {
-            sinon.stub(random, 'number').returns(0);
-            var name = faker.name.findName();
+            sinon.stub(Faker.random, 'number').returns(0);
+            var name = Faker.name.findName();
             var parts = name.split(' ');
 
             assert.ok(parts.length >= 3);
 
-            random.number.restore();
+            Faker.random.number.restore();
         });
 
         it("occasionally returns a first name and last name with a suffix", function () {
-            sinon.stub(random, 'number').returns(1);
-            var name = faker.name.findName();
+            sinon.stub(Faker.random, 'number').returns(1);
+            var name = Faker.name.findName();
             var parts = name.split(' ');
 
             assert.ok(parts.length >= 3);
 
-            random.number.restore();
+            Faker.random.number.restore();
         });
     });
 });