ffakerTW 0.1.0 → 1.1.0

data/test/test_name_cs.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameCS < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameCS,
-    :name, :last_name, :first_name, :prefix, :suffix
-  )
-
-  def setup
-    @tester = FFakerTW::NameCS
-  end
-
-  def test_name
-    @words = @tester.name.split
-    assert_include([2, 3, 4], @words.size)
-  end
-
-  def test_name_sex
-    @words = @tester.name.split
-    @words = @words[1..2] if @words.size > 2
-    assert same_sex?(@words)
-  end
-
-  def test_male_last_name
-    assert_include(@tester::LAST_NAMES[:male], @tester.last_name(:male))
-  end
-
-  def test_male_first_name
-    assert_include(@tester::FIRST_NAMES[:male], @tester.first_name(:male))
-  end
-
-  def test_prefix
-    assert_include(@tester::PREFIXES, @tester.prefix)
-  end
-
-  def test_suffix
-    assert_include(@tester::SUFFIXES, @tester.suffix)
-  end
-
-  def test_with_same_sex
-    names = []
-    @tester.with_same_sex do
-      names << @tester.last_name
-      names << @tester.first_name
-    end
-    assert same_sex?(names)
-  end
-
-  def test_with_same_sex_for_male
-    names = []
-    @tester.with_same_sex(:male) do
-      names << @tester.last_name
-      names << @tester.first_name
-    end
-    assert same_sex?(names, :male)
-  end
-
-  private
-
-  def same_sex?(words, sex = :any)
-    (sex == :any ? %i[male female] : [sex]).any? do |s|
-      words.all? do |word|
-        [@tester::LAST_NAMES, @tester::FIRST_NAMES].any? do |names|
-          names[s].include?(word)
-        end
-      end
-    end
-  end
-end

