ffakerTW 0.1.0 → 1.1.0

data/test/test_name_mx.rb

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

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

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

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

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

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

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

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

data/test/test_name_th.rb

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

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