ffaker 2.2.0 → 2.3.0

data/test/test_company_it.rb

@@ -3,6 +3,12 @@
 require 'helper'
 
 class TestCompanyIT < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::CompanyIT,
+    :name, :suffix, :prefix
+  )
 
   def test_name
     assert_match(/[ a-z]+/, FFaker::CompanyIT.name)
@@ -12,7 +18,7 @@ class TestCompanyIT < Test::Unit::TestCase
     assert_match(/[ a-z]+/i, FFaker::CompanyIT.suffix)
   end
 
-    def test_prefix
+  def test_prefix
     assert_match(/[ a-z]+/i, FFaker::CompanyIT.prefix)
   end
 end

data/test/test_company_se.rb

@@ -3,6 +3,12 @@
 require 'helper'
 
 class TestCompanySE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::CompanySE,
+    :name, :suffix
+  )
 
   def test_name
     assert_match(/[ a-z]+/, FFaker::CompanySE.name)

data/test/test_conference.rb

@@ -3,8 +3,11 @@
 require 'helper'
 
 class TestConference < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Conference, :name)
+
   def test_name
-    assert_match /1\+|[ a-z]+/i, FFaker::Conference.name
+    assert_match(/1\+|[ a-z]+/i, FFaker::Conference.name)
   end
 end
-

data/test/test_course_mathematiques.rb

@@ -1,6 +1,10 @@
-require "helper"
+require 'helper'
 
 class TestCourseMathematiques < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::CoursesFR::Mathematiques, :lesson)
+
   def setup
     @subject = FFaker::CoursesFR::Mathematiques
   end

data/test/test_course_philosophie.rb

@@ -1,6 +1,10 @@
-require "helper"
+require 'helper'
 
 class TestCoursePhilosophie < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::CoursesFR::Philosophie, :lesson)
+
   def setup
     @subject = FFaker::CoursesFR::Philosophie
   end

data/test/test_currency.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestCurrency < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Currency,
+    :code, :name
+  )
+end

data/test/test_dizzle_ipsum.rb

@@ -3,28 +3,34 @@
 require 'helper'
 
 class TestDizzleIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::DizzleIpsum,
+    :paragraph, :sentence, :paragraphs, :sentences, :words, :word
+  )
 
   def test_paragraph
-    assert_match /1\+|[ a-z]+/i, FFaker::DizzleIpsum.paragraph
+    assert_match(/1\+|[ a-z]+/i, FFaker::DizzleIpsum.paragraph)
   end
 
   def test_sentence
-    assert_match /1\+|[ a-z]+/i, FFaker::DizzleIpsum.sentence
+    assert_match(/1\+|[ a-z]+/i, FFaker::DizzleIpsum.sentence)
   end
 
   def test_paragraphs
-    assert_match /1\+|[ a-z]+/i, FFaker::DizzleIpsum.paragraphs.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::DizzleIpsum.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match /1\+|[ a-z]+/i, FFaker::DizzleIpsum.sentences.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::DizzleIpsum.sentences.join(' '))
   end
 
   def test_words
-    assert_match /1\+|[ a-z]+/i, FFaker::DizzleIpsum.words.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::DizzleIpsum.words.join(' '))
   end
 
   def test_word
-    assert_match /1\+|[a-z]+/i, FFaker::DizzleIpsum.word
+    assert_match(/1\+|[a-z]+/i, FFaker::DizzleIpsum.word)
   end
 end

data/test/test_education.rb

@@ -3,6 +3,14 @@
 require 'helper'
 
 class TestFakerEducation < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Education,
+    :degree_short, :degree, :major,
+    :school_name, :school_generic_name, :school
+  )
+
   def setup
     @tester = FFaker::Education
   end
@@ -24,11 +32,10 @@ class TestFakerEducation < Test::Unit::TestCase
   end
 
   def test_school_generic_name
-    assert @tester.school_name.match(/.+/)
+    assert @tester.school_generic_name.match(/.+/)
   end
 
   def test_school
     assert @tester.school.match(/.+ .+( .+)?/)
   end
 end
-

data/test/test_faker.rb

@@ -3,28 +3,35 @@
 require 'helper'
 
 class TestFaker < Test::Unit::TestCase
+  include DeterministicHelper
+
   def test_numerify
     assert FFaker.numerify('###').match(/\d{3}/)