data/test/test_name_da.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameDA < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameDA,
-    :any_name, :male_name, :female_name, :last_name, :prefix
-  )
-
-  RU_REGEX = /[А-Я][а-я]+/.freeze
-
-  def setup
-    @tester = FFakerTW::NameDA
-  end
-
-  def test_name
-    assert_raise(ArgumentError, 'Invalid gender, must be one of :any, :male, :female') do
-      @tester.name(:hahaha)
-    end
-  end
-
-  def test_any_name
-    assert_less_than @tester.any_name.count(' '), 3
-  end
-
-  def test_male_name
-    regexp = /#{@tester::MALE_FIRST_NAMES.join('|')}/
-    assert_less_than @tester.male_name.count(' '), 3
-    assert_match(regexp, @tester.male_name)
-  end
-
-  def test_female_name
-    regexp = /#{@tester::FEMALE_FIRST_NAMES.join('|')}/
-    assert_less_than @tester.female_name.count(' '), 3
-    assert_match(regexp, @tester.female_name)
-  end
-
-  def test_first_name
-    assert_include @tester::MALE_FIRST_NAMES, @tester.first_name(:male)
-    assert_include @tester::FEMALE_FIRST_NAMES, @tester.first_name(:female)
-    first_names = @tester::MALE_FIRST_NAMES + @tester::FEMALE_FIRST_NAMES
-    assert_include first_names, @tester.first_name(:any)
-    assert_include first_names, @tester.first_name
-    assert_raise(ArgumentError, 'Invalid gender, must be one of :any, :male, :female') do
-      @tester.first_name(:hahaha)
-    end
-  end
-
-  def test_last_name
-    assert_match(/\A['a-z]+\z/i, @tester.last_name)
-  end
-
-  def test_prefix
-    assert_match(/\A(?:Hr|Fr|Dr|Prof)\.\Z/, @tester.prefix)
-  end
-end

data/test/test_name_de.rb

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

data/test/test_name_es.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameES < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameES,
-    :name, :name_with_prefix, :first_name, :first_name_female, :first_name_male,
-    :last_name, :prefix, :female_prefix, :male_prefix
-  )
-
-  def setup
-    @tester = FFakerTW::NameES
-  end
-
-  def test_name
-    assert_match(/\A[a-zA-ZáéíóúñÁÉÍÓÚç\s]+\z/, @tester.name)
-  end
-
-  def test_name_with_prefix
-    prefix, name, last_name = @tester.name_with_prefix.split(/\s+/)
-    assert_include(@tester::PREFIXES, prefix)
-    refute_empty(name)
-    refute_empty(last_name)
-  end
-
-  def test_female_name_with_prefix
-    prefix, name, last_name = @tester.female_name_with_prefix.split(/\s+/)
-    assert_include(@tester::FEMALE_PREFIXES, prefix)
-    assert_include(@tester::FIRST_NAMES_FEMALE, name)
-    refute_empty(last_name)
-  end
-
-  def test_male_name_with_prefix
-    prefix, name, last_name = @tester.male_name_with_prefix.split(/\s+/)
-    assert_include(@tester::MALE_PREFIXES, prefix)
-    assert_include(@tester::FIRST_NAMES_MALE, name)
-    refute_empty(last_name)
-  end
-
-  def test_first_name
-    assert_include(@tester::FIRST_NAMES, @tester.first_name)
-  end
-
-  def test_first_name_female
-    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
-  end
-
-  def test_first_name_male
-    assert_include @tester::FIRST_NAMES_MALE, @tester.first_name_male
-  end
-
-  def test_last_name
-    assert_include(@tester::LAST_NAMES, @tester.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
-end

data/test/test_name_fr.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameFR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameFR,
-    :first_name, :last_name, :prefix
-  )
-
-  def setup
-    @tester = FFakerTW::NameFR
-  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_prefix
-    assert_include @tester::PREFIX, @tester.prefix
-  end
-
-  def test_name
-    # => split the name into an array of words
-    parts = @tester.name.split(' ')
-    case parts.count
-    when 3
-      first_name, prefix, last_name = parts
-      # the value at the index 1 should be a valid! prefix
-      assert_include @tester::PREFIX, prefix
-
-      # the value at the index 0 should be a valid! first_name
-      assert_include @tester::FIRST_NAMES, first_name
-
-      # the value at the index 2 should be a valid! last_name
-      assert_include @tester::LAST_NAMES, last_name
-    when 2
-      first_name, last_name = parts
-      # the value at the index 0 should be a valid! first_name
-      assert_include @tester::FIRST_NAMES, first_name
-
-      # the value at the index 1 should be a valid! last_name
-      assert_include @tester::LAST_NAMES, last_name
-    end
-  end
-end

data/test/test_name_ga.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameGa < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameGA,
-    :last_name, :first_name_male, :first_name_female, :name_male, :name_female, :name
-  )
-
-  def setup
-    @tester = FFakerTW::NameGA
-  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_name_male
-    # => split the name_male into an array of words
-    first_name, last_name = @tester.name_male.split(' ')
-
-    # the value at the index 0 should be a valid! male_prefix
-    assert_include @tester::FIRST_NAMES_MALE, first_name
-
-    # the value at the index 1 should be a valid! last_name
-    assert_include @tester::LAST_NAMES, last_name
-  end
-
-  def test_name_female
-    # => split the name_male into an array of words
-    first_name, last_name = @tester.name_female.split(' ')
-
-    # the value at the index 0 should be a valid! male_prefix
-    assert_include @tester::FIRST_NAMES_FEMALE, first_name
-
-    # the value at the index 1 should be a valid! last_name
-    assert_include @tester::LAST_NAMES, last_name
-  end
-
-  def test_name
-    # => split the name_male into an array of words
-    first_name, last_name = @tester.name.split(' ')
-
-    # the value at the index 0 should be a valid! male_prefix
-    assert_include(@tester::FIRST_NAMES_FEMALE + @tester::FIRST_NAMES_MALE, first_name)
-
-    # the value at the index 1 should be a valid! last_name
-    assert_include @tester::LAST_NAMES, last_name
-  end
-end

data/test/test_name_gr.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameGR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameGR,
-    :male_first_name, :male_last_name, :female_first_name, :female_last_name,
-    :male_full_name, :female_full_name, :last_name, :first_name
-  )
-
-  def setup
-    @tester = FFakerTW::NameGR
-  end
-
-  def test_male_first_name
-    assert_include @tester::MALE_FIRST_NAMES, @tester.male_first_name
-  end
-
-  def test_male_last_name
-    assert_include @tester::MALE_LAST_NAMES, @tester.male_last_name
-  end
-
-  def test_female_first_name
-    assert_include @tester::FEMALE_FIRST_NAMES, @tester.female_first_name
-  end
-
-  def test_female_last_name
-    assert_include @tester::FEMALE_LAST_NAMES, @tester.female_last_name
-  end
-
-  def test_male_full_name
-    names = @tester.male_full_name.split(' ')
-    assert_include @tester::MALE_FIRST_NAMES, names[0]
-    assert_include @tester::MALE_LAST_NAMES, names[1]
-  end
-
-  def test_female_full_name
-    names = @tester.female_full_name.split(' ')
-    assert_include @tester::FEMALE_FIRST_NAMES, names[0]
-    assert_include @tester::FEMALE_LAST_NAMES, names[1]
-  end
-
-  # For random names
-  def test_last_name
-    all_names = @tester::MALE_LAST_NAMES + @tester::FEMALE_LAST_NAMES
-    assert_include all_names, @tester.last_name
-  end
-
-  def test_first_name
-    all_names = @tester::MALE_FIRST_NAMES + @tester::FEMALE_FIRST_NAMES
-    assert_include all_names, @tester.first_name
-  end
-
-  def test_full_name_male
-    names = @tester.full_name(:male).split(' ')
-    assert_include @tester::MALE_FIRST_NAMES, names[0]
-    assert_include @tester::MALE_LAST_NAMES, names[1]
-    assert_deterministic { @tester.full_name(:male) }
-  end
-
-  def test_full_name_female
-    names = @tester.full_name(:female).split(' ')
-    assert_include @tester::FEMALE_FIRST_NAMES, names[0]
-    assert_include @tester::FEMALE_LAST_NAMES, names[1]
-    assert_deterministic { @tester.full_name(:female) }
-  end
-end

