ffaker 2.2.0 → 2.3.0

data/test/test_name_it.rb

@@ -4,6 +4,13 @@ require 'helper'
 
 # Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameIT < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameIT,
+    :prefix, :last_name, :first_name, :name
+  )
+
   def setup
     @tester = FFaker::NameIT
   end

data/test/test_name_ja.rb

@@ -15,6 +15,13 @@ class TestFakerNameJA < Test::Unit::TestCase
     end
   end
 
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameJA,
+    :last_name, :first_name, :last_first, :name
+  )
+
   def setup
     @tester = FFaker::NameJA
   end

data/test/test_name_kh.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class TestFakerNameKH < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameKH,
+    :last_name, :first_name, :nick_name, :name
+  )
+
+  def setup
+    @name_KH = FFaker::NameKH
+  end
+
+  def test_last_name
+    assert_include @name_KH::LAST_NAMES, @name_KH.last_name
+  end
+
+  def test_first_name
+    assert_include @name_KH::FIRST_NAMES, @name_KH.first_name
+  end
+
+  def test_nick_name
+    assert_include @name_KH::NICK_NAMES, @name_KH.nick_name
+  end
+
+  def test_name
+    last_name, first_name = @name_KH.name.split(' ')
+    assert_include @name_KH::FIRST_NAMES, first_name
+    assert_include @name_KH::LAST_NAMES, last_name
+  end
+end

data/test/test_name_kr.rb

@@ -3,6 +3,13 @@
 require 'helper'
 
 class TestFakerNameKR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameKR,
+    :name, :last_name, :name_with_space
+  )
+
   def setup
     @tester = FFaker::NameKR
   end

data/test/test_name_mx.rb

@@ -4,6 +4,15 @@ require 'helper'
 
 # Author: guapolo github.com/guapolo
 class TestFakerNameMX < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameMX,
+    :last_name, :first_name, :middle_name, :name, :male_prefix, :female_prefix,
+    :prefix, :male_name, :female_name, :full_name, :full_name_no_prefix,
+    :full_name_prefix
+  )
+
   def setup
     @tester = FFaker::NameMX
     @all_names = @tester::MALE_FIRST_NAMES + @tester::FEMALE_FIRST_NAMES

data/test/test_name_nb.rb

@@ -3,6 +3,14 @@
 require 'helper'
 
 class TestFakerNameNB < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameNB,
+    :last_name, :first_name_male, :first_name_female, :prefix, :first_name,
+    :name
+  )
+
   def setup
     @tester = FFaker::NameNB
   end

data/test/test_name_nl.rb

@@ -3,6 +3,10 @@
 require 'helper'
 
 class TestFakerNameNL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::NameNL, :name, :prefix, :suffix)
+
   def setup
     @tester = FFaker::NameNL
   end

data/test/test_name_ph.rb

@@ -3,8 +3,15 @@
 require 'helper'
 
 class TestFakerNamePH < Test::Unit::TestCase
+  include DeterministicHelper
+
   PH_REGEXP = /\A([\wñÑú-]+\.? ?){2,5}\z/
 
+  assert_methods_are_deterministic(
+    FFaker::NamePH,
+    :name, :last_name, :first_name, :prefix
+  )
+
   def setup
     @tester = FFaker::NamePH
   end

data/test/test_name_ru.rb

@@ -3,8 +3,15 @@
 require 'helper'
 
 class TestFakerNameRU < Test::Unit::TestCase
+  include DeterministicHelper
+
   RU_REGEX = /[А-Я][а-я]+/
 
+  assert_methods_are_deterministic(
+    FFaker::NameRU,
+    :name, :last_name, :first_name, :patronymic
+  )
+
   def setup
     @tester = FFaker::NameRU
   end
@@ -21,7 +28,7 @@ class TestFakerNameRU < Test::Unit::TestCase
   end
 
   def test_last_name
-    assert_match RU_REGEX, @tester.last_name
+    assert_match(RU_REGEX, @tester.last_name)
   end
 
   def test_male_last_name
@@ -29,7 +36,7 @@ class TestFakerNameRU < Test::Unit::TestCase
   end
 
   def test_first_name
-    assert_match RU_REGEX, @tester.first_name
+    assert_match(RU_REGEX, @tester.first_name)
   end
 
   def test_male_first_name
@@ -37,7 +44,7 @@ class TestFakerNameRU < Test::Unit::TestCase
   end
 
   def test_patronymic
-    assert_match RU_REGEX, @tester.patronymic
+    assert_match(RU_REGEX, @tester.patronymic)
   end
 
   def test_male_patronymic

data/test/test_name_se.rb

@@ -3,24 +3,32 @@
 require 'helper'
 
 class TestFakerNameSE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameSE,
+    :last_name, :first_name_male, :first_name_female,
+    :prefix, :first_name, :name
+  )
+
   def setup
     @tester = FFaker::NameSE
   end
 
   def test_last_name
-    assert_include @tester::LAST_NAMES, (@tester.last_name)
+    assert_include @tester::LAST_NAMES, @tester.last_name
   end
 
   def test_first_name_male
