ffakerTW 0.1.0

data/test/test_name_th.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameTH < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameTH,
+    :last_name, :first_name, :nick_name, :name
+  )
+
+  def setup
+    @tester = FFakerTW::NameTH
+  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_name, last_name = @tester.name.split(' ')
+    assert_include @tester::FIRST_NAMES, first_name
+    assert_include @tester::LAST_NAMES, last_name
+  end
+end

data/test/test_name_th_en.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameTHEN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameTHEN,
+    :last_name, :first_name, :nick_name, :name
+  )
+
+  def setup
+    @tester = FFakerTW::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_tw.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameTW < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameTW,
+    :last_name, :first_name, :name
+  )
+
+  def setup
+    @tester = FFakerTW::NameTW
+  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_name
+    assert_match(/\A.{2,}\z/, @tester.name)
+  end
+end

data/test/test_name_ua.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestNameUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::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 = FFakerTW::NameUA
+
+    @single_word_name_regexp    = /\A[а-яА-ЯіїєґІЇЄҐ’\-]+\z/.freeze
+    @multiple_words_name_regexp = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/.freeze
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  end
+
+  def test_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)
+  end
+
+  def test_name
+    8.times do
+      assert_match(@multiple_words_name_regexp, @tester.name)
+      assert_include [1, 2, 3], @tester.name.split(' ').count
+    end
+  end
+end

data/test/test_name_vn.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestNameVN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameVN,
+    :last_name, :first_name, :middle_name, :name, :last_first
+  )
+
+  def setup
+    @tester = FFakerTW::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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestNato < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NatoAlphabet,
+    :code, :alphabetic_code, :numeric_code, :callsign
+  )
+
+  def setup
+    @tester = FFakerTW::NatoAlphabet
+  end
+
+  def test_code
+    assert FFakerTW::NatoAlphabet::CODES.include?(@tester.code)
+  end
+
+  def test_letter_code
+    assert FFakerTW::NatoAlphabet::ALPHABET_CODES.include?(@tester.alphabetic_code)
+  end
+
+  def test_numerify_code
+    assert FFakerTW::NatoAlphabet::NUMERIC_CODES.include?(@tester.numeric_code)
+  end
+
+  def test_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(FFakerTW::NatoAlphabet::STOP_CODE, @tester.codify('.'))
+
+    assert_deterministic { @tester.codify('?-?-?') }
+    assert_deterministic { @tester.codify('?-#-?') }
+    assert_deterministic { @tester.codify('.') }
+  end
+end

data/test/test_number.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestNumber < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Number, :number, :decimal)
+
+  def setup
+    @tester = FFakerTW::Number
+  end
+
+  def test_number
+    assert @tester.number.is_a?(Integer)
+    assert @tester.number.digits.count == 1
+    assert @tester.number(digits: 3).digits.count == 3
+    assert_match(/\d/, @tester.number.to_s)
+    assert_match(/\d{3}/, @tester.number(digits: 3).to_s)
+  end
+
+  def test_number_when_invalid_argument
+    assert_raise(ArgumentError.new('Digits cannot be less than 1')) { @tester.number(digits: 0) }
+  end
+
+  def test_decimal
+    assert @tester.decimal.is_a?(Float)
+
+    whole_digits = rand(2..5)
+    fractional_digits = rand(2..5)
+    decimal = @tester.decimal(whole_digits: whole_digits, fractional_digits: fractional_digits)
+    assert decimal.to_s.split('.').first.size == whole_digits
+    assert decimal.to_s.split('.').last.size == fractional_digits
+  end
+
+  def test_decimal_when_invalid_argument
+    assert_raise(ArgumentError.new('Digits cannot be less than 1')) do
+      @tester.decimal(whole_digits: 0)
+    end
+
+    assert_raise(ArgumentError.new('Digits cannot be less than 1')) do
+      @tester.decimal(fractional_digits: 0)
+    end
+  end
+end

data/test/test_phone_number.rb

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