data/test/test_name_id.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameID < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameID,
-    :name, :name_with_prefix, :first_name, :first_name_female, :first_name_male,
-    :last_name, :prefix, :female_prefix, :male_prefix
-  )
-
-  def setup
-    @tester = FFakerTW::NameID
-  end
-
-  def test_name
-    assert_match(/\A[a-zA-Z\s]+\z/, @tester.name)
-  end
-
-  def test_name_with_prefix
-    prefix, name, last_name = @tester.name_with_prefix.split(/\s+/)
-    assert_include(@tester::PREFIXES, prefix)
-    refute_empty(name)
-    refute_empty(last_name)
-  end
-
-  def test_female_name_with_prefix
-    prefix, name, last_name = @tester.female_name_with_prefix.split(/\s+/)
-    assert_include(@tester::FEMALE_PREFIXES, prefix)
-    assert_include(@tester::FIRST_NAMES_FEMALE, name)
-    refute_empty(last_name)
-  end
-
-  def test_male_name_with_prefix
-    prefix, name, last_name = @tester.male_name_with_prefix.split(/\s+/)
-    assert_include(@tester::MALE_PREFIXES, prefix)
-    assert_include(@tester::FIRST_NAMES_MALE, name)
-    refute_empty(last_name)
-  end
-
-  def test_first_name
-    assert_include(@tester::FIRST_NAMES, @tester.first_name)
-  end
-
-  def test_first_name_female
-    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
-  end
-
-  def test_first_name_male
-    assert_include @tester::FIRST_NAMES_MALE, @tester.first_name_male
-  end
-
-  def test_last_name
-    assert_include(@tester::LAST_NAMES, @tester.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
-end

data/test/test_name_it.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameIT < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameIT,
-    :prefix, :last_name, :first_name, :name
-  )
-
-  def setup
-    @tester = FFakerTW::NameIT
-  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_prefix
-    assert_include @tester::PREFIX, @tester.prefix
-  end
-
-  def test_name
-    # => split the name into an array of words
-    parts = @tester.name.split(' ')
-
-    case parts.count
-    when 3
-      prefix, first_name, last_name = parts
-      # the value at the index 0 should be a valid! prefix
-      assert_include @tester::PREFIX, prefix
-
-      # the value at the index 1 should be a valid! first_name
-      assert_include @tester::FIRST_NAMES, first_name
-
-      # the value at the index 2 should be a valid! last_name
-      assert_include @tester::LAST_NAMES, last_name
-    when 2
-      first_name, last_name = parts
-      # the value at the index 0 should be a valid! first_name
-      assert_include @tester::FIRST_NAMES, first_name
-
-      # the value at the index 1 should be a valid! last_name
-      assert_include @tester::LAST_NAMES, last_name
-    end
-  end
-end

data/test/test_name_ja.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameJA < Test::Unit::TestCase
-  class << self
-    def startup
-      FFakerTW::NameJA.const_set(:FIRST_NAMES, %w[あきら フミ 三郎])
-      FFakerTW::NameJA.const_set(:LAST_NAMES, %w[佐藤 高橋 佐々木])
-    end
-
-    def shutdown
-      FFakerTW::NameJA.class_eval { remove_const(:FIRST_NAMES) }
-      FFakerTW::NameJA.class_eval { remove_const(:LAST_NAMES) }
-    end
-  end
-
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameJA,
-    :last_name, :first_name, :last_first, :name
-  )
-
-  def setup
-    @tester = FFakerTW::NameJA
-  end
-
-  def test_first_name
-    assert_include(@tester::FIRST_NAMES, @tester.first_name)
-  end
-
-  def test_last_name
-    assert_include(@tester::LAST_NAMES, @tester.last_name)
-  end
-
-  def test_last_first
-    assert_last_first(@tester.last_first)
-  end
-
-  def test_name
-    assert_last_first(@tester.name)
-  end
-
-  private
-
-  def assert_last_first(actual)
-    last_first_regexp = /(#{@tester::LAST_NAMES.join('|')})(#{@tester::FIRST_NAMES.join('|')})/
-    assert_match(last_first_regexp, actual)
-  end
-end

data/test/test_name_kh.rb

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

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