ffakerTW 0.1.0 → 1.2.0

data/test/test_name_tw.rb

@@ -1,28 +0,0 @@
-# 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

@@ -1,68 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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_phone_number_au.rb

@@ -1,65 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-# 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

data/test/test_phone_number_fr.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestPhoneNumberFR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::PhoneNumberFR,
-    :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::PhoneNumberFR
-  end
-
-  def test_phone_number
-    10.times do
-      assert_match(/^0[1-9](\s?\d{2}){4}$/, @tester.phone_number)
-    end
-  end
-
-  def test_home_work_phone_number
-    assert_match(/^0([1-5]|[8-9])(\s?\d{2}){4}$/,
-                 @tester.home_work_phone_number)
-  end
-
-  def test_mobile_phone_number
-    assert_match(/^0([6-7])(\s?\d{2}){4}$/,
-                 @tester.mobile_phone_number)
-  end
-
-  def test_international_phone_number
-    10.times do
-      assert_match(/^(\+|00)33\s?([1-9])(\s?\d{2}){4}$/,
-                   @tester.international_phone_number)
-    end
-  end
-
-  def test_international_mobile_phone_number
-    assert_match(/^(\+|00)33\s?([6-7])(\s?\d{2}){4}$/,
-                 @tester.international_mobile_phone_number)
-  end
-
-  def test_international_home_work_phone_number
-    assert_match(/^(\+|00)33\s?([1-5]|[8-9])(\s?\d{2}){4}$/,
-                 @tester.international_home_work_phone_number)
-  end
-
-  def test_country_code
-    10.times do
-      assert_match(/(\+|00)33/, @tester.country_code)
-    end
-  end
-end

data/test/test_phone_number_id.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestPhoneNumberID < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::PhoneNumberID,
-    :mobile_phone_number,
-    :home_phone_number,
-    :phone_number
-  )
-
-  def setup
-    @tester = FFakerTW::PhoneNumberID
-  end
-
-  def test_mobile_phone_number
-    prefixes = FFakerTW::PhoneNumberID::MOBILE_PHONE_PREFIXES
-    regex = /\A(?:#{prefixes.join('|')})-\d{8}\z/
-    assert_match regex, FFakerTW::PhoneNumberID.mobile_phone_number
-  end
-
-  def test_home_phone_number
-    prefixes = FFakerTW::PhoneNumberID::HOME_PHONE_PREFIXES
-    regex = /\A(#{prefixes.join('|')})-(\d{7,8})\z/
-    assert_match regex, FFakerTW::PhoneNumberID.home_phone_number
-  end
-
-  def test_phone_number
-    mobile_prefixes = FFakerTW::PhoneNumberID::MOBILE_PHONE_PREFIXES
-    home_prefixes = FFakerTW::PhoneNumberID::HOME_PHONE_PREFIXES
-    regex = /\A(#{mobile_prefixes.join('|')}|#{home_prefixes.join('|')})-(\d{7,8})\z/
-    assert_match regex, FFakerTW::PhoneNumberID.phone_number
-  end
-
-  def test_international_mobile_phone_number
-    prefixes = FFakerTW::PhoneNumberID::MOBILE_PHONE_PREFIXES.map { |x| x.sub('0', '') }
-    regex = /\A\+62(#{prefixes.join('|')})-(\d{8})\z/
-    assert_match regex, FFakerTW::PhoneNumberID.international_mobile_phone_number
-  end
-
-  def test_international_home_phone_number
-    prefixes = FFakerTW::PhoneNumberID::HOME_PHONE_PREFIXES.map { |x| x.sub('0', '') }
-    regex = /\A\+62(#{prefixes.join('|')})-(\d{7,8})\z/
-    assert_match regex, FFakerTW::PhoneNumberID.international_home_phone_number
-  end
-
-  def test_international_phone_number
-    mobile_prefixes = FFakerTW::PhoneNumberID::MOBILE_PHONE_PREFIXES.map { |x| x.sub('0', '') }
-    home_prefixes = FFakerTW::PhoneNumberID::HOME_PHONE_PREFIXES.map { |x| x.sub('0', '') }
-    regex = /\A\+62(#{mobile_prefixes.join('|')}|#{home_prefixes.join('|')})-(\d{7,8})\z/
-
-    assert_match regex, FFakerTW::PhoneNumberID.international_phone_number
-  end
-end

data/test/test_phone_number_it.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestPhoneNumberIT < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::PhoneNumberIT,
-    :phone_number, :home_phone_number, :mobile_phone_number
-  )
-end

data/test/test_phone_number_ja.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestPhoneNumberJA < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::PhoneNumberJA,
-    :phone_number, :home_phone_number, :mobile_phone_number,
-    :international_mobile_phone_number, :international_home_phone_number, :international_phone_number,
-    :mobile_prefix, :home_phone_prefix
-  )
-
-  def setup
-    @tester = FFakerTW::PhoneNumberJA
-  end
-
-  def test_phone_number
-    assert_match(/\A0\d{1,4} \d{1,4} \d{4}\z/, @tester.phone_number)
-    assert_include([12, 13], @tester.phone_number.length)
-  end
-
-  def test_home_phone_number
-    assert_match(/\A0\d{1,4} \d{1,4} \d{4}\z/, @tester.home_phone_number)
-    assert_equal(@tester.home_phone_number.length, 12)
-  end
-
-  def test_mobile_phone_number
-    assert_match(/\A0(90|80|70) \d{4} \d{4}\z/, @tester.mobile_phone_number)
-    assert_equal(@tester.mobile_phone_number.length, 13)
-  end
-
-  def test_international_phone_number
-    assert_match(/\A\+81 \d{1,4} \d{1,4} \d{4}\z/, @tester.international_phone_number)
-    assert_include([15, 16], @tester.international_phone_number.length)
-  end
-
-  def test_international_home_phone_number
-    assert_match(/\A\+81 \d{1,4} \d{1,4} \d{4}\z/, @tester.international_home_phone_number)
-    assert_equal(@tester.international_home_phone_number.length, 15)
-  end
-
-  def test_international_mobile_phone_number
-    assert_match(/\A\+81 (90|80|70) \d{4} \d{4}\z/, @tester.international_mobile_phone_number)
-    assert_equal(@tester.international_mobile_phone_number.length, 16)
-  end
-
-  def test_mobile_prefix
-    assert_include(@tester::MOBILE_PHONE_PREFIXES, @tester.mobile_prefix)
-  end
-
-  def test_home_phone_prefix
-    disit = rand(1..4)
-    assert_include(
-      @tester::ONE_DISIT_AREA_CODES +
-        @tester::TWO_DISIT_AREA_CODES +
-        @tester::THREE_DISIT_AREA_CODES +
-        @tester::FOUR_DISIT_AREA_CODES,
-      @tester.home_phone_prefix(disit)
-    )
-  end
-end