-    assert_include @tester::FIRST_NAMES_MALE, (@tester.first_name_male)
+    assert_include @tester::FIRST_NAMES_MALE, @tester.first_name_male
   end
 
   def test_first_name_female
-    assert_include @tester::FIRST_NAMES_FEMALE, (@tester.first_name_female)
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
   end
 
   def test_prefix
-    assert_include @tester::PREFIXES, (@tester.prefix)
+    assert_include @tester::PREFIXES, @tester.prefix
   end
 
   def test_first_name

data/test/test_name_sn.rb

@@ -4,6 +4,14 @@ require 'helper'
 
 # Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameSn < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameSN,
+    :last_name, :first_name_male, :first_name_female,
+    :prefix_male, :prefix_female, :name_male, :name_female, :name_sn
+  )
+
   def setup
     @tester = FFaker::NameSN
   end

data/test/test_name_th.rb

@@ -3,6 +3,13 @@
 require 'helper'
 
 class TestFakerNameTH < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameTH,
+    :last_name, :first_name, :nick_name, :name
+  )
+
   def setup
     @tester = FFaker::NameTH
   end

data/test/test_name_th_en.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestFakerNameTHEN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameTHEN,
+    :last_name, :first_name, :nick_name, :name
+  )
+
+  def setup
+    @tester = FFaker::NameTHEN
+  end
+
+  def test_last_name
+    assert_include @tester::LAST_NAMES, @tester.last_name
+  end
+
+  def test_first_name
+    assert_include @tester::FIRST_NAMES, @tester.first_name
+  end
+
+  def test_nick_name
+    assert_include @tester::NICK_NAMES, @tester.nick_name
+  end
+
+  def test_name
+    *first_names, last_name = @tester.name.split(' ')
+    first_name = first_names.join(' ')
+    assert_include @tester::FIRST_NAMES, first_name
+    assert_include @tester::LAST_NAMES, last_name
+  end
+end

data/test/test_name_ua.rb

@@ -3,6 +3,15 @@
 require 'helper'
 
 class TestNameUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameUA,
+    :first_name_female, :first_name_male, :first_name,
+    :last_name_female, :last_name_male, :last_name,
+    :middle_name_female, :middle_name_male, :name
+  )
+
   def setup
     @tester = FFaker::NameUA
 
@@ -11,48 +20,48 @@ class TestNameUA < Test::Unit::TestCase
   end
 
   def test_first_name_male
-    assert_include @tester::FIRST_NAMES_MALE, (@tester.first_name_male)
-    assert_match @single_word_name_regexp, @tester.first_name_male
+    assert_include @tester::FIRST_NAMES_MALE, @tester.first_name_male
+    assert_match(@single_word_name_regexp, @tester.first_name_male)
   end
 
   def test_first_name_female
-    assert_include @tester::FIRST_NAMES_FEMALE, (@tester.first_name_female)
-    assert_match @single_word_name_regexp, @tester.first_name_female
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
+    assert_match(@single_word_name_regexp, @tester.first_name_female)
   end
 
   def test_middle_name_male
-    assert_include @tester::MIDDLE_NAMES_MALE, (@tester.middle_name_male)
-    assert_match @single_word_name_regexp, @tester.middle_name_male
+    assert_include @tester::MIDDLE_NAMES_MALE, @tester.middle_name_male
+    assert_match(@single_word_name_regexp, @tester.middle_name_male)
   end
 
   def test_middle_name_female
-    assert_include @tester::MIDDLE_NAMES_FEMALE, (@tester.middle_name_female)
-    assert_match @single_word_name_regexp, @tester.middle_name_female
+    assert_include @tester::MIDDLE_NAMES_FEMALE, @tester.middle_name_female
+    assert_match(@single_word_name_regexp, @tester.middle_name_female)
   end
 
   def test_last_name_male
-    assert_include @tester::LAST_NAMES_MALE, (@tester.last_name_male)
-    assert_match @single_word_name_regexp, @tester.last_name_male
+    assert_include @tester::LAST_NAMES_MALE, @tester.last_name_male
+    assert_match(@single_word_name_regexp, @tester.last_name_male)
   end
 
   def test_last_name_female
-    assert_include @tester::LAST_NAMES_FEMALE, (@tester.last_name_female)
-    assert_match @single_word_name_regexp, @tester.last_name_female
+    assert_include @tester::LAST_NAMES_FEMALE, @tester.last_name_female
+    assert_match(@single_word_name_regexp, @tester.last_name_female)
   end
 
   def test_first_name
-    assert_include @tester::FIRST_NAMES, (@tester.first_name)
-    assert_match @single_word_name_regexp, @tester.first_name
+    assert_include @tester::FIRST_NAMES, @tester.first_name
+    assert_match(@single_word_name_regexp, @tester.first_name)
   end
 
   def test_last_name
-    assert_include @tester::LAST_NAMES, (@tester.last_name)
-    assert_match @single_word_name_regexp, @tester.last_name
+    assert_include @tester::LAST_NAMES, @tester.last_name
+    assert_match(@single_word_name_regexp, @tester.last_name)
   end
 
   def test_name
     8.times do
