ffakerTW 0.1.0

data/test/test_name_kh.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameKH < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameKH,
+    :last_name, :first_name, :nick_name, :name
+  )
+
+  def setup
+    @name_kh = FFakerTW::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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameKR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameKR,
+    :name, :last_name, :name_with_space
+  )
+
+  def setup
+    @tester = FFakerTW::NameKR
+  end
+
+  def test_name
+    assert_match(/\A[가-힣]{2,}\z/, @tester.name)
+  end
+
+  def test_last_first
+    assert_match(/\A[가-힣]{2,}\z/, @tester.last_first)
+  end
+
+  def test_name_with_space
+    assert_match(/\A[가-힣]{1,2} [가-힣]{2,}\z/, @tester.name_with_space)
+  end
+end

data/test/test_name_mx.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameMX < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::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 = FFakerTW::NameMX
+    @all_names = @tester::MALE_FIRST_NAMES + @tester::FEMALE_FIRST_NAMES
+  end
+
+  def test_last_name
+    assert_include @tester::LAST_NAMES, @tester.last_name
+  end
+
+  def test_first_name
+    assert_include @all_names, @tester.first_name
+  end
+
+  def test_middle_name
+    assert_include @all_names, @tester.middle_name
+  end
+
+  def test_name
+    assert_include @all_names, @tester.name
+  end
+
+  def test_prefix_male
+    assert_include @tester::MALE_PREFIXES, @tester.male_prefix
+  end
+
+  def test_prefix_female
+    assert_include @tester::FEMALE_PREFIXES, @tester.female_prefix
+  end
+
+  def test_prefix
+    assert_include @tester::PREFIXES, @tester.prefix
+  end
+
+  def test_male_name
+    parts = @tester.male_name.split(' ')
+    case parts.count
+    when 1
+      assert_include @tester::MALE_FIRST_NAMES, parts[0]
+    when 2
+      assert_include @tester::MALE_FIRST_NAMES, parts[0]
+      assert_include @tester::MALE_FIRST_NAMES, parts[1]
+    end
+  end
+
+  def test_female_name
+    parts = @tester.female_name.split(' ')
+    case parts.count
+    when 1
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[0]
+    when 2
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[0]
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[1]
+    end
+  end
+
+  def test_full_name_male
+    parts = @tester.full_name(:male).split(' ')
+    case parts.count
+    when 5
+      assert_include @tester::MALE_PREFIXES, parts[0]
+      assert_include @tester::MALE_FIRST_NAMES, parts[1]
+      # Middle name
+      assert_include @tester::MALE_FIRST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
+    when 4
+      prefix_or_first_name = @tester::MALE_PREFIXES.include?(parts[0]) ||
+                             @tester::MALE_FIRST_NAMES.include?(parts[0])
+      assert prefix_or_first_name
+      assert_include @tester::MALE_FIRST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+    when 3
+      assert_include @tester::MALE_FIRST_NAMES, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+    else
+      flunk 'Invalid Male Name'
+    end
+  end
+
+  def test_full_name_female
+    parts = @tester.full_name(:female).split(' ')
+    case parts.count
+    when 5
+      assert_include @tester::FEMALE_PREFIXES, parts[0]
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[1]
+      # Middle name
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
+    when 4
+      prefix_or_first_name = @tester::FEMALE_PREFIXES.include?(parts[0]) ||
+                             @tester::FEMALE_FIRST_NAMES.include?(parts[0])
+      assert prefix_or_first_name
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+    when 3
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+    else
+      flunk 'Invalid Female Name'
+    end
+  end
+
+  def test_full_name
+    parts = @tester.full_name.split(' ')
+    case parts.count
+    when 5
+      assert_include @tester::PREFIXES, parts[0]
+      assert_include @all_names, parts[1]
+      # Middle name
+      assert_include @all_names, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
+    when 4
+      prefix_or_first_name = @tester::PREFIXES.include?(parts[0]) ||
+                             @all_names.include?(parts[0])
+      assert prefix_or_first_name
+      assert_include @all_names, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+    when 3
+      assert_include @all_names, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+    else
+      flunk 'Invalid Name'
+    end
+  end
+
+  def test_full_name_no_prefix
+    parts = @tester.full_name_no_prefix.split(' ')
+    case parts.count
+    when 4
+      assert_include @all_names, parts[0]
+      assert_include @all_names, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+    when 3
+      assert_include @all_names, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+    else
+      flunk 'Invalid Name'
+    end
+  end
+
+  def test_full_name_prefix
+    parts = @tester.full_name_prefix.split(' ')
+    case parts.count
+    when 5
+      assert_include @tester::PREFIXES, parts[0]
+      assert_include @all_names, parts[1]
+      # Middle name
+      assert_include @all_names, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
+    when 4
+      prefix_or_first_name = @tester::PREFIXES.include?(parts[0]) ||
+                             @all_names.include?(parts[0])
+      assert prefix_or_first_name
+      assert_include @all_names, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+    when 3
+      assert_include @all_names, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+    else
+      flunk 'Invalid Name'
+    end
+  end
+end

