ffakerTW 0.1.0

data/test/test_name_br.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameBR,
+    :name, :name_with_prefix, :first_name, :first_name_female, :first_name_male,
+    :last_name, :prefix, :female_prefix, :male_prefix
+  )
+
+  def setup
+    @tester = FFakerTW::NameBR
+  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)
+    assert(!name.empty?)
+    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_cn.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerNameCN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::NameCN,
+    :name, :first_name, :last_name
+  )
+
+  def setup
+    @tester = FFakerTW::NameCN
+  end
+
+  def test_name
+    assert_match(/\A.{2,}\z/, @tester.name)
+  end
+
+  def test_first_name
+    assert_match(/\A.{1,2}\z/, @tester.first_name)
+  end
+
+  def test_last_name
+    assert_match(/\A.{1,5}\z/, @tester.last_name)
+  end
+end

data/test/test_name_cs.rb

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

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

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

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

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

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

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

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

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

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