data/test/test_phone_number_au.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberAU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::PhoneNumberAU,
+    :mobile_phone_prefix, :home_work_phone_prefix, :phone_prefix,
+    :mobile_phone_number, :home_work_phone_number, :phone_number,
+    :international_mobile_phone_number,
+    :international_home_work_phone_number,
+    :international_phone_number
+  )
+
+  def setup
+    @tester = FFakerTW::PhoneNumberAU
+  end
+
+  def test_mobile_phone_prefix
+    assert_include(FFakerTW::PhoneNumberAU::MOBILE_OPERATORS_PREFIX,
+                   @tester.mobile_phone_prefix)
+  end
+
+  def test_home_work_phone_prefix
+    assert_include(FFakerTW::PhoneNumberAU::HOME_WORK_OPERATORS_PREFIX,
+                   @tester.home_work_phone_prefix)
+  end
+
+  def test_phone_prefix
+    assert_include(FFakerTW::PhoneNumberAU::OPERATORS_PREFIX,
+                   @tester.phone_prefix)
+  end
+
+  def test_mobile_phone_number
+    assert_match(/0[45]\d{2} \d{3} \d{3}/,
+                 FFakerTW::PhoneNumberAU.mobile_phone_number)
+  end
+
+  def test_home_work_phone_number
+    assert_match(/\(\d{2}\) \d{4} \d{4}/,
+                 FFakerTW::PhoneNumberAU.home_work_phone_number)
+  end
+
+  def test_phone_number
+    assert_match(/(?:0[45]\d{1,2} \d{3} \d{3}|\(\d{2}\) \d{4} \d{4})/,
+                 FFakerTW::PhoneNumberAU.phone_number)
+  end
+
+  def test_international_mobile_phone_number
+    assert_match(/\+61 \d{1,2} \d{4} \d{4}/,
+                 FFakerTW::PhoneNumberAU.international_mobile_phone_number)
+  end
+
+  def test_international_home_work_phone_number
+    assert_match(/\+61 \d{1,2} \d{4} \d{4}/,
+                 FFakerTW::PhoneNumberAU.international_home_work_phone_number)
+  end
+
+  def test_international_phone_number
+    assert_match(/\+61 \d{1,2} \d{4} \d{4}/,
+                 FFakerTW::PhoneNumberAU.international_phone_number)
+  end
+end

data/test/test_phone_number_br.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::PhoneNumberBR,
+    :phone_number, :home_work_phone_number, :mobile_phone_number,
+    :international_phone_number, :international_mobile_phone_number,
+    :international_home_work_phone_number, :country_code
+  )
+
+  def setup
+    @tester = FFakerTW::PhoneNumberBR
+  end
+
+  def test_area_codes
+    assert(!@tester::AREA_CODE.empty?)
+    assert(@tester::AREA_CODE.sort.uniq == @tester::AREA_CODE)
+    @tester::AREA_CODE.each do |area_code|
+      assert_match(/\A[1-9]\d\z/, area_code)
+    end
+  end
+
+  def test_phone_number
+    10.times do
+      assert_match(/\A[1-9]\d\s?9?\d{4}-?\d{4}\z/, @tester.phone_number)
+    end
+  end
+
+  def test_home_work_phone_number
+    assert_match(/\A[1-9]\d\s?[2-5]\d{3}-?\d{4}\z/,
+                 @tester.home_work_phone_number)
+  end
+
+  def test_mobile_phone_number
+    assert_match(/\A[1-9]\d\s?9[6-9]\d{3}-?\d{4}\z/,
+                 @tester.mobile_phone_number)
+  end
+
+  def test_international_phone_number
+    10.times do
+      assert_match(/\A\+55\s?[1-9]\d\s?9?\d{4}-?\d{4}\z/,
+                   @tester.international_phone_number)
+    end
+  end
+
+  def test_international_mobile_phone_number
+    assert_match(/\A\+55\s?[1-9]\d\s?9[6-9]\d{3}-?\d{4}\z/,
+                 @tester.international_mobile_phone_number)
+  end
+
+  def test_international_home_work_phone_number
+    assert_match(/\A\+55\s?[1-9]\d\s?[2-5]\d{3}-?\d{4}\z/,
+                 @tester.international_home_work_phone_number)
+  end
+
+  def test_country_code
+    assert_match('+55', @tester.country_code)
+  end
+end

data/test/test_phone_number_cu.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberCU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::PhoneNumberCU,
+    :mobile_phone_prefix, :home_work_phone_prefix, :phone_prefix,
+    :mobile_phone_number, :home_work_phone_number, :general_phone_number,
+    :international_mobile_phone_number, :international_home_work_phone_number,
+    :international_phone_number,
+    :e164_mobile_phone_number, :e164_home_work_phone_number, :e164_phone_number
+  )
+
+  def setup
+    @tester = FFakerTW::PhoneNumberCU
+  end
+
+  def test_mobile_phone_prefix
+    assert FFakerTW::PhoneNumberCU::MOBILE_OPERATORS_PREFIX.include?(
+      @tester.mobile_phone_prefix
+    )
+  end
+
+  def test_home_work_phone_prefix
+    assert FFakerTW::PhoneNumberCU::HOME_WORK_OPERATORS_PREFIX.include?(
+      @tester.home_work_phone_prefix
+    )
+  end
+
+  def test_phone_prefix
+    10.times do
+      assert FFakerTW::PhoneNumberCU::OPERATORS_PREFIX.include?(
+        @tester.phone_prefix
+      )
+    end
+  end
+
+  def test_mobile_phone_number
+    assert_match(/05 \d{3} \d{4}/,
+                 FFakerTW::PhoneNumberCU.mobile_phone_number)
+  end
+
+  def test_home_work_phone_number
+    assert_match(/\(0(7\) \d{3}|\d{2}\) \d{2}) \d{4}/,
+                 FFakerTW::PhoneNumberCU.home_work_phone_number)
+  end
+
+  def test_general_phone_number
+    10.times do
+      assert_match(/((05|\(07\)) \d{3}|\(0\d{2}\) \d{2}) \d{4}/,
+                   FFakerTW::PhoneNumberCU.general_phone_number)
+    end
+  end
+
+  def test_international_mobile_phone_number
+    assert_match(/(00|\+)535 \d{3} \d{4}/,
+                 FFakerTW::PhoneNumberCU.international_mobile_phone_number)
+  end
+
+  def test_international_home_work_phone_number
+    assert_match(/(00|\+)53(7 \d{3}|\d{2} \d{2}) \d{4}/,
+                 FFakerTW::PhoneNumberCU.international_home_work_phone_number)
+  end
+
+  def test_international_phone_number
+    10.times do
+      assert_match(/(00|\+)53((5|7) \d{3}|\d{2} \d{2}) \d{4}/,
+                   FFakerTW::PhoneNumberCU.international_phone_number)
+    end
+  end
+
+  # E.164 format tests
+  #
+  def test_e164_mobile_phone_number
+    assert_match(/535\d{7}/,
+                 FFakerTW::PhoneNumberCU.e164_mobile_phone_number)
+  end
+
+  def test_e164_home_work_phone_number
+    assert_match(/53(7\d{7}|\d{2}\d{6})/,
+                 FFakerTW::PhoneNumberCU.e164_home_work_phone_number)
+  end
+
+  def test_e164_phone_number
+    10.times do
+      assert_match(/53((5|7)\d{7}|\d{2}\d{6})/,
+                   FFakerTW::PhoneNumberCU.e164_phone_number)
+    end
+  end
+end

