ffaker 2.2.0 → 2.3.0

data/test/test_job_kr.rb

@@ -3,6 +3,10 @@
 require 'helper'
 
 class TestFakerJobKR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::JobKR, :title)
+
   def setup
     @tester = FFaker::JobKR
   end

data/test/test_job_vn.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+
+require 'helper'
+
+class TestFakerJobVN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::JobVN, :title)
+
+  def setup
+    @tester = FFaker::JobVN
+  end
+
+  def test_title
+    assert @tester.title.length >= 1
+  end
+
+  def test_nouns
+    assert_kind_of Array, @tester::JOB_NOUNS
+  end
+end

data/test/test_locale.rb

@@ -3,19 +3,25 @@
 require 'helper'
 
 class TestLocale < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Locale, :code, :language)
+
   def test_code
-    assert_match /./, FFaker::Locale.code
+    assert_match(/./, FFaker::Locale.code)
   end
 
   def test_language
-    assert_match /./, FFaker::Locale.language
+    assert_match(/./, FFaker::Locale.language)
   end
 
   def test_language_with_args
-    assert_match 'French', FFaker::Locale.language('FR')
+    assert_match('French', FFaker::Locale.language('FR'))
+    assert_deterministic { FFaker::Locale.language('FR') }
   end
 
   def test_code_with_args
-    assert_match 'FR', FFaker::Locale.code('French')
+    assert_match('FR', FFaker::Locale.code('French'))
+    assert_deterministic { FFaker::Locale.code('French') }
   end
 end

data/test/test_lorem.rb

@@ -3,45 +3,52 @@
 require 'helper'
 
 class TestLorem < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Lorem,
+    :paragraph, :sentence, :phrase, :paragraphs, :sentences, :phrases, :words, :word, :characters
+  )
+
   def test_paragraph
-    assert_match /[ a-z]+/, FFaker::Lorem.paragraph
+    assert_match(/[ a-z]+/, FFaker::Lorem.paragraph)
   end
 
   def test_sentence
-    assert_match /[ a-z]+/, FFaker::Lorem.sentence
+    assert_match(/[ a-z]+/, FFaker::Lorem.sentence)
     assert_nothing_thrown do
       100.times { FFaker::Lorem.sentence 0 }
     end
   end
 
   def test_phrase
-    assert_match /[ a-z]+/, FFaker::Lorem.phrase
+    assert_match(/[ a-z]+/, FFaker::Lorem.phrase)
   end
 
   def test_paragraphs
-    assert_match /[ a-z]+/, FFaker::Lorem.paragraphs.join(" ")
+    assert_match(/[ a-z]+/, FFaker::Lorem.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match /[ a-z]+/, FFaker::Lorem.sentences.join(" ")
+    assert_match(/[ a-z]+/, FFaker::Lorem.sentences.join(' '))
   end
 
   def test_phrases
-    assert_match /[ a-z]+/, FFaker::Lorem.phrases.join(" ")
+    assert_match(/[ a-z]+/, FFaker::Lorem.phrases.join(' '))
   end
 
   def test_words
-    assert_match /[ a-z]+/, FFaker::Lorem.words.join(" ")
+    assert_match(/[ a-z]+/, FFaker::Lorem.words.join(' '))
   end
 
   def test_word
-    assert_match /[a-z]+/, FFaker::Lorem.word
+    assert_match(/[a-z]+/, FFaker::Lorem.word)
   end
 
   def test_characters
-    assert_match /[a-z0-9]+/, FFaker::Lorem.characters
-    assert FFaker::Lorem.characters().length == 255
+    assert_match(/[a-z0-9]+/, FFaker::Lorem.characters)
+    assert FFaker::Lorem.characters.length == 255
     assert FFaker::Lorem.characters(10).length == 10
-    assert FFaker::Lorem.characters(-1) == ""
+    assert FFaker::Lorem.characters(-1) == ''
   end
 end

data/test/test_lorem_ar.rb

@@ -3,35 +3,43 @@
 require 'helper'
 
 class TestLoremARAR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::LoremAR,
+    :paragraph, :paragraphs, :sentence, :sentences,
+    :phrase, :phrases, :word, :words
+  )
+
   def test_paragraph
-    assert_match /[ a-z]+/, FFaker::LoremAR.paragraph
+    assert_match(/[ a-z]+/, FFaker::LoremAR.paragraph)
   end
 
   def test_sentence
-    assert_match /[ a-z]+/, FFaker::LoremAR.sentence
+    assert_match(/[ a-z]+/, FFaker::LoremAR.sentence)
   end
 
   def test_phrase
-    assert_match /[ a-z]+/, FFaker::LoremAR.phrase
+    assert_match(/[ a-z]+/, FFaker::LoremAR.phrase)
   end
 
   def test_paragraphs
