ffakerTW 0.1.0

data/test/test_lorem_ie.rb

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestModuleUtils < Test::Unit::TestCase
+  def test_provides_a_k_method_for_generating_constant_arrays
+    obj = Object.new
+    obj.extend FFakerTW::ModuleUtils
+    result = obj.k %w[1 2 3]
+
+    assert result.frozen?
+    result.each { |e| assert e.frozen? }
+  end
+end

data/test/test_movie.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestMovie < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Movie, :title, :rating)
+
+  def setup
+    @tester = FFakerTW::Movie
+  end
+
+  def test_title
+    assert_match(/[ a-z]+/, FFakerTW::Movie.title)
+  end
+
+  def test_rating
+    assert FFakerTW::Movie::RATINGS.include? @tester.rating
+  end
+end

data/test/test_music.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestMusic < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Music,
+    :genre, :album, :artist, :song
+  )
+
+  def test_genre
+    assert_match(%r{[A-z]|\W|&/+}, FFakerTW::Music.genre)
+  end
+
+  def test_album
+    assert_match(/\s|[A-z]|\W|\d|'|\?+/, FFakerTW::Music.album)
+  end
+
+  def test_artist
+    assert_match(/\s|[A-z]|\W|\d|'|\?|&|\+|\.|-+/, FFakerTW::Music.artist)
+  end
+
+  def test_song
+    assert_match(/\s|[A-z]|\W|\d|'|\?|&|\+|\.|-+/, FFakerTW::Music.song)
+  end
+end

data/test/test_name.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerName < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Name,
+    :name, :name_with_prefix, :female_name_with_prefix, :male_name_with_prefix,
+    :name_with_suffix, :female_name_with_suffix, :male_name_with_suffix,
+    :name_with_prefix_suffix, :female_name_with_prefix_suffix, :male_name_with_prefix_suffix,
+    :first_name, :first_name_female, :first_name_male, :last_name,
+    :prefix, :female_prefix, :male_prefix, :other_prefix, :suffix, :pronouns
+  )
+
+  def setup
+    @tester = FFakerTW::Name
+  end
+
+  def test_name
+    assert_match(/(\w+\.? ?){2,3}/, @tester.name)
+  end
+
+  def test_html_safe_name
+    assert_match(/(\w+\.? ?){2,3}/, @tester.html_safe_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_name_with_suffix
+    name, last_name, suffix = @tester.name_with_suffix.split(/\s+/)
+    assert_include(@tester::SUFFIXES, suffix)
+    assert(!name.empty?)
+    refute_empty(last_name)
+  end
+
+  def test_female_name_with_suffix
+    name, last_name, suffix = @tester.female_name_with_suffix.split(/\s+/)
+    assert_include(@tester::SUFFIXES, suffix)
+    assert_include(@tester::FIRST_NAMES_FEMALE, name)
+    refute_empty(last_name)
+  end
+
+  def test_male_name_with_suffix
+    name, last_name, suffix = @tester.male_name_with_suffix.split(/\s+/)
+    assert_include(@tester::SUFFIXES, suffix)
+    assert_include(@tester::FIRST_NAMES_MALE, name)
+    refute_empty(last_name)
+  end
+
+  def test_name_with_prefix_suffix
+    prefix, name, last_name, suffix = @tester.name_with_prefix_suffix.split(/\s+/)
+    assert_include(@tester::PREFIXES, prefix)
+    assert_include(@tester::SUFFIXES, suffix)
+    assert(!name.empty?)
+    refute_empty(last_name)
+  end
+
+  def test_female_name_with_prefix_suffix
+    prefix, name, last_name, suffix = @tester.female_name_with_prefix_suffix.split(/\s+/)
+    assert_include(@tester::FEMALE_PREFIXES, prefix)
+    assert_include(@tester::SUFFIXES, suffix)
+    assert_include(@tester::FIRST_NAMES_FEMALE, name)
+    refute_empty(last_name)
+  end
+
+  def test_male_name_with_prefix_suffix
+    prefix, name, last_name, suffix = @tester.male_name_with_prefix_suffix.split(/\s+/)
+    assert_include(@tester::MALE_PREFIXES, prefix)
+    assert_include(@tester::SUFFIXES, suffix)
+    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_html_safe_last_name
+    assert_include(@tester::LAST_NAMES, @tester.html_safe_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_other_prefix
+    assert_include(@tester::OTHER_PREFIXES, @tester.other_prefix)
+  end
+
+  def test_suffix
+    assert_match(/[A-Z][a-z]*\.?/, @tester.suffix)
+  end
+
+  def test_pronouns
+    assert_include(@tester::PRONOUNS, @tester.pronouns)
+  end
+end

data/test/test_name_ar.rb

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