ffaker 2.2.0 → 2.3.0

data/test/test_phone_number_sg.rb

@@ -3,42 +3,50 @@
 require 'helper'
 
 class TestPhoneNumberSG < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::PhoneNumberSG,
+    :voip_number, :fixed_line_number, :mobile_number, :mobile_or_pager_number,
+    :international_toll_free_number, :toll_free_number, :premium_service_number,
+    :phone_number
+  )
+
   def setup
     @tester = FFaker::PhoneNumberSG
   end
 
   def test_voip_number
-    assert_match /3\d{3}\s\d{4}/, @tester.voip_number
+    assert_match(/3\d{3}\s\d{4}/, @tester.voip_number)
   end
 
   def test_fixed_line_number
-    assert_match /6\d{3}\s\d{4}/, @tester.fixed_line_number
+    assert_match(/6\d{3}\s\d{4}/, @tester.fixed_line_number)
   end
 
   def test_mobile_number
-    assert_match /8\d{3}\s\d{4}/, @tester.mobile_number
+    assert_match(/8\d{3}\s\d{4}/, @tester.mobile_number)
   end
 
   def test_mobile_or_pager_number
-    assert_match /9\d{3}\s\d{4}/, @tester.mobile_or_pager_number
+    assert_match(/9\d{3}\s\d{4}/, @tester.mobile_or_pager_number)
   end
 
   def test_international_toll_free_number
-    assert_match /800\s\d{3}\s\d{4}/, @tester.international_toll_free_number
+    assert_match(/800\s\d{3}\s\d{4}/, @tester.international_toll_free_number)
   end
 
   def test_toll_free_number
-    assert_match /1800\s\d{3}\s\d{4}/, @tester.toll_free_number
+    assert_match(/1800\s\d{3}\s\d{4}/, @tester.toll_free_number)
   end
 
   def test_premium_service_number
-    assert_match /1900\s\d{3}\s\d{4}/, @tester.premium_service_number
+    assert_match(/1900\s\d{3}\s\d{4}/, @tester.premium_service_number)
   end
 
   def test_phone_number
     10.times do
-      assert_match /[6,8,9]\d{3}\s\d{4}/, @tester.phone_number
+      assert_match(/[6,8,9]\d{3}\s\d{4}/, @tester.phone_number)
     end
   end
 end
-

data/test/test_phone_number_sn.rb

@@ -4,6 +4,14 @@ require 'helper'
 
 # Author: xarala<pathe.sene@xarala.sn> http://www.xarala.sn
 class TestPhoneNumberSN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::PhoneNumberSN,
+    :mobile_phone_prefix, :homework_phone_prefix, :mobile_number, :phone_number,
+    :homework_number, :short_phone_number
+  )
+
   def setup
     @tester = FFaker::PhoneNumberSN
   end
@@ -17,18 +25,18 @@ class TestPhoneNumberSN < Test::Unit::TestCase
   end
 
   def test_short_phone_number
-    assert_match /\d{3}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.short_phone_number
+    assert_match(/\d{3}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.short_phone_number)
   end
 
   def test_mobile_phone_number
-    assert_match /(70|76|77)-\d{3}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.mobile_number
+    assert_match(/(70|76|77)-\d{3}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.mobile_number)
   end
 
   def test_phone_number
-    assert_match /(33|70|76|77)-\d{3}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.phone_number
+    assert_match(/(33|70|76|77)-\d{3}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.phone_number)
   end
 
   def test_homework_phone_number
-    assert_match /(33)-(8|9)\d{2}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.homework_number
+    assert_match(/(33)-(8|9)\d{2}-\d{2}-\d{2}/, FFaker::PhoneNumberSN.homework_number)
   end
 end

data/test/test_products.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestProducts < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Product,
+    :brand, :product_name, :product, :model
+  )
+
+  def test_letters_max_as_int
+    assert_match(/\A[A-Z]{10}\z/, FFaker::Product.letters(10))
+    assert_deterministic { FFaker::Product.letters(10) }
+  end
+
+  def test_letters_max_as_range
+    assert_match(/\A[A-Z]{5,10}\z/, FFaker::Product.letters(5..10))
+    assert_deterministic { FFaker::Product.letters(5..10) }
+  end
+end

data/test/test_skill.rb

@@ -3,9 +3,15 @@
 require 'helper'
 
 class TestSkill < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Skill,
+    :tech_skill, :tech_skills, :specialty, :specialties
+  )
 
   def test_tech_skill
-    assert_match /[a-z]+/i, FFaker::Skill.tech_skill
+    assert_match(/[a-z]+/i, FFaker::Skill.tech_skill)
   end
 
   def test_tech_skills
@@ -14,7 +20,7 @@ class TestSkill < Test::Unit::TestCase
   end
 
   def test_specialty
-    assert_match /[ a-z]+/i, FFaker::Skill.specialty
+    assert_match(/[ a-z]+/i, FFaker::Skill.specialty)
   end
 
   def test_specialties

data/test/test_sports.rb

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

data/test/test_ssn.rb