+    assert_deterministic { FFaker.numerify('###') }
   end
 
   def test_numerify_with_array
     assert FFaker.numerify(['###', '###']).match(/\d{3}/)
+    assert_deterministic { FFaker.numerify(['###', '###']) }
   end
 
   def test_letterify
     assert FFaker.letterify('???').match(/[a-z]{3}/)
+    assert_deterministic { FFaker.letterify('???') }
   end
 
   def test_letterify_with_array
     assert FFaker.letterify(['???', '???']).match(/[a-z]{3}/)
+    assert_deterministic { FFaker.letterify(['???', '???']) }
   end
 
   def test_bothify
     assert FFaker.bothify('???###').match(/[a-z]{3}\d{3}/)
+    assert_deterministic { FFaker.bothify('???###') }
   end
 
   def test_bothify_with_array
     assert FFaker.bothify(['???###', '???###']).match(/[a-z]{3}\d{3}/)
+    assert_deterministic { FFaker.bothify(['???###', '???###']) }
   end
-
 end

data/test/test_food.rb

@@ -3,19 +3,26 @@
 require 'helper'
 
 class TestFakerFood < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Food,
+    :vegetable, :fruit, :meat, :herb_or_spice
+  )
+
   def test_vegetable
-    assert_match /\A[-\/ íó'a-z0-9]+\z/i, FFaker::Food.vegetable
+    assert_match(/\A[-\/ íó'a-z0-9]+\z/i, FFaker::Food.vegetable)
   end
 
   def test_fruit
-    assert_match /\A[ a-z0-9]+\z/i, FFaker::Food.fruit
+    assert_match(/\A[ a-z0-9]+\z/i, FFaker::Food.fruit)
   end
 
   def test_meat
-    assert_match /\A[, a-z0-9]+\z/i, FFaker::Food.meat
+    assert_match(/\A[, a-z0-9]+\z/i, FFaker::Food.meat)
   end
 
   def test_herb_or_spice
-    assert_match /\A[-, a-z0-9]+\z/i, FFaker::Food.herb_or_spice
+    assert_match(/\A[-, a-z0-9]+\z/i, FFaker::Food.herb_or_spice)
   end
 end

data/test/test_gender.rb

@@ -3,12 +3,16 @@
 require 'helper'
 
 class TestFakerGender < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Gender, :random)
+
   def setup
     @tester = FFaker::Gender
   end
 
   def test_random
     gender_regex = /\A(male|female)\z/
-    assert_match gender_regex, @tester.random
+    assert_match(gender_regex, @tester.random)
   end
 end

data/test/test_gender_br.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestFakerGenderBR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::GenderBR, :random)
+
+  def setup
+    @tester = FFaker::GenderBR
+  end
+
+  def test_random
+    gender_regex = /\A(feminino|masculino)\z/
+    assert_match(gender_regex, @tester.random)
+  end
+end

data/test/test_gender_cn.rb

@@ -3,13 +3,16 @@
 require 'helper'
 
 class TestFakerGenderCN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::GenderCN, :random)
+
   def setup
     @tester = FFaker::GenderCN
   end
 
   def test_random
     gender_regex = /\A[男女]\z/
-    assert_match gender_regex, @tester.random
+    assert_match(gender_regex, @tester.random)
   end
-
 end

data/test/test_gender_kr.rb

@@ -3,22 +3,26 @@
 require 'helper'
 
 class TestFakerGenderKR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::GenderKR, :random)
+
   def setup
     @tester = FFaker::GenderKR
   end
 
   def test_random
     gender_regex = /\A[남녀]\z/
-    assert_match gender_regex, @tester.random
+    assert_match(gender_regex, @tester.random)
   end
 
   def test_sample
     gender_regex = /\A[남녀]\z/
-    assert_match gender_regex, @tester.sample
+    assert_match(gender_regex, @tester.sample)
   end
 
   def test_maybe
     gender_regex = /\A[남녀]\z/
-    assert_match gender_regex, @tester.maybe
+    assert_match(gender_regex, @tester.maybe)
   end
 end

data/test/test_geolocation.rb

@@ -3,19 +3,23 @@
 require 'helper'
 
 class TestGeolocation < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Geolocation, :lat, :lng)
+
   def test_lat
-    assert_match /[0-9]+/, FFaker::Geolocation.lat.to_s
+    assert_match(/[0-9]+/, FFaker::Geolocation.lat.to_s)
   end
 
   def test_lng
