namespacing with 'Faker'

3 files changed, 149 insertions, 149 deletions

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();
         });
     });
 });