@@ -3,9 +3,11 @@
 require 'helper'
 
 class TestSSN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::SSN, :ssn)
 
   def test_ssn
     assert_match(/\d{3}-\d{2}-\d{3}/, FFaker::SSN.ssn)
   end
-
 end

data/test/test_ssn_mx.rb

@@ -4,6 +4,12 @@ require 'helper'
 
 # Author Guapolo <github.com/guapolo>
 class TestSSNMX < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::SSNMX,
+    :ssn, :ssn_undashed, :imss, :imss_undashed, :issste, :issste_undashed
+  )
 
   def test_ssn
     assert_match(/\d{10}-\d/, FFaker::SSNMX.ssn)
@@ -28,5 +34,4 @@ class TestSSNMX < Test::Unit::TestCase
   def test_issste_undashed
     assert_match(/\d{11}/, FFaker::SSNMX.issste_undashed)
   end
-
 end

data/test/test_ssn_se.rb

@@ -3,6 +3,9 @@
 require 'helper'
 
 class TestSSNSE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::SSNSE, :ssn)
 
   def test_ssn_format
     ssn = FFaker::SSNSE.ssn

data/test/test_string.rb

@@ -3,85 +3,112 @@
 require 'helper'
 
 class TestString < Test::Unit::TestCase
+  include DeterministicHelper
+
   FS = FFaker::String
 
   def test_atoms
     assert_equal 'abc', FS.from_regexp(/abc/)
+    assert_deterministic { FS.from_regexp(/abc/) }
   end
 
   def test_digits
     assert_match(/\A\d\d\d\z/, FS.from_regexp(/\d\d\d/))
+    assert_deterministic { FS.from_regexp(/\d\d\d/) }
   end
 
   def test_word_characters
     assert_match(/\A\w\w\w\z/, FS.from_regexp(/\w\w\w/))
+    assert_deterministic { FS.from_regexp(/\w\w\w/) }
   end
 
   def test_word_range_character
     assert_match(/\A[a-z]\z/, FS.from_regexp(/[a-z]/))
+    assert_deterministic { FS.from_regexp(/[a-z]/) }
   end
 
   def test_dash_character
     assert_match(/\A[a-z-]\z/, FS.from_regexp(/[a-z-]/))
     assert_match(/\A[a-]\z/, FS.from_regexp(/[a-]/))
     assert_match(/\A[-]\z/, FS.from_regexp(/[-]/))
+
+    assert_deterministic { FS.from_regexp(/[a-z-]/) }
+    assert_deterministic { FS.from_regexp(/[a-]/) }
+    assert_deterministic { FS.from_regexp(/[-]/) }
   end
 
   def test_spaces
     assert_match(/\A\s\s\s\z/, FS.from_regexp(/\s\s\s/))
+    assert_deterministic { FS.from_regexp(/\s\s\s/) }
   end
 
   def test_escaped_characters
     assert_equal '\\/.()[]{}', FS.from_regexp(/\\\/\.\(\)\[\]\{\}/)
+    assert_deterministic { FS.from_regexp(%r|\\\/\.\(\)\[\]\{\}|) }
   end
 
   def test_atom_sets
     assert_include %w(a b c), FS.from_regexp(/[abc]/)
+    assert_deterministic { FS.from_regexp(/[abc]/) }
   end
 
   def test_special_sets
     assert_match(/\A[\w\d]\z/, FS.from_regexp(/[\w\d]/))
+    assert_deterministic { FS.from_regexp(/[\w\d]/) }
   end
 
   def test_atom_question
     assert_match(/\Aa?\z/, FS.from_regexp(/a?/))
+    assert_deterministic { FS.from_regexp(/a?/) }
   end
 
   def test_special_question
     assert_match(/\A\w?\z/, FS.from_regexp(/\w?/))
+    assert_deterministic { FS.from_regexp(/\w?/) }
   end
 
   def test_set_question
     assert_match(/\A[abc]?\z/, FS.from_regexp(/[abc]?/))
+    assert_deterministic { FS.from_regexp(/[abc]?/) }
   end
 
   def test_atom_plus
     assert_match(/\Aa+\z/, FS.from_regexp(/a+/))
+    assert_deterministic { FS.from_regexp(/a+/) }
   end
 
   def test_special_plus
     assert_match(/\A\w+\z/, FS.from_regexp(/\w+/))
+    assert_deterministic { FS.from_regexp(/\w+/) }
   end
 
   def test_set_plus
     assert_match(/\A[abc]+\z/, FS.from_regexp(/[abc]+/))
+    assert_deterministic { FS.from_regexp(/[abc]+/) }
   end
 
   def test_atom_star
     assert_match(/\Aa*\z/, FS.from_regexp(/a*/))
+    assert_deterministic { FS.from_regexp(/a*/) }
   end
 
   def test_special_star
     assert_match(/\A\w*\z/, FS.from_regexp(/\w*/))
+    assert_deterministic { FS.from_regexp(/\w*/) }
   end
 
   def test_set_star
     assert_match(/\A[abc]*\z/, FS.from_regexp(/[abc]*/))