-    assert_match /[0-9]+/, FFaker::Geolocation.lng.to_s
+    assert_match(/[0-9]+/, FFaker::Geolocation.lng.to_s)
   end
 
   def test_boxed_coords
     coords_list = [
-      [[1,1], [3,3]],
-      [[12.3455,23.3434], [34.3434,36.34343]],
-      [[12.3455,23.3434], [10.3434,6.34343]]
+      [[1, 1], [3, 3]],
+      [[12.3455, 23.3434], [34.3434, 36.34343]],
+      [[12.3455, 23.3434], [10.3434, 6.34343]]
     ]
 
     coords_list.each do |coords|
@@ -26,9 +30,8 @@ class TestGeolocation < Test::Unit::TestCase
 
       new_coords = FFaker::Geolocation.boxed_coords(coords[0], coords[1])
 
-      assert (lat_min..lat_max).include?new_coords[0]
-      assert (lon_min..lon_max).include?new_coords[1]
+      assert (lat_min..lat_max).cover?new_coords[0]
+      assert (lon_min..lon_max).cover?new_coords[1]
     end
-
   end
 end

data/test/test_guid.rb

@@ -3,7 +3,12 @@
 require 'helper'
 
 class TestGuid < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Guid, :guid)
+
   def test_guid
-    assert_match /[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}/, FFaker::Guid.guid
+    assert_match(/[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}/,
+                 FFaker::Guid.guid)
   end
 end

data/test/test_healthcare_ipsum.rb

@@ -1,27 +1,34 @@
 require 'helper'
 
 class TestHealthcareIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::HealthcareIpsum,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
   def test_paragraph
-    assert_match /1\+|[ a-z]+/i, FFaker::HealthcareIpsum.paragraph
+    assert_match(/1\+|[ a-z]+/i, FFaker::HealthcareIpsum.paragraph)
   end
 
   def test_sentence
-    assert_match /1\+|[ a-z]+/i, FFaker::HealthcareIpsum.sentence
+    assert_match(/1\+|[ a-z]+/i, FFaker::HealthcareIpsum.sentence)
   end
 
   def test_paragraphs
-    assert_match /1\+|[ a-z]+/i, FFaker::HealthcareIpsum.paragraphs.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::HealthcareIpsum.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match /1\+|[ a-z]+/i, FFaker::HealthcareIpsum.sentences.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::HealthcareIpsum.sentences.join(' '))
   end
 
   def test_words
-    assert_match /1\+|[ a-z]+/i, FFaker::HealthcareIpsum.words.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::HealthcareIpsum.words.join(' '))
   end
 
   def test_word
-    assert_match /1\+|[a-z]+/i, FFaker::HealthcareIpsum.word
+    assert_match(/1\+|[a-z]+/i, FFaker::HealthcareIpsum.word)
   end
 end

data/test/test_hipster_ipsum.rb

@@ -3,29 +3,36 @@
 require 'helper'
 
 class TestHipsterIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::HipsterIpsum,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
   TEST_REGEX = /\+1|[ a-z]+/i
 
   def test_paragraph
-    assert_match TEST_REGEX, FFaker::HipsterIpsum.paragraph
+    assert_match(TEST_REGEX, FFaker::HipsterIpsum.paragraph)
   end
 
   def test_sentence
-    assert_match TEST_REGEX, FFaker::HipsterIpsum.sentence
+    assert_match(TEST_REGEX, FFaker::HipsterIpsum.sentence)
   end
 
   def test_paragraphs
-    assert_match TEST_REGEX, FFaker::HipsterIpsum.paragraphs.join(" ")
+    assert_match(TEST_REGEX, FFaker::HipsterIpsum.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match TEST_REGEX, FFaker::HipsterIpsum.sentences.join(" ")
+    assert_match(TEST_REGEX, FFaker::HipsterIpsum.sentences.join(' '))
   end
 
   def test_words
-    assert_match TEST_REGEX, FFaker::HipsterIpsum.words.join(" ")
+    assert_match(TEST_REGEX, FFaker::HipsterIpsum.words.join(' '))
   end
 
   def test_word
-    assert_match TEST_REGEX, FFaker::HipsterIpsum.word
+    assert_match(TEST_REGEX, FFaker::HipsterIpsum.word)
   end
 end