Linting fixes for `./test`

1 files changed, 482 insertions, 482 deletions

diff --git a/test/address.unit.js b/test/address.unit.js
index 0306f4f1..57f4c8d7 100644
--- a/test/address.unit.js
+++ b/test/address.unit.js
@@ -1,558 +1,558 @@
 if (typeof module !== 'undefined') {
-    var assert = require('assert');
-    var sinon = require('sinon');
-    var faker = require('../index');
+  var assert = require('assert');
+  var sinon = require('sinon');
+  var faker = require('../index');
 }
 
 describe("address.js", function () {
-    describe("city()", function () {
-        beforeEach(function () {
-            sinon.spy(faker.address, 'cityPrefix');
-            sinon.spy(faker.name, 'firstName');
-            sinon.spy(faker.name, 'lastName');
-            sinon.spy(faker.address, 'citySuffix');
-        });
+  describe("city()", function () {
+    beforeEach(function () {
+      sinon.spy(faker.address, 'cityPrefix');
+      sinon.spy(faker.name, 'firstName');
+      sinon.spy(faker.name, 'lastName');
+      sinon.spy(faker.address, 'citySuffix');
+    });
 
-        afterEach(function () {
-            faker.datatype.number.restore();
-            faker.address.cityPrefix.restore();
-            faker.name.firstName.restore();
-            faker.name.lastName.restore();
-            faker.address.citySuffix.restore();
-        });
+    afterEach(function () {
+      faker.datatype.number.restore();
+      faker.address.cityPrefix.restore();
+      faker.name.firstName.restore();
+      faker.name.lastName.restore();
+      faker.address.citySuffix.restore();
+    });
 
-        it("occasionally returns prefix + first name + suffix", function () {
-            sinon.stub(faker.datatype, 'number').returns(0);
+    it("occasionally returns prefix + first name + suffix", function () {
+      sinon.stub(faker.datatype, 'number').returns(0);
 
-            var city = faker.address.city();
-            assert.ok(city);
+      var city = faker.address.city();
+      assert.ok(city);
 
-            assert.ok(faker.address.cityPrefix.calledOnce);
-            assert.ok(faker.name.firstName.calledOnce);
-            assert.ok(faker.address.citySuffix.calledOnce);
-        });
+      assert.ok(faker.address.cityPrefix.calledOnce);
+      assert.ok(faker.name.firstName.calledOnce);
+      assert.ok(faker.address.citySuffix.calledOnce);
+    });
 
-        it("occasionally returns prefix + first name", function () {
-            sinon.stub(faker.datatype, 'number').returns(1);
+    it("occasionally returns prefix + first name", function () {
+      sinon.stub(faker.datatype, 'number').returns(1);
 
-            var city = faker.address.city();
-            assert.ok(city);
+      var city = faker.address.city();
+      assert.ok(city);
 
-            assert.ok(faker.address.cityPrefix.calledOnce);
-            assert.ok(faker.name.firstName.calledOnce);
-        });
+      assert.ok(faker.address.cityPrefix.calledOnce);
+      assert.ok(faker.name.firstName.calledOnce);
+    });
 
-        it("occasionally returns first name + suffix", function () {
-            sinon.stub(faker.datatype, 'number').returns(2);
+    it("occasionally returns first name + suffix", function () {
+      sinon.stub(faker.datatype, 'number').returns(2);
 
-            var city = faker.address.city();
-            assert.ok(city);
+      var city = faker.address.city();
+      assert.ok(city);
 
-            assert.ok(faker.address.citySuffix.calledOnce);
-        });
+      assert.ok(faker.address.citySuffix.calledOnce);
+    });
 
-        it("occasionally returns last name + suffix", function () {
-            sinon.stub(faker.datatype, 'number').returns(3);
+    it("occasionally returns last name + suffix", function () {
+      sinon.stub(faker.datatype, 'number').returns(3);
 
-            var city = faker.address.city();
-            assert.ok(city);
+      var city = faker.address.city();
+      assert.ok(city);
 
-            assert.ok(!faker.address.cityPrefix.called);
-            assert.ok(!faker.name.firstName.called);
-            assert.ok(faker.name.lastName.calledOnce);
-            assert.ok(faker.address.citySuffix.calledOnce);
-        });
+      assert.ok(!faker.address.cityPrefix.called);
+      assert.ok(!faker.name.firstName.called);
+      assert.ok(faker.name.lastName.calledOnce);
+      assert.ok(faker.address.citySuffix.calledOnce);
     });
+  });
 
 
-    describe("streetName()", function () {
-        beforeEach(function () {
-            sinon.spy(faker.name, 'firstName');
-            sinon.spy(faker.name, 'lastName');
-            sinon.spy(faker.address, 'streetSuffix');
-        });
+  describe("streetName()", function () {
+    beforeEach(function () {
+      sinon.spy(faker.name, 'firstName');
+      sinon.spy(faker.name, 'lastName');
+      sinon.spy(faker.address, 'streetSuffix');
+    });
 
-        afterEach(function () {
-            faker.name.firstName.restore();
-            faker.name.lastName.restore();
-            faker.address.streetSuffix.restore();
-        });
+    afterEach(function () {
+      faker.name.firstName.restore();
+      faker.name.lastName.restore();
+      faker.address.streetSuffix.restore();
+    });
 
-        it("occasionally returns last name + suffix", function () {
-            sinon.stub(faker.datatype, 'number').returns(0);
+    it("occasionally returns last name + suffix", function () {
+      sinon.stub(faker.datatype, 'number').returns(0);
 
-            var street_name = faker.address.streetName();
-            assert.ok(street_name);
-            assert.ok(!faker.name.firstName.called);
-            assert.ok(faker.name.lastName.calledOnce);
-            assert.ok(faker.address.streetSuffix.calledOnce);
+      var street_name = faker.address.streetName();
+      assert.ok(street_name);
+      assert.ok(!faker.name.firstName.called);
+      assert.ok(faker.name.lastName.calledOnce);
+      assert.ok(faker.address.streetSuffix.calledOnce);
 
-            faker.datatype.number.restore();
-        });
+      faker.datatype.number.restore();
+    });
 
-        it("occasionally returns first name + suffix", function () {
-            sinon.stub(faker.datatype, 'number').returns(1);
+    it("occasionally returns first name + suffix", function () {
+      sinon.stub(faker.datatype, 'number').returns(1);
 
-            var street_name = faker.address.streetName();
-            assert.ok(street_name);
+      var street_name = faker.address.streetName();
+      assert.ok(street_name);
 
-            assert.ok(faker.name.firstName.calledOnce);
-            assert.ok(!faker.name.lastName.called);
-            assert.ok(faker.address.streetSuffix.calledOnce);
+      assert.ok(faker.name.firstName.calledOnce);
+      assert.ok(!faker.name.lastName.called);
+      assert.ok(faker.address.streetSuffix.calledOnce);
 
-            faker.datatype.number.restore();
-        });
+      faker.datatype.number.restore();
+    });
 
-        it("trims trailing whitespace from the name", function() {
-            faker.address.streetSuffix.restore();
+    it("trims trailing whitespace from the name", function() {
+      faker.address.streetSuffix.restore();
 
-            sinon.stub(faker.address, 'streetSuffix').returns("")
-            var street_name = faker.address.streetName();
-            assert.ok(!street_name.match(/ $/));
-        });
+      sinon.stub(faker.address, 'streetSuffix').returns("")
+      var street_name = faker.address.streetName();
+      assert.ok(!street_name.match(/ $/));
     });
+  });
 
 
 
-    describe("streetAddress()", function () {
+  describe("streetAddress()", function () {
 
-        var errorExpectDigits = function(expected){
-            return "The street number should be had " + expected + " digits"
-        }
+    var errorExpectDigits = function(expected){
+      return "The street number should be had " + expected + " digits"
+    }
 
-        beforeEach(function () {
-            sinon.spy(faker.address, 'streetName');
-            sinon.spy(faker.address, 'secondaryAddress');
-        });
+    beforeEach(function () {
+      sinon.spy(faker.address, 'streetName');
+      sinon.spy(faker.address, 'secondaryAddress');
+    });
 
-        afterEach(function () {
-            faker.address.streetName.restore();
-            faker.address.secondaryAddress.restore();
-        });
+    afterEach(function () {
+      faker.address.streetName.restore();
+      faker.address.secondaryAddress.restore();
+    });
 
-        it("occasionally returns a 5-digit street number", function () {
-            sinon.stub(faker.datatype, 'number').returns(0);
-            var address = faker.address.streetAddress();
-            var expected = 5
-            var parts = address.split(' ');
+    it("occasionally returns a 5-digit street number", function () {
+      sinon.stub(faker.datatype, 'number').returns(0);
+      var address = faker.address.streetAddress();
+      var expected = 5
+      var parts = address.split(' ');
 
-            assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
-            assert.ok(faker.address.streetName.called);
+      assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
+      assert.ok(faker.address.streetName.called);
 
-            faker.datatype.number.restore();
-        });
+      faker.datatype.number.restore();
+    });
 
-        it("occasionally returns a 4-digit street number", function () {
-            sinon.stub(faker.datatype, 'number').returns(1);
-            var address = faker.address.streetAddress();
-            var parts = address.split(' ');
-            var expected = 4
+    it("occasionally returns a 4-digit street number", function () {
+      sinon.stub(faker.datatype, 'number').returns(1);
+      var address = faker.address.streetAddress();
+      var parts = address.split(' ');
+      var expected = 4
 
-            assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
-            assert.ok(faker.address.streetName.called);
+      assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
+      assert.ok(faker.address.streetName.called);
 
-            faker.datatype.number.restore();
-        });
+      faker.datatype.number.restore();
+    });
 
-        it("occasionally returns a 3-digit street number", function () {
-            sinon.stub(faker.datatype, 'number').returns(2);
-            var address = faker.address.streetAddress();
-            var parts = address.split(' ');
-            var expected = 3
+    it("occasionally returns a 3-digit street number", function () {
+      sinon.stub(faker.datatype, 'number').returns(2);
+      var address = faker.address.streetAddress();
+      var parts = address.split(' ');
+      var expected = 3
 
-            assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
-            assert.ok(faker.address.streetName.called);
-            assert.ok(!faker.address.secondaryAddress.called);
+      assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
+      assert.ok(faker.address.streetName.called);
+      assert.ok(!faker.address.secondaryAddress.called);
 
-            faker.datatype.number.restore();
-        });
+      faker.datatype.number.restore();
+    });
 
-        context("when useFulladdress is true", function () {
-            it("adds a secondary address to the result", function () {
-                faker.address.streetAddress(true);
+    context("when useFulladdress is true", function () {
+      it("adds a secondary address to the result", function () {
+        faker.address.streetAddress(true);
         
-                assert.ok(faker.address.secondaryAddress.called);
-            });
-        });
-    });
-
-
-    describe("secondaryAddress()", function () {
-        it("randomly chooses an Apt or Suite number", function () {
-            sinon.spy(faker.random, 'arrayElement');
-
-            var address = faker.address.secondaryAddress();
-
-            var expected_array = [
-                'Apt. ###',
-                'Suite ###'
-            ];
-
-            assert.ok(address);
-            assert.ok(faker.random.arrayElement.calledWith(expected_array));
-            faker.random.arrayElement.restore();
-        });
-    });
-
-    describe("county()", function () {
-        it("returns random county", function () {
-            sinon.spy(faker.address, 'county');
-            var county = faker.address.county();
-            assert.ok(county);
-            assert.ok(faker.address.county.called);
-            faker.address.county.restore();
-        });
-    });
-
-    describe("country()", function () {
-        it("returns random country", function () {
-            sinon.spy(faker.address, 'country');
-            var country = faker.address.country();
-            assert.ok(country);
-            assert.ok(faker.address.country.called);
-            faker.address.country.restore();
-        });
-    });
-
-    describe("countryCode()", function () {
-
-        it("returns random countryCode", function () {
-            sinon.spy(faker.address, 'countryCode');
-            var countryCode = faker.address.countryCode();
-            assert.ok(countryCode);
-            assert.ok(faker.address.countryCode.called);
-            faker.address.countryCode.restore();
-        });
-
-        it("returns random alpha-3 countryCode", function () {
-            sinon.spy(faker.address, 'countryCode');
-            var countryCode = faker.address.countryCode("alpha-3");
-            assert.ok(countryCode);
-            assert.ok(faker.address.countryCode.called);
-            assert.strictEqual(countryCode.length, 3, "The countryCode should be had 3 characters");
-            faker.address.countryCode.restore();
-        });
+        assert.ok(faker.address.secondaryAddress.called);
+      });
+    });
+  });
+
+
+  describe("secondaryAddress()", function () {
+    it("randomly chooses an Apt or Suite number", function () {
+      sinon.spy(faker.random, 'arrayElement');
+
+      var address = faker.address.secondaryAddress();
+
+      var expected_array = [
+        'Apt. ###',
+        'Suite ###'
+      ];
+
+      assert.ok(address);
+      assert.ok(faker.random.arrayElement.calledWith(expected_array));
+      faker.random.arrayElement.restore();
+    });
+  });
+
+  describe("county()", function () {
+    it("returns random county", function () {
+      sinon.spy(faker.address, 'county');
+      var county = faker.address.county();
+      assert.ok(county);
+      assert.ok(faker.address.county.called);
+      faker.address.county.restore();
+    });
+  });
+
+  describe("country()", function () {
+    it("returns random country", function () {
+      sinon.spy(faker.address, 'country');
+      var country = faker.address.country();
+      assert.ok(country);
+      assert.ok(faker.address.country.called);
+      faker.address.country.restore();
+    });
+  });
+
+  describe("countryCode()", function () {
+
+    it("returns random countryCode", function () {
+      sinon.spy(faker.address, 'countryCode');
+      var countryCode = faker.address.countryCode();
+      assert.ok(countryCode);
+      assert.ok(faker.address.countryCode.called);
+      faker.address.countryCode.restore();
+    });
+
+    it("returns random alpha-3 countryCode", function () {
+      sinon.spy(faker.address, 'countryCode');
+      var countryCode = faker.address.countryCode("alpha-3");
+      assert.ok(countryCode);
+      assert.ok(faker.address.countryCode.called);
+      assert.strictEqual(countryCode.length, 3, "The countryCode should be had 3 characters");
+      faker.address.countryCode.restore();
+    });
         
+  });
+
+  describe("state()", function () {
+    it("returns random state", function () {
+      sinon.spy(faker.address, 'state');
+      var state = faker.address.state();
+      assert.ok(state);
+      assert.ok(faker.address.state.called);
+      faker.address.state.restore();
+    });
+  });
+
+  describe("zipCode()", function () {
+    it("returns random zipCode", function () {
+      sinon.spy(faker.address, 'zipCode');
+      var zipCode = faker.address.zipCode();
+      assert.ok(zipCode);
+      assert.ok(faker.address.zipCode.called);
+      faker.address.zipCode.restore();
+    });
+
+    it("returns random zipCode - user specified format", function () {
+      var zipCode = faker.address.zipCode("?#? #?#");
+      assert.ok(zipCode.match(/^[A-Za-z]\d[A-Za-z]\s\d[A-Za-z]\d$/));
+      // try another format
+      zipCode = faker.address.zipCode("###-###");
+      assert.ok(zipCode.match(/^\d{3}-\d{3}$/));
     });
 
-    describe("state()", function () {
-        it("returns random state", function () {
-            sinon.spy(faker.address, 'state');
-            var state = faker.address.state();
-            assert.ok(state);
-            assert.ok(faker.address.state.called);
-            faker.address.state.restore();
-        });
-    });
-
-    describe("zipCode()", function () {
-        it("returns random zipCode", function () {
-            sinon.spy(faker.address, 'zipCode');
-            var zipCode = faker.address.zipCode();
-            assert.ok(zipCode);
-            assert.ok(faker.address.zipCode.called);
-            faker.address.zipCode.restore();
-        });
-
-        it("returns random zipCode - user specified format", function () {
-            var zipCode = faker.address.zipCode("?#? #?#");
-            assert.ok(zipCode.match(/^[A-Za-z]\d[A-Za-z]\s\d[A-Za-z]\d$/));
-            // try another format
-            zipCode = faker.address.zipCode("###-###");
-            assert.ok(zipCode.match(/^\d{3}-\d{3}$/));
-        });
-
-        it("returns zipCode with proper locale format", function () {
-            // we'll use the en_CA locale..
-            faker.locale = "en_CA";
-            var zipCode = faker.address.zipCode();
-            assert.ok(zipCode.match(/^[A-Za-z]\d[A-Za-z]\s?\d[A-Za-z]\d$/));
-        });
-    });
-
-    describe("zipCodeByState()", function () {
-        it("returns zipCode valid for specified State", function () {
-          faker.locale = "en_US";
-          var states = ["IL", "GA", "WA"];
-
-          var zipCode1 = faker.address.zipCodeByState(states[0]);
-          assert.ok(zipCode1 >= 60001);
-          assert.ok(zipCode1 <= 62999);
-          var zipCode2 = faker.address.zipCodeByState(states[1]);
-          assert.ok(zipCode2 >= 30001);
-          assert.ok(zipCode2 <= 31999);
-          var zipCode3 = faker.address.zipCodeByState(states[2]);
-          assert.ok(zipCode3 >= 98001);
-          assert.ok(zipCode3 <= 99403);
-        });
-
-        it("returns undefined if state is invalid", function () {
-            var state = "XX";
-            sinon.spy(faker.address, 'zipCode');
-            faker.address.zipCodeByState(state);
-            assert.ok(faker.address.zipCode.called);
-            faker.address.zipCode.restore();
-        });
-
-        it("returns undefined if state is valid but localeis invalid", function () {
-            faker.locale = "zh_CN";
-            var state = "IL";
-            sinon.spy(faker.address, 'zipCode');
-            faker.address.zipCodeByState(state);
-            assert.ok(faker.address.zipCode.called);
-            faker.address.zipCode.restore();
-        });
-    });
-
-    describe("latitude()", function () {
-        it("returns random latitude", function () {
-            for (var i = 0; i < 100; i++) {
-                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.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.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.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.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.datatype.number.called);
-                faker.datatype.number.restore();
-            }
-        });
-    });
-
-    describe("longitude()", function () {
-        it("returns random longitude", function () {
-            for (var i = 0; i < 100; i++) {
-                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.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.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.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.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.datatype.number.called);
-                faker.datatype.number.restore();
-            }
-        });
-    });
-
-    describe("direction()", function () {
-        it("returns random direction", function () {
-            sinon.stub(faker.address, 'direction').returns('North');
-            var direction = faker.address.direction();
-            var expected = 'North';
-
-            assert.strictEqual(direction, expected, "The random direction should be equals " + expected);
-            faker.address.direction.restore();
-        })
-
-        it("returns abbreviation when useAbbr is false", function () {
-            sinon.stub(faker.address, 'direction').returns('N');
-            var direction = faker.address.direction(false);
-            var expected = 'N';
-            assert.strictEqual(direction, expected, "The abbreviation of direction when useAbbr is false should be equals " + expected+ ". Current is " + direction);
-            faker.address.direction.restore();
-        })
-
-        it("returns abbreviation when useAbbr is true", function () {
-            var direction = faker.address.direction(true);
-            var expectedType = 'string';
-            var lengthDirection = direction.length
-            var prefixErrorMessage = "The abbreviation of direction when useAbbr is true should"
-            assert.strictEqual(typeof direction, expectedType, prefixErrorMessage + " be typeof string. Current is" + typeof direction);
-            assert.strictEqual(lengthDirection <= 2, true, prefixErrorMessage + " have a length less or equals 2. Current is " + lengthDirection);
-        })
-
-        it("returns abbreviation when useAbbr is true", function () {
-            sinon.stub(faker.address, 'direction').returns('N');
-            var direction = faker.address.direction(true);
-            var expected = 'N';
-            assert.strictEqual(direction, expected, "The abbreviation of direction when useAbbr is true should be equals " + expected + ". Current is " + direction);
-            faker.address.direction.restore();
-        })
+    it("returns zipCode with proper locale format", function () {
+      // we'll use the en_CA locale..
+      faker.locale = "en_CA";
+      var zipCode = faker.address.zipCode();
+      assert.ok(zipCode.match(/^[A-Za-z]\d[A-Za-z]\s?\d[A-Za-z]\d$/));
+    });
+  });
+
+  describe("zipCodeByState()", function () {
+    it("returns zipCode valid for specified State", function () {
+      faker.locale = "en_US";
+      var states = ["IL", "GA", "WA"];
+
+      var zipCode1 = faker.address.zipCodeByState(states[0]);
+      assert.ok(zipCode1 >= 60001);
+      assert.ok(zipCode1 <= 62999);
+      var zipCode2 = faker.address.zipCodeByState(states[1]);
+      assert.ok(zipCode2 >= 30001);
+      assert.ok(zipCode2 <= 31999);
+      var zipCode3 = faker.address.zipCodeByState(states[2]);
+      assert.ok(zipCode3 >= 98001);
+      assert.ok(zipCode3 <= 99403);
+    });
+
+    it("returns undefined if state is invalid", function () {
+      var state = "XX";
+      sinon.spy(faker.address, 'zipCode');
+      faker.address.zipCodeByState(state);
+      assert.ok(faker.address.zipCode.called);
+      faker.address.zipCode.restore();
+    });
+
+    it("returns undefined if state is valid but localeis invalid", function () {
+      faker.locale = "zh_CN";
+      var state = "IL";
+      sinon.spy(faker.address, 'zipCode');
+      faker.address.zipCodeByState(state);
+      assert.ok(faker.address.zipCode.called);
+      faker.address.zipCode.restore();
+    });
+  });
+
+  describe("latitude()", function () {
+    it("returns random latitude", function () {
+      for (var i = 0; i < 100; i++) {
+        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.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.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.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.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.datatype.number.called);
+        faker.datatype.number.restore();
+      }
+    });
+  });
+
+  describe("longitude()", function () {
+    it("returns random longitude", function () {
+      for (var i = 0; i < 100; i++) {
+        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.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.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.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.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.datatype.number.called);
+        faker.datatype.number.restore();
+      }
+    });
+  });
 
+  describe("direction()", function () {
+    it("returns random direction", function () {
+      sinon.stub(faker.address, 'direction').returns('North');
+      var direction = faker.address.direction();
+      var expected = 'North';
+
+      assert.strictEqual(direction, expected, "The random direction should be equals " + expected);
+      faker.address.direction.restore();
+    })
+
+    it("returns abbreviation when useAbbr is false", function () {
+      sinon.stub(faker.address, 'direction').returns('N');
+      var direction = faker.address.direction(false);
+      var expected = 'N';
+      assert.strictEqual(direction, expected, "The abbreviation of direction when useAbbr is false should be equals " + expected+ ". Current is " + direction);
+      faker.address.direction.restore();
+    })
+
+    it("returns abbreviation when useAbbr is true", function () {
+      var direction = faker.address.direction(true);
+      var expectedType = 'string';
+      var lengthDirection = direction.length
+      var prefixErrorMessage = "The abbreviation of direction when useAbbr is true should"
+      assert.strictEqual(typeof direction, expectedType, prefixErrorMessage + " be typeof string. Current is" + typeof direction);
+      assert.strictEqual(lengthDirection <= 2, true, prefixErrorMessage + " have a length less or equals 2. Current is " + lengthDirection);
     })
 
-    describe("ordinalDirection()", function () {
-        it("returns random ordinal direction", function () {
-            sinon.stub(faker.address, 'ordinalDirection').returns('West');
-            var ordinalDirection = faker.address.ordinalDirection();
-            var expected = 'West';
+    it("returns abbreviation when useAbbr is true", function () {
+      sinon.stub(faker.address, 'direction').returns('N');
+      var direction = faker.address.direction(true);
+      var expected = 'N';
+      assert.strictEqual(direction, expected, "The abbreviation of direction when useAbbr is true should be equals " + expected + ". Current is " + direction);
+      faker.address.direction.restore();
+    })
 
-            assert.strictEqual(ordinalDirection, expected, "The ransom ordinal direction should be equals " + expected + ". Current is " + ordinalDirection);
-            faker.address.ordinalDirection.restore();
-        })
+  })
 
-        it("returns abbreviation when useAbbr is true", function () {
-            sinon.stub(faker.address, 'ordinalDirection').returns('W');
-            var ordinalDirection = faker.address.ordinalDirection(true);
-            var expected = 'W';
+  describe("ordinalDirection()", function () {
+    it("returns random ordinal direction", function () {
+      sinon.stub(faker.address, 'ordinalDirection').returns('West');
+      var ordinalDirection = faker.address.ordinalDirection();
+      var expected = 'West';
 
-            assert.strictEqual(ordinalDirection, expected, "The ordinal direction when useAbbr is true should be equals " + expected + ". Current is " + ordinalDirection);
-            faker.address.ordinalDirection.restore();
-        })
+      assert.strictEqual(ordinalDirection, expected, "The ransom ordinal direction should be equals " + expected + ". Current is " + ordinalDirection);
+      faker.address.ordinalDirection.restore();
+    })
 
-        it("returns abbreviation when useAbbr is true", function () {
-            var ordinalDirection = faker.address.ordinalDirection(true);
-            var expectedType = 'string';
-            var ordinalDirectionLength = ordinalDirection.length;
-            var prefixErrorMessage = "The ordinal direction when useAbbr is true should"
+    it("returns abbreviation when useAbbr is true", function () {
+      sinon.stub(faker.address, 'ordinalDirection').returns('W');
+      var ordinalDirection = faker.address.ordinalDirection(true);
+      var expected = 'W';
 
-            assert.strictEqual(typeof ordinalDirection, expectedType, prefixErrorMessage + " be had typeof equals " + expectedType + ".Current is " + typeof ordinalDirection);
-            assert.strictEqual(ordinalDirectionLength <= 2, true, prefixErrorMessage + " have a length less or equals 2. Current is " + ordinalDirectionLength);
-        })
+      assert.strictEqual(ordinalDirection, expected, "The ordinal direction when useAbbr is true should be equals " + expected + ". Current is " + ordinalDirection);
+      faker.address.ordinalDirection.restore();
+    })
 
+    it("returns abbreviation when useAbbr is true", function () {
+      var ordinalDirection = faker.address.ordinalDirection(true);
+      var expectedType = 'string';
+      var ordinalDirectionLength = ordinalDirection.length;
+      var prefixErrorMessage = "The ordinal direction when useAbbr is true should"
 
+      assert.strictEqual(typeof ordinalDirection, expectedType, prefixErrorMessage + " be had typeof equals " + expectedType + ".Current is " + typeof ordinalDirection);
+      assert.strictEqual(ordinalDirectionLength <= 2, true, prefixErrorMessage + " have a length less or equals 2. Current is " + ordinalDirectionLength);
     })
 
-    describe("cardinalDirection()", function () {
-        it("returns random cardinal direction", function () {
-            sinon.stub(faker.address, 'cardinalDirection').returns('Northwest');
-            var cardinalDirection = faker.address.cardinalDirection();
-            var expected = 'Northwest';
 
-            assert.strictEqual(cardinalDirection, expected, "The random cardinal direction should be equals " + expected + ". Current is " + cardinalDirection);
-            faker.address.cardinalDirection.restore();
-        })
+  })
 
-        it("returns abbreviation when useAbbr is true", function () {
-            sinon.stub(faker.address, 'cardinalDirection').returns('NW');
-            var cardinalDirection = faker.address.cardinalDirection(true);
-            var expected = 'NW';
+  describe("cardinalDirection()", function () {
+    it("returns random cardinal direction", function () {
+      sinon.stub(faker.address, 'cardinalDirection').returns('Northwest');
+      var cardinalDirection = faker.address.cardinalDirection();
+      var expected = 'Northwest';
 
-            assert.strictEqual(cardinalDirection, expected, "The cardinal direction when useAbbr is true should be equals " + expected + ". Current is " + cardinalDirection);
-            faker.address.cardinalDirection.restore();
-        })
+      assert.strictEqual(cardinalDirection, expected, "The random cardinal direction should be equals " + expected + ". Current is " + cardinalDirection);
+      faker.address.cardinalDirection.restore();
+    })
+
+    it("returns abbreviation when useAbbr is true", function () {
+      sinon.stub(faker.address, 'cardinalDirection').returns('NW');
+      var cardinalDirection = faker.address.cardinalDirection(true);
+      var expected = 'NW';
 
-        it("returns abbreviation when useAbbr is true", function () {
-            var cardinalDirection = faker.address.cardinalDirection(true);
-            var expectedType = 'string';
-            var cardinalDirectionLength = cardinalDirection.length;
-            var prefixErrorMessage = "The cardinal direction when useAbbr is true should"
+      assert.strictEqual(cardinalDirection, expected, "The cardinal direction when useAbbr is true should be equals " + expected + ". Current is " + cardinalDirection);
+      faker.address.cardinalDirection.restore();
+    })
 
-            assert.strictEqual(typeof cardinalDirection, expectedType, prefixErrorMessage + " be had typeof equals " + expectedType + ".Current is " + typeof ordinalDirection);
-            assert.strictEqual(cardinalDirectionLength <= 2, true, prefixErrorMessage + " have a length less or equals 2. Current is " + cardinalDirectionLength);
-        })
+    it("returns abbreviation when useAbbr is true", function () {
+      var cardinalDirection = faker.address.cardinalDirection(true);
+      var expectedType = 'string';
+      var cardinalDirectionLength = cardinalDirection.length;
+      var prefixErrorMessage = "The cardinal direction when useAbbr is true should"
 
+      assert.strictEqual(typeof cardinalDirection, expectedType, prefixErrorMessage + " be had typeof equals " + expectedType + ".Current is " + typeof ordinalDirection);
+      assert.strictEqual(cardinalDirectionLength <= 2, true, prefixErrorMessage + " have a length less or equals 2. Current is " + cardinalDirectionLength);
     })
 
-    describe("nearbyGPSCoordinate()", function () {
-        it("returns random gps coordinate within a distance of another one", function () {
-            function haversine(lat1, lon1, lat2, lon2, isMetric) {
-                function degreesToRadians(degrees) {
-                    return degrees * (Math.PI/180.0);
-                }
-                function kilometersToMiles(miles) {
-                    return miles * 0.621371;
-                }
-                var R = 6378.137;
-                var dLat = degreesToRadians(lat2-lat1);
-                var dLon = degreesToRadians(lon2-lon1);
-                var a = Math.sin(dLat/2) * Math.sin(dLat/2)
+  })
+
+  describe("nearbyGPSCoordinate()", function () {
+    it("returns random gps coordinate within a distance of another one", function () {
+      function haversine(lat1, lon1, lat2, lon2, isMetric) {
+        function degreesToRadians(degrees) {
+          return degrees * (Math.PI/180.0);
+        }
+        function kilometersToMiles(miles) {
+          return miles * 0.621371;
+        }
+        var R = 6378.137;
+        var dLat = degreesToRadians(lat2-lat1);
+        var dLon = degreesToRadians(lon2-lon1);
+        var a = Math.sin(dLat/2) * Math.sin(dLat/2)
                     + Math.cos(degreesToRadians(lat1)) * Math.cos(degreesToRadians(lat2))
                     * Math.sin(dLon/2) * Math.sin(dLon/2);
-                var distance = R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
-
-                return isMetric ? distance : kilometersToMiles(distance);
-            }
-            for (var i = 0; i < 10000; i++) {
-                var latFloat1 = parseFloat(faker.address.latitude());
-                var lonFloat1 = parseFloat(faker.address.longitude());
-                var radius = (Math.random() * 99) + 1; // range of [1, 100)
-                var isMetric = (Math.round(Math.random()) == 1);
-
-                var coordinate = faker.address.nearbyGPSCoordinate([latFloat1, lonFloat1], radius, isMetric);
-                assert.ok(coordinate.length === 2);
-                assert.ok(typeof coordinate[0] === 'string');
-                assert.ok(typeof coordinate[1] === 'string');
-
-                var latFloat2 = parseFloat(coordinate[0]);
-                assert.ok(latFloat2 >= -90.0);
-                assert.ok(latFloat2 <= 90.0);
-
-                var lonFloat2 = parseFloat(coordinate[1]);
-                assert.ok(lonFloat2 >= -180.0);
-                assert.ok(lonFloat2 <= 180.0);
-
-                // Due to floating point math, and constants that are not extremely precise,
-                // returned points will not be strictly within the given radius of the input
-                // coordinate. Using a error of 1.0 to compensate.
-                var error = 1.0;
-                var actualDistance = haversine(latFloat1, lonFloat1, latFloat2, lonFloat2, isMetric);
-                assert.ok(actualDistance <= (radius + error));
-            }
-
-            // test once with undefined radius
-            var coordinate = faker.address.nearbyGPSCoordinate([latFloat1, lonFloat1], undefined, isMetric);
-            assert.ok(coordinate.length === 2);
-            assert.ok(typeof coordinate[0] === 'string');
-            assert.ok(typeof coordinate[1] === 'string');
-
-        });
-    });
-
-    describe("timeZone()", function () {
-        it("returns random timeZone", function () {
-            sinon.spy(faker.address, 'timeZone');
-            var timeZone = faker.address.timeZone();
-            assert.ok(timeZone);
-            assert.ok(faker.address.timeZone.called);
-            faker.address.timeZone.restore();
-        });
+        var distance = R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+
+        return isMetric ? distance : kilometersToMiles(distance);
+      }
+      for (var i = 0; i < 10000; i++) {
+        var latFloat1 = parseFloat(faker.address.latitude());
+        var lonFloat1 = parseFloat(faker.address.longitude());
+        var radius = (Math.random() * 99) + 1; // range of [1, 100)
+        var isMetric = (Math.round(Math.random()) == 1);
+
+        var coordinate = faker.address.nearbyGPSCoordinate([latFloat1, lonFloat1], radius, isMetric);
+        assert.ok(coordinate.length === 2);
+        assert.ok(typeof coordinate[0] === 'string');
+        assert.ok(typeof coordinate[1] === 'string');
+
+        var latFloat2 = parseFloat(coordinate[0]);
+        assert.ok(latFloat2 >= -90.0);
+        assert.ok(latFloat2 <= 90.0);
+
+        var lonFloat2 = parseFloat(coordinate[1]);
+        assert.ok(lonFloat2 >= -180.0);
+        assert.ok(lonFloat2 <= 180.0);
+
+        // Due to floating point math, and constants that are not extremely precise,
+        // returned points will not be strictly within the given radius of the input
+        // coordinate. Using a error of 1.0 to compensate.
+        var error = 1.0;
+        var actualDistance = haversine(latFloat1, lonFloat1, latFloat2, lonFloat2, isMetric);
+        assert.ok(actualDistance <= (radius + error));
+      }
+
+      // test once with undefined radius
+      var coordinate = faker.address.nearbyGPSCoordinate([latFloat1, lonFloat1], undefined, isMetric);
+      assert.ok(coordinate.length === 2);
+      assert.ok(typeof coordinate[0] === 'string');
+      assert.ok(typeof coordinate[1] === 'string');
+
+    });
+  });
+
+  describe("timeZone()", function () {
+    it("returns random timeZone", function () {
+      sinon.spy(faker.address, 'timeZone');
+      var timeZone = faker.address.timeZone();
+      assert.ok(timeZone);
+      assert.ok(faker.address.timeZone.called);
+      faker.address.timeZone.restore();
     });
+  });
 
 });