data/test/test_name_nb.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameNB < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameNB,
+    :last_name, :first_name_male, :first_name_female, :prefix, :first_name,
+    :name
+  )
+
+  def setup
+    @tester = FFakerTW::NameNB
+  end
+
+  def test_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
+  end
+
+  def test_first_name_female
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
+  end
+
+  def test_prefix
+    assert_include @tester::PREFIXES, @tester.prefix
+  end
+
+  def test_first_name
+    parts = @tester.first_name.split(' ')
+    assert_include [1, 2], parts.count
+  end
+
+  def test_name
+    parts = @tester.name.split(' ')
+    assert_include [2, 3, 4], parts.count
+  end
+end

data/test/test_name_nl.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameNL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::NameNL, :name, :prefix, :suffix)
+
+  def setup
+    @tester = FFakerTW::NameNL
+  end
+
+  def test_name
+    assert_match(/(\w+\.? ?){2,3}/, @tester.name)
+  end
+
+  def test_prefix
+    assert_match(/[A-Z][a-z]+\.?/, @tester.prefix)
+  end
+
+  def test_suffix
+    assert_match(/[A-Z][a-z]*\.?/, @tester.suffix)
+  end
+end

data/test/test_name_ph.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNamePH < Test::Unit::TestCase
+  include DeterministicHelper
+
+  PH_REGEXP = /\A([\wñÑú-]+\.? ?){2,5}\z/.freeze
+
+  assert_methods_are_deterministic(
+    FFakerTW::NamePH,
+    :name, :last_name, :first_name, :prefix
+  )
+
+  def setup
+    @tester = FFakerTW::NamePH
+  end
+
+  def test_name
+    assert_match(PH_REGEXP, @tester.name)
+  end
+
+  def test_last_name
+    assert_match(PH_REGEXP, @tester.last_name)
+  end
+
+  def test_first_name
+    assert_match(PH_REGEXP, @tester.first_name)
+  end
+
+  def test_prefix
+    assert_match(/\A[A-Z][a-z]+\.?\z/, @tester.prefix)
+  end
+end

