address.unit.js

if (typeof module !== 'undefined') {
  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');
    });

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

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

    it("occasionally returns prefix + first name", function () {
      sinon.stub(faker.datatype, 'number').returns(1);

      var city = faker.address.city();
      assert.ok(city);

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

      var city = faker.address.city();
      assert.ok(city);

      assert.ok(faker.address.citySuffix.calledOnce);
    });

    it("occasionally returns last name + suffix", function () {
      sinon.stub(faker.datatype, 'number').returns(3);

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


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

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

      faker.datatype.number.restore();
    });

    it("occasionally returns first name + suffix", function () {
      sinon.stub(faker.datatype, 'number').returns(1);

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

      faker.datatype.number.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(/ $/));
    });
  });



  describe("streetAddress()", function () {

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

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

      assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
      assert.ok(faker.address.streetName.called);

      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

      assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
      assert.ok(faker.address.streetName.called);

      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

      assert.strictEqual(parts[0].length, expected, errorExpectDigits(expected));
      assert.ok(faker.address.streetName.called);
      assert.ok(!faker.address.secondaryAddress.called);

      faker.datatype.number.restore();
    });

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

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

  })

  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 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';

      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';

      assert.strictEqual(cardinalDirection, expected, "The cardinal direction when useAbbr is true should be equals " + expected + ". Current is " + cardinalDirection);
      faker.address.cardinalDirection.restore();
    })

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

});