ffaker 2.2.0 → 2.3.0

data/test/test_address_fi.rb

@@ -4,11 +4,18 @@ require 'helper'
 
 # Test features related to Finnish addresses
 class TestAddressFI < Test::Unit::TestCase
+  include DeterministicHelper
+
   ALPHA = /\A[\p{Alpha}]+/
   DIGIT = /\d{1}/
 
+  assert_methods_are_deterministic(
+    FFaker::AddressFI,
+    :city, :full_address, :random_country, :zip_code
+  )
+
   def test_fi_city
-    assert_match ALPHA, FFaker::AddressFI.city
+    assert_match(ALPHA, FFaker::AddressFI.city)
   end
 
   def test_fi_zip_code
@@ -21,8 +28,8 @@ class TestAddressFI < Test::Unit::TestCase
 
   def test_fi_full_address
     address = FFaker::AddressFI.full_address
-    assert_match ALPHA, address
-    assert_match DIGIT, address
+    assert_match(ALPHA, address)
+    assert_match(DIGIT, address)
     assert_match(/SUOMI/, address)
     assert_match(/[\, a-z]/, address)
   end

data/test/test_address_fr.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'helper'
+
+# Test features related to Finnish addresses
+class TestAddressFR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressFR,
+    :city, :full_address, :street_name, :postal_code
+  )
+end

data/test/test_address_gr.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAddressGR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressGR,
+    :city, :region, :zip_code, :street_name, :street_nbr, :street_address
+  )
+
+  def setup
+    @address_gr = FFaker::AddressGR
+    @street_prefix = FFaker::AddressGR::STREET_PREFIX.join("|")
+  end
+
+  def test_city
+    assert_match /\p{Greek}/, @address_gr.city
+  end
+
+  def test_region
+    assert_match /\p{Greek}/, @address_gr.region
+  end
+
+  def test_zip_code
+    assert_match /\A\d{5}\z/, @address_gr.zip_code
+  end
+
+  def test_street_name
+    assert_match /\p{Greek}/, @address_gr.street_name
+  end
+
+  def test_street_nbr
+    assert_match /\A\d{1,3}\z/, @address_gr.street_nbr
+  end
+
+  def test_street_address
+    address = FFaker::AddressGR.street_address
+    assert_match(/#{@street_prefix}/, address)
+    assert_match(/\p{Greek}/, address)
+  end
+end

data/test/test_address_in.rb

@@ -3,48 +3,56 @@
 require 'helper'
 
 class TestAddressININ < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressIN,
+    :country_code, :country, :pincode, :state_abbr,
+    :state_and_union_territory_abbr, :state_and_union_territory, :state,
+    :time_zone, :union_territory_abbr, :union_territory
+  )
+
   def test_in_state
-    assert_match /\A[A-Z][ A-Za-z]*\z/, FFaker::AddressIN.state
+    assert_match(/\A[A-Z][ A-Za-z]*\z/, FFaker::AddressIN.state)
   end
 
   def test_in_state_abbr
-    assert_match /\A[A-Z]{2}\z/, FFaker::AddressIN.state_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFaker::AddressIN.state_abbr)
   end
 
   def test_in_union_territory
-    assert_match /\A[A-Z][ A-Za-z]*\z/, FFaker::AddressIN.union_territory
+    assert_match(/\A[A-Z][ A-Za-z]*\z/, FFaker::AddressIN.union_territory)
   end
 
   def test_in_union_territory_abbr
-    assert_match /\A[A-Z]{2}\z/, FFaker::AddressIN.union_territory_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFaker::AddressIN.union_territory_abbr)
   end
 
   def test_in_state_and_union_territory
-    assert_match /\A[A-Z][ A-Za-z]*\z/, FFaker::AddressIN.state_and_union_territory
+    assert_match(/\A[A-Z][ A-Za-z]*\z/, FFaker::AddressIN.state_and_union_territory)
   end
 
   def test_in_state_and_union_territory_abbr
-    assert_match /\A[A-Z]{2}\z/, FFaker::AddressIN.state_and_union_territory_abbr
+    assert_match(/\A[A-Z]{2}\z/, FFaker::AddressIN.state_and_union_territory_abbr)
   end
 
   def test_pincode
-    assert_match /[0-9]{6}/, FFaker::AddressIN.pincode
+    assert_match(/[0-9]{6}/, FFaker::AddressIN.pincode)
   end
 
   def test_zip_code
-    assert_match /[0-9]{6}/, FFaker::AddressIN.pincode
+    assert_match(/[0-9]{6}/, FFaker::AddressIN.pincode)
   end
 
   def test_in_country
-    assert_equal "India", FFaker::AddressIN.country
+    assert_equal 'India', FFaker::AddressIN.country
   end
 
   def test_in_country_code
-    assert_equal "IN", FFaker::AddressIN.country_code
+    assert_equal 'IN', FFaker::AddressIN.country_code
   end
 
   def test_in_time_zone
-    assert_equal "Asia/Kolkata", FFaker::AddressIN.time_zone
+    assert_equal 'Asia/Kolkata', FFaker::AddressIN.time_zone
   end