-    assert_match /[^a-zA-Z0-9]+/, FFaker::LoremAR.paragraphs.join(" ")
+    assert_match(/[^a-zA-Z0-9]+/, FFaker::LoremAR.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match /[^a-zA-Z0-9]+/, FFaker::LoremAR.sentences.join(" ")
+    assert_match(/[^a-zA-Z0-9]+/, FFaker::LoremAR.sentences.join(' '))
   end
 
   def test_phrases
-    assert_match /[^a-zA-Z0-9]+/, FFaker::LoremAR.phrases.join(" ")
+    assert_match(/[^a-zA-Z0-9]+/, FFaker::LoremAR.phrases.join(' '))
   end
 
   def test_words
-    assert_match /[^a-zA-Z0-9]+/, FFaker::LoremAR.words.join(" ")
+    assert_match(/[^a-zA-Z0-9]+/, FFaker::LoremAR.words.join(' '))
   end
 
   def test_word
-    assert_match /[^a-zA-Z0-9]+/, FFaker::LoremAR.word
+    assert_match(/[^a-zA-Z0-9]+/, FFaker::LoremAR.word)
   end
 end

data/test/test_lorem_cn.rb

@@ -3,12 +3,19 @@
 require 'helper'
 
 class TestLoremCN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::LoremCN,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
   def test_paragraph
-    assert FFaker::LoremCN.paragraph.length >= 3*4*2
+    assert FFaker::LoremCN.paragraph.length >= 3 * 4 * 2
   end
 
   def test_sentence
-    assert FFaker::LoremCN.sentence.length >= 4*2
+    assert FFaker::LoremCN.sentence.length >= 4 * 2
   end
 
   def test_paragraphs

data/test/test_lorem_fr.rb

@@ -3,35 +3,43 @@
 require 'helper'
 
 class TestLoremFR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::LoremFR,
+    :paragraph, :paragraphs, :sentence, :sentences,
+    :phrase, :phrases, :word, :words
+  )
+
   def test_paragraph
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraph
+    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraph)
   end
 
   def test_sentence
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.sentence
+    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.sentence)
   end
 
   def test_phrase
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.phrase
+    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.phrase)
   end
 
   def test_paragraphsLoremFR
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraphs.join(" ")
+    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.sentences.join(" ")
+    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.sentences.join(' '))
   end
 
   def test_phrases
-    assert_match /\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.phrases.join(" ")
+    assert_match(/\A[ -.àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.phrases.join(' '))
   end
 
   def test_words
-    assert_match /\A[ -àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.words.join(" ")
+    assert_match(/\A[ -àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.words.join(' '))
   end
 
   def test_word
-    assert_match /\A[-àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.word
+    assert_match(/\A[-àâéèêîôùûa-z]+\z/i, FFaker::LoremFR.word)
   end
 end

data/test/test_lorem_ja.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestLoremJA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::LoremJA,
+    :character, :characters,
+    :word, :words,
+    :sentence, :sentences,
+    :paragraph, :paragraphs
+  )
+
+  def setup
+    @subject = FFaker::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 @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 @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 @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

@@ -3,45 +3,54 @@
 require 'helper'
 
 class TestLoremKR < Test::Unit::TestCase
+  include DeterministicHelper
+
   KOREAN_SENTENCE_MATCHER = /\A[ .가-힣]+\z/
   KOREAN_WORDS_MATCHER = /\A[ 가-힣]+\z/
   KOREAN_WORD_MATCHER = /\A[가-힣]+\z/
+
+  assert_methods_are_deterministic(
+    FFaker::LoremKR,
+    :paragraph, :paragraphs, :sentence, :sentences,
+    :phrase, :phrases, :word, :words
+  )
+
   def setup
     @tester = FFaker::LoremKR
   end
 
   def test_paragraph
-    assert_match KOREAN_SENTENCE_MATCHER, @tester.paragraph
+    assert_match(KOREAN_SENTENCE_MATCHER, @tester.paragraph)
   end
 
   def test_sentence
-    assert_match KOREAN_SENTENCE_MATCHER, @tester.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
+    assert_match(KOREAN_SENTENCE_MATCHER, @tester.phrase)
   end
 
   def test_paragraphs
-    assert_match KOREAN_SENTENCE_MATCHER, @tester.paragraphs.join(" ")
+    assert_match(KOREAN_SENTENCE_MATCHER, @tester.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match KOREAN_SENTENCE_MATCHER, @tester.sentences.join(" ")
+    assert_match(KOREAN_SENTENCE_MATCHER, @tester.sentences.join(' '))
   end
 
   def test_phrases
-    assert_match KOREAN_SENTENCE_MATCHER, @tester.phrases.join(" ")
+    assert_match(KOREAN_SENTENCE_MATCHER, @tester.phrases.join(' '))
   end
 
   def test_words
-    assert_match KOREAN_WORDS_MATCHER, @tester.words.join(" ")
+    assert_match(KOREAN_WORDS_MATCHER, @tester.words.join(' '))
   end
 
   def test_word
-    assert_match KOREAN_WORD_MATCHER, @tester.word
+    assert_match(KOREAN_WORD_MATCHER, @tester.word)
   end
 end

data/test/test_lorem_ua.rb

@@ -3,43 +3,50 @@
 require 'helper'
 
 class TestLoremUA < Test::Unit::TestCase
+  include DeterministicHelper
+
   SENTENCE_MATCHER = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s\.\!\?,]+\z/
   WORDS_MATCHER    = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/
   WORD_MATCHER     = /\A[а-яА-ЯіїєґІЇЄҐ’\-]+\z/
 
+  assert_methods_are_deterministic(
+    FFaker::LoremUA,
+    :paragraph, :sentence, :words, :word
+  )
+
   def setup
     @tester = FFaker::LoremUA
   end
 
   def test_word
-    assert_match WORD_MATCHER, @tester.word
+    assert_match(WORD_MATCHER, @tester.word)
   end
 
   def test_words
     @tester.words(10).each do |word|
-      assert_match WORD_MATCHER, word
+      assert_match(WORD_MATCHER, word)
     end
-    assert_match WORDS_MATCHER, @tester.words.join(" ")
+    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)
+    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
+      assert_match(SENTENCE_MATCHER, sentence)
     end
   end
 
   def test_paragraph
-    assert_match SENTENCE_MATCHER, @tester.paragraph
+    assert_match(SENTENCE_MATCHER, @tester.paragraph)
   end
 
   def test_paragraphs
     @tester.paragraphs.each do |paragraph|
-      assert_match SENTENCE_MATCHER, paragraph
+      assert_match(SENTENCE_MATCHER, paragraph)
     end
   end
 end