data/test/test_name_pl.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNamePL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NamePL,
+    :name, :name_with_prefix, :last_name, :first_name, :female_name_with_prefix,
+    :male_name_with_prefix, :female_full_name, :male_full_name, :female_first_name,
+    :female_last_name, :male_first_name, :male_last_name, :prefix,
+    :female_prefix, :male_prefix, :academic_degree_prefix
+  )
+
+  def setup
+    @tester = FFakerTW::NamePL
+  end
+
+  def test_name
+    assert_match(/(\w+\.? ?){2}/, @tester.name)
+  end
+
+  def name_with_prefix
+    prefix, first_name, last_name = @tester.name_with_prefix.split
+    assert_include(@tester::PREFIXES, prefix)
+    refute_empty(first_name)
+    refute_empty(last_name)
+  end
+
+  def test_female_name_with_prefix
+    prefix, first_name, last_name = @tester.female_name_with_prefix.split
+    assert_include(@tester::FEMALE_PREFIXES, prefix)
+    assert_include(@tester::FEMALE_FIRST_NAMES, first_name)
+    assert_include(@tester::FEMALE_LAST_NAMES, last_name)
+  end
+
+  def test_male_name_with_prefix
+    prefix, first_name, last_name = @tester.male_name_with_prefix.split
+    assert_include(@tester::MALE_PREFIXES, prefix)
+    assert_include(@tester::MALE_FIRST_NAMES, first_name)
+    assert_include(@tester::MALE_LAST_NAMES, last_name)
+  end
+
+  def test_female_full_name
+    first_name, last_name = @tester.female_full_name.split
+    assert_include(@tester::FEMALE_FIRST_NAMES, first_name)
+    assert_include(@tester::FEMALE_LAST_NAMES, last_name)
+  end
+
+  def test_male_full_name
+    first_name, last_name = @tester.male_full_name.split
+    assert_include(@tester::MALE_FIRST_NAMES, first_name)
+    assert_include(@tester::MALE_LAST_NAMES, last_name)
+  end
+
+  def test_first_name
+    first_names = @tester::FEMALE_FIRST_NAMES + @tester::MALE_FIRST_NAMES
+    assert_include(first_names, @tester.first_name)
+  end
+
+  def test_first_name_with_argument
+    assert_include(@tester::FEMALE_FIRST_NAMES, @tester.first_name(:female))
+  end
+
+  def test_female_first_name
+    assert_include(@tester::FEMALE_FIRST_NAMES, @tester.female_first_name)
+  end
+
+  def test_male_first_name
+    assert_include(@tester::MALE_FIRST_NAMES, @tester.male_first_name)
+  end
+
+  def test_last_name
+    last_names = @tester::FEMALE_LAST_NAMES + @tester::MALE_LAST_NAMES
+    assert_include(last_names, @tester.last_name)
+  end
+
+  def test_last_name_with_argument
+    assert_include(@tester::MALE_LAST_NAMES, @tester.last_name(:male))
+  end
+
+  def test_female_last_name
+    assert_include(@tester::FEMALE_LAST_NAMES, @tester.female_last_name)
+  end
+
+  def test_male_last_name
+    assert_include(@tester::MALE_LAST_NAMES, @tester.male_last_name)
+  end
+
+  def test_prefix
+    assert_include(@tester::PREFIXES, @tester.prefix)
+  end
+
+  def test_female_prefix
+    assert_include(@tester::FEMALE_PREFIXES, @tester.female_prefix)
+  end
+
+  def test_male_prefix
+    assert_include(@tester::MALE_PREFIXES, @tester.male_prefix)
+  end
+
+  def test_academic_degree_prefix
+    assert_include(@tester::ACADEMIC_DEGREE_PREFIXES, @tester.academic_degree_prefix)
+  end
+
+  def test_name_for_gender_raises_argument_error
+    error = assert_raises(ArgumentError) { @tester.send(:name_for_gender, :name, :vodka) }
+    assert_match("Gender must be one of: #{@tester::GENDERS}", error.message)
+  end
+end

data/test/test_name_ru.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestNameRU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  RU_REGEX = /\A[а-яА-Я]{2,}\z/.freeze
+  RU_REGEX_MULTIPLE_WORDS = /\A[а-яА-Я\s]+\z/.freeze
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameRU,
+    :name, :first_name, :last_name, :female_name, :male_name,
+    :first_name_female, :first_name_male, :middle_name_female,
+    :middle_name_male, :last_name_female, :last_name_male
+  )
+
+  def setup
+    @tester = FFakerTW::NameRU
+  end
+
+  def test_name
+    assert_match(RU_REGEX_MULTIPLE_WORDS, @tester.name)
+    assert_include [1, 2, 3], @tester.name.split(' ').count
+  end
+
+  def test_first_name
+    assert_include @tester::FIRST_NAMES, @tester.first_name
+    assert_match(RU_REGEX, @tester.first_name)
+  end
+
+  def test_last_name
+    assert_include @tester::LAST_NAMES, @tester.last_name
+    assert_match(RU_REGEX, @tester.last_name)
+  end
+
+  def test_female_name
+    assert_match(RU_REGEX_MULTIPLE_WORDS, @tester.female_name)
+    assert_include [1, 2, 3], @tester.female_name.split(' ').count
+  end
+
+  def test_male_name
+    assert_match(RU_REGEX_MULTIPLE_WORDS, @tester.male_name)
+    assert_include [1, 2, 3], @tester.male_name.split(' ').count
+  end
+
+  def test_first_name_female
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
+    assert_match(RU_REGEX, @tester.first_name_female)
+  end
+
+  def test_first_name_male
+    assert_include @tester::FIRST_NAMES_MALE, @tester.first_name_male
+    assert_match(RU_REGEX, @tester.first_name_male)
+  end
+
+  def test_middle_name_female
+    assert_include @tester::MIDDLE_NAMES_FEMALE, @tester.middle_name_female
+    assert_match(RU_REGEX, @tester.middle_name_female)
+  end
+
+  def test_middle_name_male
+    assert_include @tester::MIDDLE_NAMES_MALE, @tester.middle_name_male
+    assert_match(RU_REGEX, @tester.middle_name_male)
+  end
+
+  def test_last_name_female
+    assert_include @tester::LAST_NAMES_FEMALE, @tester.last_name_female
+    assert_match(RU_REGEX, @tester.last_name_female)
+  end
+
+  def test_last_name_male
+    assert_include @tester::LAST_NAMES_MALE, @tester.last_name_male
+    assert_match(RU_REGEX, @tester.last_name_male)
+  end
+end