+    assert_deterministic { FS.from_regexp(/[abc]*/) }
   end
 
   def test_braces
-    assert_equal "a" * 13, FS.from_regexp(/a{13}/)
+    assert_equal 'a' * 13, FS.from_regexp(/a{13}/)
     assert_match(/\A[abc]{13}\z/, FS.from_regexp(/[abc]{13}/))
     assert_match(/\A\w{13}\z/, FS.from_regexp(/\w{13}/))
+
+    assert_deterministic { FS.from_regexp(/a{13}/) }
+    assert_deterministic { FS.from_regexp(/[abc]{13}/) }
+    assert_deterministic { FS.from_regexp(/\w{13}/) }
   end
 end

data/test/test_time.rb

@@ -3,17 +3,48 @@
 require 'helper'
 
 class TestFakerTime < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Time, :date, :datetime, :month)
+
   def setup
     @tester = FFaker::Time
   end
 
   def test_date
     date_regex = /\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-|+]\d{4}\z/
-    assert_match date_regex, @tester.date.to_s
+    assert_match(date_regex, @tester.date)
+  end
+
+  def test_date_hours_and_minutes
+    assert_match('04:20:00', @tester.date(hours: 4, minutes: 20))
+    assert_deterministic { @tester.date(hours: 4, minutes: 20) }
+  end
+
+  def test_datetime
+    date_regex = /\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-|+]\d{4}\z/
+    assert_match(date_regex, @tester.datetime)
+  end
+
+  def test_datetime_hours_and_minutes
+    assert_match('04:20:00', @tester.datetime(hours: 4, minutes: 20))
+    assert_deterministic { @tester.datetime(hours: 4, minutes: 20) }
   end
 
   def test_month
     month_regex = /\A(?:January|February|March|April|May|June|July|August|September|October|November|December)\z/
-    assert_match month_regex, @tester.month
+    assert_match(month_regex, @tester.month)
+  end
+
+  def test_between
+    from = Time.local(2015, 1, 1)
+    to   = Time.local(2016, 1, 1)
+
+    100.times do
+      random_date = @tester.between(from, to)
+      assert random_date >= from, "Expected >= \"#{from}\", but got #{random_date}"
+      assert random_date <= to, "Expected <= \"#{to}\", but got #{random_date}"
+      assert_deterministic { @tester.between(from, to) }
+    end
   end
 end

data/test/test_tweet.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestTweet < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Tweet,
+    :tags, :mention, :body, :tweet
+  )
+
+  def test_2_tags
+    assert_match(/\#\S*\s\#\S*/, FFaker::Tweet.tags)
+  end
+
+  def test_3_tags
+    assert_match(/\#\S*\s\#\S*\s\#\S*/, FFaker::Tweet.tags(3))
+    assert_deterministic { FFaker::Tweet.tags(3) }
+  end
+
+  def test_mention
+    assert_match(/\@\S*/, FFaker::Tweet.mention)
+  end
+
+  def test_mentions_three
+    assert_match(/\@\S*\s\@\S*\s\@\S*/, FFaker::Tweet.mentions(3))
+    assert_deterministic { FFaker::Tweet.mentions(3) }
+  end
+
+  def test_body
+    assert(FFaker::Tweet.body.size <= 140)
+  end
+
+  def test_shortish_body
+    assert(FFaker::Tweet.body(20).size <= 20)
+  end
+
+  def test_short_body
+    assert(FFaker::Tweet.body(2).size.between?(2, 20))
+  end
+
+  def test_tweet
+    100.times { assert(FFaker::Tweet.tweet.size <= 140) }
+  end
+
+  def test_tweet_with_reply
+    assert_match(/^\@/, FFaker::Tweet.tweet(reply: true))
+    assert_deterministic { FFaker::Tweet.tweet(reply: true) }
+  end
+
+  def test_oversize_body_length
+    assert(FFaker::Tweet.tweet(body_length: 200).size <= 140)
+  end
+
+  def test_undersize_body_length
+    assert(FFaker::Tweet.tweet(body_length: 2).size <= 140)
+  end
+end

data/test/test_units.rb

@@ -4,6 +4,13 @@ require 'helper'
 
 # Author: lurraca github.com/lurraca
 class TestUnits < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Unit,
+    :time_name, :time_abbr, :temperature_name, :temperature_abbr
+  )
+
   def setup
     @tester = FFaker::Unit
     @time_units = @tester::TIME_UNITS.map { |u| OpenStruct.new u }

data/test/test_units_english.rb

@@ -4,6 +4,15 @@ require 'helper'
 
 # Author: lurraca github.com/lurraca
 class TestUnitsEnglish < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::UnitEnglish,
+    :length_name, :length_abbr, :mass_name, :mass_abbr,
+    :liquid_name, :liquid_abbr, :volume_name, :volume_abbr,
+    :area_name, :area_abbr
+  )
+
   def setup
     @tester = FFaker::UnitEnglish
     @length_units = @tester::LENGTH_UNITS.map { |u| OpenStruct.new u }