data/test/test_phone_number_da.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberDA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::PhoneNumberDA,
+    :home_work_phone_number, :mobile_phone_number, :phone_number, :country_code,
+    :international_mobile_phone_number,
+    :international_home_work_phone_number,
+    :international_phone_number
+  )
+
+  def setup
+    @tester = FFakerTW::PhoneNumberDA
+  end
+
+  def test_home_work_phone_number
+    assert_match(/\A\d{8}\z/, @tester.home_work_phone_number)
+  end
+
+  def test_mobile_phone_number
+    assert_match(/\A\d{8}\z/, @tester.mobile_phone_number)
+  end
+
+  def test_phone_number
+    assert_match(/\A\d{8}\z/, @tester.phone_number)
+  end
+
+  def test_country_code
+    assert_equal '+45', @tester.country_code
+  end
+
+  def test_international_mobile_phone_number
+    assert_match(/\A\+45 \d{8}\z/, @tester.international_mobile_phone_number)
+  end
+
+  def test_international_home_work_phone_number
+    assert_match(/\A\+45 \d{8}\z/, @tester.international_home_work_phone_number)
+  end
+
+  def test_international_phone_number
+    assert_match(/\A\+45 \d{8}\z/, @tester.international_phone_number)
+  end
+end

data/test/test_phone_number_de.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberDE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::PhoneNumberDE,
+    :mobile_prefix, :region_prefix, :mobile_phone_number, :home_work_phone_number,
+    :country_code, :international_mobile_phone_number, :international_home_work_phone_number
+  )
+
+  def setup
+    @tester = FFakerTW::PhoneNumberDE
+  end
+
+  def test_mobile_prefix
+    assert_match(/^01[567]{1}[0-9]{1}$/, FFakerTW::PhoneNumberDE.mobile_prefix)
+  end
+
+  def test_mobile_prefix_without_leading_zero
+    assert_match(/^1[567]{1}[0-9]{1}$/, FFakerTW::PhoneNumberDE.mobile_prefix(false))
+  end
+
+  def test_region_prefix
+    assert_match(/^0[2-9]{1}[0-9]{1,3}$/, FFakerTW::PhoneNumberDE.region_prefix)
+  end
+
+  def test_region_prefix_without_leading_zero
+    assert_match(/^[2-9]{1}[0-9]{1,3}$/, FFakerTW::PhoneNumberDE.region_prefix(false))
+  end
+
+  def test_mobile_phone_number
+    assert_match(/^01[567]{1}[0-9]{1} [0-9]{7}$/, FFakerTW::PhoneNumberDE.mobile_phone_number)
+  end
+
+  def test_home_work_phone_number
+    assert_match(/^0[2-9]{1}[0-9]{1,3} [0-9]{7}$/, FFakerTW::PhoneNumberDE.home_work_phone_number)
+  end
+
+  def test_country_code
+    assert_match('+49', FFakerTW::PhoneNumberDE.country_code)
+  end
+
+  def test_international_mobile_phone_number
+    assert_match(/^\+49 1[567]{1}[0-9]{1} [0-9]{7}$/, FFakerTW::PhoneNumberDE.international_mobile_phone_number)
+  end
+
+  def test_international_home_work_phone_number
+    assert_match(/^\+49 [2-9]{1}[0-9]{1,3} [0-9]{7}$/, FFakerTW::PhoneNumberDE.international_home_work_phone_number)
+  end
+end