-
 end

data/test/test_address_kr.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'helper'
+
+class TestAddressKR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressKR,
+    :postal_code, :old_postal_code, :road_addess, :land_address, :land_number,
+    :building_name, :address_detail, :street, :town, :borough, :city, :province,
+    :metropolitan_city
+  )
+end

data/test/test_address_mx.rb

@@ -4,23 +4,30 @@ require 'helper'
 
 # Author: guapolo github.com/guapolo
 class TestAddressMX < Test::Unit::TestCase
+  include DeterministicHelper
+  
+  assert_methods_are_deterministic(
+    FFaker::AddressMX,
+    :municipality, :postal_code, :state_abbr, :state, :zip_code
+  )
+
   def test_mx_state
-    assert_match /[\sa-z]/i, FFaker::AddressMX.state
+    assert_match(/[\sa-z]/i, FFaker::AddressMX.state)
   end
 
   def test_mx_state_abbr
-    assert_match /[A-Z]/, FFaker::AddressMX.state_abbr
+    assert_match(/[A-Z]/, FFaker::AddressMX.state_abbr)
   end
 
   def test_postal_code
-    assert_match /[0-9]/, FFaker::AddressMX.postal_code
+    assert_match(/[0-9]/, FFaker::AddressMX.postal_code)
   end
 
   def test_zip_code
-    assert_match /[0-9]/, FFaker::AddressMX.zip_code
+    assert_match(/[0-9]/, FFaker::AddressMX.zip_code)
   end
 
   def test_mx_municipality
-    assert_match /[\sa-z]/i, FFaker::AddressMX.municipality
+    assert_match(/[\sa-z]/i, FFaker::AddressMX.municipality)
   end
 end

data/test/test_address_nl.rb

@@ -3,28 +3,34 @@
 require 'helper'
 
 class TestAddressNL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressNL,
+    :city, :province, :street_address, :street_name, :zip_code
+  )
 
   def setup
     @tester = FFaker::AddressNL
   end
 
   def test_city
-    assert_match /[ a-z]+/, @tester.city
+    assert_match(/[ a-z]+/, @tester.city)
   end
 
   def test_province
-    assert_match /[ a-z]/, @tester.province
+    assert_match(/[ a-z]/, @tester.province)
   end
 
   def test_zip_code
-    assert_match /^\d{4}\s\w{2}$/, @tester.zip_code
+    assert_match(/^\d{4}\s\w{2}$/, @tester.zip_code)
   end
 
   def test_street_name
-    assert_match /[ a-z]+/, @tester.street_name
+    assert_match(/[ a-z]+/, @tester.street_name)
   end
 
   def test_street_address
-    assert_match /[ a-z]+/, @tester.street_address
+    assert_match(/[ a-z]+/, @tester.street_address)
   end
 end

data/test/test_address_ru.rb

@@ -3,28 +3,34 @@
 require 'helper'
 
 class TestAddressRU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressRU,
+    :city, :province, :street_address, :street_name, :zip_code
+  )
 
   def setup
     @tester = FFaker::AddressRU
   end
 
   def test_city
-    assert_match /\A[a-zа-яё\-\s]+\z/i, @tester.city
+    assert_match(/\A[a-zа-яё\-\s]+\z/i, @tester.city)
   end
 
   def test_province
-    assert_match /\A[a-zа-яё\-\s]+\z/i, @tester.province
+    assert_match(/\A[a-zа-яё\-\s]+\z/i, @tester.province)
   end
 
   def test_zip_code
-    assert_match /\A\d{6}\z/, @tester.zip_code
+    assert_match(/\A\d{6}\z/, @tester.zip_code)
   end
 
   def test_street_name
-    assert_match /\A[a-zа-яё.\-\s]+\z/i, @tester.street_name
+    assert_match(/\A[a-zа-яё.\-\s]+\z/i, @tester.street_name)
   end
 
   def test_street_address
-    assert_match /\A[a-zа-яё.,\-\s\d]+\z/i, @tester.street_address
+    assert_match(/\A[a-zа-яё.,\-\s\d]+\z/i, @tester.street_address)
   end
 end

data/test/test_address_se.rb

@@ -3,12 +3,18 @@
 require 'helper'
 
 class TestAddressSE < Test::Unit::TestCase
+  include DeterministicHelper
 
   ALPHA = /\A[\p{Alpha}]+/
   DIGIT = /\d{1}/
 
+  assert_methods_are_deterministic(
+    FFaker::AddressSE,
+    :city, :random_country, :full_address, :zip_code
+  )
+
   def test_se_city
-    assert_match ALPHA, FFaker::AddressSE.city
+    assert_match(ALPHA, FFaker::AddressSE.city)
   end
 
   def test_se_zip_code
@@ -21,8 +27,8 @@ class TestAddressSE < Test::Unit::TestCase
 
   def test_se_full_address
     address = FFaker::AddressSE.full_address
-    assert_match ALPHA, address
-    assert_match DIGIT, address
+    assert_match(ALPHA, address)
+    assert_match(DIGIT, address)
     assert_match(/SVERIGE/, address)
     assert_match(/[\, a-z]/, address)
   end

