ffakerTW 0.1.0 → 1.2.0

data/test/test_lorem_cn.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremCN < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremCN,
-    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
-  )
-
-  def test_paragraph
-    assert_greater_than_or_equal_to FFakerTW::LoremCN.paragraph.length, 3 * 4 * 2
-  end
-
-  def test_sentence
-    assert_greater_than_or_equal_to FFakerTW::LoremCN.sentence.length, 4 * 2
-  end
-
-  def test_paragraphs
-    assert_greater_than_or_equal_to FFakerTW::LoremCN.paragraphs.length, 2
-  end
-
-  def test_paragraphs_is_not_a_string_representation_of_an_array
-    assert !/[\[\]]+/.match([FFakerTW::LoremCN.paragraphs].flatten.join(' '))
-  end
-
-  def test_paragraphs_is_an_array
-    assert FFakerTW::LoremCN.paragraphs.class == Array
-  end
-
-  def test_sentences
-    assert_greater_than_or_equal_to FFakerTW::LoremCN.sentences.length, 2
-  end
-
-  def test_sentences_is_an_array
-    assert FFakerTW::LoremCN.sentences.class == Array
-  end
-
-  def test_sentences_via_to_s_produces_string_terminated_with_period
-    string = FFakerTW::LoremCN.sentences.to_s
-    assert string.class == String
-    assert string =~ /。$/
-  end
-
-  def test_words
-    assert_greater_than_or_equal_to FFakerTW::LoremCN.words.length, 2
-  end
-
-  def test_word
-    assert_greater_than_or_equal_to FFakerTW::LoremCN.word.length, 1
-  end
-end

data/test/test_lorem_fr.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremFR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremFR,
-    :paragraph, :paragraphs, :sentence, :sentences, :phrase, :phrases, :word, :words
-  )
-
-  REGEX = /\A[ -.ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
-  REGEX_WORD = /\A[-ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
-  REGEX_WORDS = /\A[ -ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
-
-  def test_paragraph
-    assert_match(REGEX, FFakerTW::LoremFR.paragraph)
-  end
-
-  def test_sentence
-    assert_match(REGEX, FFakerTW::LoremFR.sentence)
-  end
-
-  def test_phrase
-    assert_match(REGEX, FFakerTW::LoremFR.phrase)
-  end
-
-  def test_paragraphs
-    assert_match(REGEX, FFakerTW::LoremFR.paragraphs.join(' '))
-  end
-
-  def test_sentences
-    assert_match(REGEX, FFakerTW::LoremFR.sentences.join(' '))
-  end
-
-  def test_phrases
-    assert_match(REGEX, FFakerTW::LoremFR.phrases.join(' '))
-  end
-
-  def test_words
-    assert_match(REGEX_WORDS, FFakerTW::LoremFR.words.join(' '))
-  end
-
-  def test_word
-    assert_match(REGEX_WORD, FFakerTW::LoremFR.word)
-  end
-end

data/test/test_lorem_ie.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremIE < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremIE,
-    :paragraph, :paragraphs, :sentence, :sentences,
-    :phrase, :phrases, :word, :words, :question
-  )
-
-  WORDS_REGEX = /\A[\w\W]+\z/i.freeze # spaces, alphanumeric & perioids, etc.
-  WORD_REGEX = /\A[áéíóúa-z]+\z/i.freeze
-
-  def test_paragraph
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.paragraph)
-  end
-
-  def test_question
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.question)
-  end
-
-  def test_sentence
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.sentence)
-  end
-
-  def test_phrase
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.phrase)
-  end
-
-  def test_paragraphs
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.paragraphs.join(' '))
-  end
-
-  def test_sentences
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.sentences.join(' '))
-  end
-
-  def test_phrases
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.phrases.join(' '))
-  end
-
-  def test_words
-    assert_match(WORDS_REGEX, FFakerTW::LoremIE.words.join(' '))
-  end
-
-  def test_word
-    assert_match(WORD_REGEX, FFakerTW::LoremIE.word)
-  end
-end

data/test/test_lorem_it.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremIT < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremIT,
-    :paragraph, :sentence, :phrase, :paragraphs, :sentences, :phrases, :words, :word
-  )
-
-  def test_paragraph
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.paragraph)
-  end
-
-  def test_sentence
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.sentence)
-    assert_nothing_thrown do
-      100.times { FFakerTW::LoremIT.sentence 0 }
-    end
-  end
-
-  def test_phrase
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.phrase)
-  end
-
-  def test_paragraphs
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.paragraphs.join(' '))
-  end
-
-  def test_sentences
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.sentences.join(' '))
-  end
-
-  def test_phrases
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.phrases.join(' '))
-  end
-
-  def test_words
-    assert_match(/[ a-z]+/, FFakerTW::LoremIT.words.join(' '))
-  end
-
-  def test_word
-    assert_match(/[a-z]+/, FFakerTW::LoremIT.word)
-  end
-
-  def test_word_collection_uniqueness
-    assert_equal(FFakerTW::LoremIT::WORDS, FFakerTW::LoremIT::WORDS.uniq)
-  end
-end