data/test/test_name_se.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameSE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameSE,
+    :last_name, :first_name_male, :first_name_female,
+    :prefix, :first_name, :name
+  )
+
+  def setup
+    @tester = FFakerTW::NameSE
+  end
+
+  def test_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
+  end
+
+  def test_first_name_female
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
+  end
+
+  def test_prefix
+    assert_include @tester::PREFIXES, @tester.prefix
+  end
+
+  def test_first_name
+    parts = @tester.first_name.split(' ')
+    assert_include [1, 2], parts.count
+  end
+
+  def test_name
+    parts = @tester.name.split(' ')
+    assert_include [2, 3, 4], parts.count
+  end
+end

data/test/test_name_sn.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameSn < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameSN,
+    :last_name, :first_name_male, :first_name_female,
+    :prefix_male, :prefix_female, :name_male, :name_female, :name_sn
+  )
+
+  def setup
+    @tester = FFakerTW::NameSN
+  end
+
+  def test_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
+  end
+
+  def test_first_name_female
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
+  end
+
+  def test_prefix_male
+    assert_include @tester::PREFIX_MALE, @tester.prefix_male
+  end
+
+  def test_prefix_female
+    assert_include @tester::PREFIX_FEMALE, @tester.prefix_female
+  end
+
+  def test_name_male
+    parts = @tester.name_male.split(' ')
+    assert_include [2, 3], parts.count
+
+    case parts.count
+    when 3
+      male_prefix, male_first_name, last_name = parts
+
+      assert_include @tester::PREFIX_MALE, male_prefix
+      assert_include @tester::FIRST_NAMES_MALE, male_first_name
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      male_first_name, last_name = parts
+
+      assert_include @tester::FIRST_NAMES_MALE, male_first_name
+      assert_include @tester::LAST_NAMES, last_name
+    end
+  end
+
+  def test_name_female
+    parts = @tester.name_female.split(' ')
+    assert_include [2, 3], parts.count
+
+    case parts.count
+    when 3
+      female_prefix, female_first_name, last_name = parts
+
+      assert_include @tester::PREFIX_FEMALE, female_prefix
+      assert_include @tester::FIRST_NAMES_FEMALE, female_first_name
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      female_first_name, last_name = parts
+
+      assert_include @tester::FIRST_NAMES_FEMALE, female_first_name
+      assert_include @tester::LAST_NAMES, last_name
+    end
+  end
+
+  def test_senegalese_name
+    parts = @tester.name_sn.split(' ')
+    assert_include [2, 3], parts.count
+
+    case parts.count
+    when 3
+      prefix, first_name, last_name = parts
+      assert_include(@tester::PREFIX_FEMALE + @tester::PREFIX_MALE, prefix)
+      assert_include(@tester::FIRST_NAMES_FEMALE + @tester::FIRST_NAMES_MALE, first_name)
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      first_name, last_name = parts
+      assert_include(@tester::FIRST_NAMES_FEMALE + @tester::FIRST_NAMES_MALE, first_name)
+      assert_include @tester::LAST_NAMES, last_name
+    end
+  end
+end