data/test/test_address_sn.rb

@@ -3,9 +3,15 @@
 # => author: PapePathe github.com/PapePathe
 # => email: pathe.sene@gmail.com
 
-require "helper"
+require 'helper'
 
 class TestAddressSn < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressSN,
+    :region, :departement, :arrondissement
+  )
 
   def setup
     @subject = FFaker::AddressSN

data/test/test_address_ua.rb

@@ -3,6 +3,13 @@
 require 'helper'
 
 class TestAddressUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressUA,
+    :city, :country, :province, :zip_code, :street_name, :street_address,
+    :building_number, :appartment_number
+  )
 
   def setup
     @tester = FFaker::AddressUA
@@ -10,40 +17,40 @@ class TestAddressUA < Test::Unit::TestCase
   end
 
   def test_city
-    assert_match @multiple_words_name_regexp, @tester.city
+    assert_match(@multiple_words_name_regexp, @tester.city)
   end
 
   def test_country
-    assert_match @multiple_words_name_regexp, @tester.country
+    assert_match(@multiple_words_name_regexp, @tester.country)
   end
 
   def test_province
-    assert_match @multiple_words_name_regexp, @tester.province
+    assert_match(@multiple_words_name_regexp, @tester.province)
   end
 
   def test_zip_code
-    assert_match /\A\d{5}\z/, @tester.zip_code
+    assert_match(/\A\d{5}\z/, @tester.zip_code)
   end
 
   def test_street_name
-    assert_match /\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/, @tester.street_name
+    assert_match(/\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/, @tester.street_name)
   end
 
   def test_street_address
-    assert_match /\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+,\s\d{1,3}\z/, @tester.street_address
+    assert_match(/\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+,\s\d{1,3}\z/, @tester.street_address)
   end
 
   def test_street_address_with_secondary
-    assert_match \
+    assert_match( \
       /\Aвул\.\s[а-яА-ЯіїєґІЇЄҐ’\-\s]+,\s\d{1,3},\sкв\.\s\d{1,3}\z/,
-      @tester.street_address(true)
+      @tester.street_address(true))
   end
 
   def test_building_number
-    assert_match /\A\d{1,3}\z/, @tester.building_number
+    assert_match(/\A\d{1,3}\z/, @tester.building_number)
   end
 
   def test_appartment_number
-    assert_match /\A\d{1,3}\z/, @tester.appartment_number
+    assert_match(/\A\d{1,3}\z/, @tester.appartment_number)
   end
 end

data/test/test_address_uk.rb

@@ -3,15 +3,23 @@
 require 'helper'
 
 class TestAddressUK < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressUK,
+    :country, :county, :postcode
+  )
+
   def test_county
-    assert_match /[ a-z]/, FFaker::AddressUK.county
+    assert_match(/[ a-z]/, FFaker::AddressUK.county)
   end
 
   def test_country
-    assert_match /[ a-z]/, FFaker::AddressUK.country
+    assert_match(/[ a-z]/, FFaker::AddressUK.country)
   end
 
   def test_postcode
-    assert_match /^[A-Z]{2}\d \d[A-Z]{2}|[A-Z]{2}\d\d \d[A-Z]{2}$/, FFaker::AddressUK.postcode
+    assert_match(/^[A-Z]{2}\d \d[A-Z]{2}|[A-Z]{2}\d\d \d[A-Z]{2}$/,
+                 FFaker::AddressUK.postcode)
   end
 end

data/test/test_address_us.rb

@@ -3,28 +3,37 @@
 require 'helper'
 
 class TestAddressUSUS < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::AddressUS,
+    :continental_state_abbr, :continental_state,
+    :state_abbr, :state_and_territories_abbr, :state,
+    :zip_code
+  )
+
   def test_us_state
-    assert_match /[ a-z]/, FFaker::AddressUS.state
+    assert_match(/[ a-z]/, FFaker::AddressUS.state)
   end
 
   def test_us_state_abbr
-    assert_match /[A-Z]/, FFaker::AddressUS.state_abbr
+    assert_match(/[A-Z]/, FFaker::AddressUS.state_abbr)
   end
 
   def test_us_state_and_territories_abbr
-    assert_match /[A-Z]/, FFaker::AddressUS.state_and_territories_abbr
+    assert_match(/[A-Z]/, FFaker::AddressUS.state_and_territories_abbr)
   end
 
   def test_us_continental_state
-    assert_match /[ a-z]/, FFaker::AddressUS.continental_state
+    assert_match(/[ a-z]/, FFaker::AddressUS.continental_state)
   end
 
   def test_us_continental_state_abbr
-    assert_match /[A-Z]/, FFaker::AddressUS.continental_state_abbr
+    assert_match(/[A-Z]/, FFaker::AddressUS.continental_state_abbr)
   end
 
   def test_zip_code
-    assert_match /[0-9]/, FFaker::AddressUS.zip_code
+    assert_match(/[0-9]/, FFaker::AddressUS.zip_code)
   end
 
   def test_zip_code_frozen