data/test/test_lorem_ja.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremJA < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremJA,
-    :character, :characters,
-    :word, :words,
-    :sentence, :sentences,
-    :paragraph, :paragraphs
-  )
-
-  def setup
-    @subject = FFakerTW::LoremJA
-  end
-
-  def test_character
-    assert_equal 1, @subject.character.length
-    assert_kind_of String, @subject.character
-  end
-
-  def test_characters
-    assert_equal 20, @subject.characters.length
-    assert_kind_of String, @subject.characters
-  end
-
-  def test_characters_with_count
-    assert_equal 30, @subject.characters(30).length
-    assert_deterministic { @subject.characters(30) }
-  end
-
-  def test_word
-    assert_greater_than_or_equal_to @subject.word.length, 1
-    assert_kind_of String, @subject.word
-  end
-
-  def test_words
-    assert_equal 3, @subject.words.length
-    assert_kind_of Array, @subject.words
-  end
-
-  def test_words_with_count
-    assert_equal 10, @subject.words(10).length
-    assert_deterministic { @subject.words(10) }
-  end
-
-  def test_sentence
-    assert_greater_than_or_equal_to @subject.sentence.length, 1
-  end
-
-  def test_sentences
-    assert_equal 3, @subject.sentences.length
-    assert_kind_of Array, @subject.sentences
-  end
-
-  def test_sentences_with_count
-    assert_equal 10, @subject.sentences(10).length
-    assert_deterministic { @subject.sentences(10) }
-  end
-
-  def test_paragraph
-    assert_greater_than_or_equal_to @subject.paragraph.length, 1
-  end
-
-  def test_paragraphs
-    assert_equal 3, @subject.paragraphs.length
-    assert_kind_of Array, @subject.paragraphs
-  end
-
-  def test_paragraphs_with_count
-    assert_equal 10, @subject.paragraphs(10).length
-    assert_deterministic { @subject.paragraphs(10) }
-  end
-
-  def test_paragraph_end_with_terminate_character
-    assert_match(/。$/, @subject.paragraph)
-  end
-end

data/test/test_lorem_kr.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremKR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  KOREAN_SENTENCE_MATCHER = /\A[ .가-힣]+\z/.freeze
-  KOREAN_WORDS_MATCHER = /\A[ 가-힣]+\z/.freeze
-  KOREAN_WORD_MATCHER = /\A[가-힣]+\z/.freeze
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremKR,
-    :paragraph, :paragraphs, :sentence, :sentences,
-    :phrase, :phrases, :word, :words
-  )
-
-  def setup
-    @tester = FFakerTW::LoremKR
-  end
-
-  def test_paragraph
-    assert_match(KOREAN_SENTENCE_MATCHER, @tester.paragraph)
-  end
-
-  def test_sentence
-    assert_match(KOREAN_SENTENCE_MATCHER, @tester.sentence)
-    assert_nothing_thrown do
-      100.times { @tester.sentence 0 }
-    end
-  end
-
-  def test_phrase
-    assert_match(KOREAN_SENTENCE_MATCHER, @tester.phrase)
-  end
-
-  def test_paragraphs
-    assert_match(KOREAN_SENTENCE_MATCHER, @tester.paragraphs.join(' '))
-  end
-
-  def test_sentences
-    assert_match(KOREAN_SENTENCE_MATCHER, @tester.sentences.join(' '))
-  end
-
-  def test_phrases
-    assert_match(KOREAN_SENTENCE_MATCHER, @tester.phrases.join(' '))
-  end
-
-  def test_words
-    assert_match(KOREAN_WORDS_MATCHER, @tester.words.join(' '))
-  end
-
-  def test_word
-    assert_match(KOREAN_WORD_MATCHER, @tester.word)
-  end
-end

data/test/test_lorem_pl.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerLoremPL < Test::Unit::TestCase
-  include DeterministicHelper
-
-  POLISH_WORD_MATCHER = /\A[A-Ża-ż\s]+\z/.freeze
-  POLISH_SENTENCE_MATCHER = /\A[A-Ża-ż\s.!?,]+\z/.freeze
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremPL,
-    :character, :characters, :word, :words,
-    :sentence, :sentences, :paragraph, :paragraphs
-  )
-
-  def setup
-    @tester = FFakerTW::LoremPL
-  end
-
-  def test_word
-    assert_match(POLISH_WORD_MATCHER, @tester.word)
-  end
-
-  def test_words
-    @tester.words(10).each do |word|
-      assert_match(POLISH_WORD_MATCHER, word)
-    end
-  end
-
-  def test_sentence
-    assert_match(POLISH_SENTENCE_MATCHER, @tester.sentence(20))
-    assert_match(POLISH_SENTENCE_MATCHER, @tester.sentence(4))
-  end
-
-  def test_sentences
-    @tester.sentences(10).each do |sentence|
-      assert_match(POLISH_SENTENCE_MATCHER, sentence)
-    end
-  end
-
-  def test_paragraph
-    assert_match(POLISH_SENTENCE_MATCHER, @tester.paragraph)
-  end
-
-  def test_paragraphs
-    @tester.paragraphs.each do |paragraph|
-      assert_match(POLISH_SENTENCE_MATCHER, paragraph)
-    end
-  end
-end