-      assert_match @multiple_words_name_regexp, @tester.name
+      assert_match(@multiple_words_name_regexp, @tester.name)
       assert_include [1, 2, 3], @tester.name.split(' ').count
     end
   end

data/test/test_name_vn.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestNameVN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NameVN,
+    :last_name, :first_name, :middle_name, :name, :last_first
+  )
+
+  def setup
+    @tester = FFaker::NameVN
+  end
+
+  def test_last_name
+    assert_include @tester::LAST_NAMES, @tester.last_name
+  end
+
+  def test_first_name
+    assert_include @tester::FIRST_NAMES, @tester.first_name
+  end
+
+  def test_middle_name
+    assert_include @tester::MIDDLE_NAMES, @tester.middle_name
+  end
+
+  def test_name
+    (middle_name, first_name, last_name) = @tester.name.split(' ')
+    assert_include @tester::FIRST_NAMES, first_name
+    assert_include @tester::MIDDLE_NAMES, middle_name
+    assert_include @tester::LAST_NAMES, last_name
+  end
+
+  def test_last_first
+    (last_name, middle_name, first_name) = @tester.last_first.split(' ')
+    assert_include @tester::FIRST_NAMES, first_name
+    assert_include @tester::MIDDLE_NAMES, middle_name
+    assert_include @tester::LAST_NAMES, last_name
+  end
+end

data/test/test_nato_alphabet.rb

@@ -3,6 +3,13 @@
 require 'helper'
 
 class TestNato < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::NatoAlphabet,
+    :code, :alphabetic_code, :numeric_code, :callsign
+  )
+
   def setup
     @tester = FFaker::NatoAlphabet
   end
@@ -20,12 +27,16 @@ class TestNato < Test::Unit::TestCase
   end
 
   def test_callsign
-    assert_match /[A-Z]+-[A-Z]+-[A-Z]+/, @tester.callsign
+    assert_match(/[A-Z]+-[A-Z]+-[A-Z]+/, @tester.callsign)
   end
 
   def test_codify
-    assert_match /[A-Z]+-[A-Z]+-[A-Z]+/, @tester.codify("?-?-?")
-    assert_match /[A-Z]+-[A-Z]+-[A-Z]+/, @tester.codify("?-#-?")
-    assert_match FFaker::NatoAlphabet::STOP_CODE, @tester.codify(".")
+    assert_match(/[A-Z]+-[A-Z]+-[A-Z]+/, @tester.codify('?-?-?'))
+    assert_match(/[A-Z]+-[A-Z]+-[A-Z]+/, @tester.codify('?-#-?'))
+    assert_match(FFaker::NatoAlphabet::STOP_CODE, @tester.codify('.'))
+
+    assert_deterministic { @tester.codify('?-?-?') }
+    assert_deterministic { @tester.codify('?-#-?') }
+    assert_deterministic { @tester.codify('.') }
   end
 end

data/test/test_phone_number.rb

@@ -3,25 +3,43 @@
 require 'helper'
 
 class TestPhoneNumer < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::PhoneNumber,
+    :phone_number, :area_code, :exchange_code, :short_phone_number, :phone_calling_code, :imei
+  )
+
   def test_phone_number
-    assert_match /\d{3}[. -]\d{3}/, FFaker::PhoneNumber.phone_number
+    assert_match(/\d{3}[. -]\d{3}/, FFaker::PhoneNumber.phone_number)
   end
 
   def test_area_code
-    assert_not_match /\A\d11\z/, FFaker::PhoneNumber.area_code.to_s
-    assert_match /\A\d{3}\z/, FFaker::PhoneNumber.area_code.to_s
+    assert_not_match(/\A\d11\z/, FFaker::PhoneNumber.area_code.to_s)
+    assert_match(/\A\d{3}\z/, FFaker::PhoneNumber.area_code.to_s)
+  end
+
+  def test_exchange_code
+    assert_not_match(/\A\d11\z/, FFaker::PhoneNumber.exchange_code.to_s)
+    assert_match(/\A\d{3}\z/, FFaker::PhoneNumber.exchange_code.to_s)
   end
 
   def test_short_phone_number
-    assert_match /\A\d{3}-\d{3}-\d{4}\z/, FFaker::PhoneNumber.short_phone_number
+    assert_match(/\A\d{3}-\d{3}-\d{4}\z/, FFaker::PhoneNumber.short_phone_number)
+  end
+
+  def test_phone_calling_code
+    assert_match(/\A\+\d+\z/, FFaker::PhoneNumber.phone_calling_code)
   end
 
   def test_imei
-    assert_match /\A\d{15}\z/, FFaker::PhoneNumber.imei
+    assert_match(/\A\d{15}\z/, FFaker::PhoneNumber.imei)
   end
 
   def test_imei_with_sn
     sn = rand(1_000_000)
-    assert_match /\A\d{8}#{sprintf('%06d', sn)}\d{1}\z/, FFaker::PhoneNumber.imei(sn)
+    assert_match(/\A\d{8}#{sprintf('%06d', sn)}\d{1}\z/,
+                 FFaker::PhoneNumber.imei(sn))
+    assert_deterministic { FFaker::PhoneNumber.imei(sn) }
   end
 end