data/test/test_lorem_ru.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremRU < Test::Unit::TestCase
-  include DeterministicHelper
-
-  SENTENCE_MATCHER = /\A[а-яА-ЯёЁ\-\s.!?,]+\z/.freeze
-  WORDS_MATCHER    = /\A[А-Яа-яёЁ\-\s]+\z/.freeze
-  WORD_MATCHER     = /\A[А-Яа-яёЁ\-]+\z/.freeze
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremRU,
-    :paragraph, :sentence, :words, :word
-  )
-
-  def setup
-    @tester = FFakerTW::LoremRU
-  end
-
-  def test_word
-    assert_match(WORD_MATCHER, @tester.word)
-  end
-
-  def test_words
-    @tester.words(10).each do |word|
-      assert_match(WORD_MATCHER, word)
-    end
-    assert_match(WORDS_MATCHER, @tester.words.join(' '))
-  end
-
-  def test_sentence
-    assert_match(SENTENCE_MATCHER, @tester.sentence(20))
-    assert_match(SENTENCE_MATCHER, @tester.sentence(4))
-  end
-
-  def test_sentences
-    @tester.sentences(10).each do |sentence|
-      assert_match(SENTENCE_MATCHER, sentence)
-    end
-  end
-
-  def test_paragraph
-    assert_match(SENTENCE_MATCHER, @tester.paragraph)
-  end
-
-  def test_paragraphs
-    @tester.paragraphs.each do |paragraph|
-      assert_match(SENTENCE_MATCHER, paragraph)
-    end
-  end
-end

data/test/test_lorem_ua.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestLoremUA < Test::Unit::TestCase
-  include DeterministicHelper
-
-  SENTENCE_MATCHER = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s.!?,]+\z/.freeze
-  WORDS_MATCHER    = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/.freeze
-  WORD_MATCHER     = /\A[а-яА-ЯіїєґІЇЄҐ’\-]+\z/.freeze
-
-  assert_methods_are_deterministic(
-    FFakerTW::LoremUA,
-    :paragraph, :sentence, :words, :word
-  )
-
-  def setup
-    @tester = FFakerTW::LoremUA
-  end
-
-  def test_word
-    assert_match(WORD_MATCHER, @tester.word)
-  end
-
-  def test_words
-    @tester.words(10).each do |word|
-      assert_match(WORD_MATCHER, word)
-    end
-    assert_match(WORDS_MATCHER, @tester.words.join(' '))
-  end
-
-  def test_sentence
-    assert_match(SENTENCE_MATCHER, @tester.sentence(20))
-    assert_match(SENTENCE_MATCHER, @tester.sentence(4))
-  end
-
-  def test_sentences
-    @tester.sentences(10).each do |sentence|
-      assert_match(SENTENCE_MATCHER, sentence)
-    end
-  end
-
-  def test_paragraph
-    assert_match(SENTENCE_MATCHER, @tester.paragraph)
-  end
-
-  def test_paragraphs
-    @tester.paragraphs.each do |paragraph|
-      assert_match(SENTENCE_MATCHER, paragraph)
-    end
-  end
-end

data/test/test_name_ar.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TestFakerNameAR < Test::Unit::TestCase
-  include DeterministicHelper
-
-  assert_methods_are_deterministic(
-    FFakerTW::NameAR,
-    :first_name_male, :first_name_female, :last_name,
-    :name_male, :name_female
-  )
-
-  def setup
-    @tester = FFakerTW::NameAR
-  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_last_name
-    assert_include(@tester::LAST_NAMES, @tester.last_name)
-  end
-
-  def test_name_male
-    expected = @tester::FIRST_NAMES_MALE.product(@tester::LAST_NAMES).map { |set| set.join(' ') }
-    assert_include(expected, @tester.name_male)
-  end
-
-  def test_name_female
-    expected = @tester::FIRST_NAMES_FEMALE.product(@tester::LAST_NAMES).map { |set| set.join(' ') }
-    assert_include(expected, @tester.name_female)
-  end
-end

data/test/test_name_br.rb

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

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