ffaker 2.10.0 → 2.23.0

data/test/test_phone_number_sg.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestPhoneNumberSG < Test::Unit::TestCase
   include DeterministicHelper
@@ -17,36 +17,36 @@ class TestPhoneNumberSG < Test::Unit::TestCase
   end
 
   def test_voip_number
-    assert_match(/3\d{3}\s\d{4}/, @tester.voip_number)
+    assert_match(/\A3\d{3}\s\d{4}\z/, @tester.voip_number)
   end
 
   def test_fixed_line_number
-    assert_match(/6\d{3}\s\d{4}/, @tester.fixed_line_number)
+    assert_match(/\A6\d{3}\s\d{4}\z/, @tester.fixed_line_number)
   end
 
   def test_mobile_number
-    assert_match(/8\d{3}\s\d{4}/, @tester.mobile_number)
+    assert_match(/\A8\d{3}\s\d{4}\z/, @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(/\A9\d{3}\s\d{4}\z/, @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(/\A800\s\d{3}\s\d{4}\z/, @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(/\A1800\s\d{3}\s\d{4}\z/, @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(/\A1900\s\d{3}\s\d{4}\z/, @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(/\A[689]\d{3}\s\d{4}\z/, @tester.phone_number)
     end
   end
 end

data/test/test_phone_number_sn.rb

@@ -1,8 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
-# Author: xarala<pathe.sene@xarala.sn> http://www.xarala.sn
 class TestPhoneNumberSN < Test::Unit::TestCase
   include DeterministicHelper
 
@@ -17,11 +16,11 @@ class TestPhoneNumberSN < Test::Unit::TestCase
   end
 
   def test_mobile_phone_prefix
-    assert FFaker::PhoneNumberSN::MobileOperatorsPrefix.include?(@tester.mobile_phone_prefix)
+    assert FFaker::PhoneNumberSN::MOBILE_OPERATORS_PREFIX.include?(@tester.mobile_phone_prefix)
   end
 
   def test_homework_phone_prefix
-    assert FFaker::PhoneNumberSN::HomeWorkOperatorsPrefix.include?(@tester.homework_phone_prefix)
+    assert FFaker::PhoneNumberSN::HOME_WORK_OPERATORS_PREFIX.include?(@tester.homework_phone_prefix)
   end
 
   def test_short_phone_number

data/test/test_phone_number_tw.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberTW < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::PhoneNumberTW,
+    :mobile_phone_number, :home_work_phone_number, :phone_number,
+    :international_mobile_phone_number, :international_home_work_phone_number,
+    :international_phone_number
+  )
+
+  def setup
+    @tester = FFaker::PhoneNumberTW
+  end
+
+  def test_mobile_phone_number
+    assert_match(/09\d{2}-\d{3}-\d{3}/, @tester.mobile_phone_number)
+  end
+
+  def test_home_work_phone_number
+    assert_match(/\(0\d\) \d{3,4}-\d{4}/, @tester.home_work_phone_number)
+  end
+
+  def test_phone_number
+    10.times do
+      assert_match(/\(*0\d{1,3}\)*[\s-]\d{3,4}-\d{3,4}/, @tester.phone_number)
+    end
+  end
+
+  def test_international_mobile_phone_number
+    assert_match(/\+886-9\d{2}-\d{3}-\d{3}/,
+                 @tester.international_mobile_phone_number)
+  end
+
+  def test_international_home_work_phone_number
+    assert_match(/\+886-\d{1}-\d{3,4}-\d{4}/,
+                 @tester.international_home_work_phone_number)
+  end
+end

data/test/test_phone_number_ua.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::PhoneNumberUA,
+    :phone_number, :home_phone_number, :mobile_phone_number,
+    :international_home_phone_number, :international_mobile_phone_number
+  )
+
+  def setup
+    @tester = FFaker::PhoneNumberUA
+  end
+
+  def test_phone_number
+    assert_match(/^(\+(380)\s|0)[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.phone_number)
+  end
+
+  def test_home_phone_number
+    assert_match(/^0{1}[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.home_phone_number)
+  end
+
+  def test_mobile_phone_number
+    assert_match(/^0{1}[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.mobile_phone_number)
+  end
+
+  def test_international_home_phone_number
+    assert_match(/^\+(380)\s[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.international_home_phone_number)
+  end
+
+  def international_mobile_phone_number
+    assert_match(/^\+(380)\s[0-9]{2}\s[0-9]{3}-[0-9]{4}$/,
+                 @tester.international_mobile_phone_number)
+  end
+end

data/test/test_products.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestProducts < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_sem_ver.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSemVer < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::SemVer, :next)
+
+  def setup
+    @tester = FFaker::SemVer
+  end
+
+  def test_next
+    assert_includes(%w[0.0.1 0.1.0 1.0.0], @tester.next)
+    assert_includes(%w[2.0.0 1.3.0 1.2.4], @tester.next('1.2.3'))
+  end
+end

data/test/test_skill.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestSkill < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_sport_pl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSportPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::SportPL,
+    :name,
+    :summer,
+    :winter
+  )
+
+  def setup
+    @tester = FFaker::SportPL
+  end
+
+  def test_name
+    assert_include(@tester::ALL, @tester.name)
+  end
+
+  def test_summer
+    assert_include(@tester::SUMMER, @tester.summer)
+  end
+
+  def test_winter
+    assert_include(@tester::WINTER, @tester.winter)
+  end
+end

data/test/test_sport_ru.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSportRU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::SportRU,
+    :name,
+    :summer,
+    :winter
+  )
+
+  def setup
+    @tester = FFaker::SportRU
+  end
+
+  def test_name
+    assert_include(@tester::ALL, @tester.name)
+  end
+
+  def test_summer
+    assert_include(@tester::SUMMER, @tester.summer)
+  end
+
+  def test_winter
+    assert_include(@tester::WINTER, @tester.winter)
+  end
+end

data/test/test_sport_us.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSportUS < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::SportUS, :name)
+
+  def setup
+    @tester = FFaker::SportUS
+  end
+
+  def test_name
+    assert_include @tester::NAMES, @tester.name
+  end
+end

data/test/test_sports.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestSports < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_ssn.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestSSN < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_ssn_mx.rb

@@ -1,8 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
-# Author Guapolo <github.com/guapolo>
 class TestSSNMX < Test::Unit::TestCase
   include DeterministicHelper
 

data/test/test_ssn_se.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestSSNSE < Test::Unit::TestCase
   include DeterministicHelper
@@ -12,16 +12,16 @@ class TestSSNSE < Test::Unit::TestCase
     assert_match(/(19|20)\d{10}/, ssn, "With no arguments year should start with 19 or 20, #{ssn}")
   end
 
-  def is_equal?(nbr)
-    nbr % 2
+  def equal?(other)
+    other % 2
   end
 
   def test_ssn_with_gender
     ssn_male = FFaker::SSNSE.ssn(gender: :male)
-    assert is_equal?(ssn_male[10].to_i)
+    assert equal?(ssn_male[10].to_i)
 
     ssn_female = FFaker::SSNSE.ssn(gender: :female)
-    assert is_equal?(ssn_female[10].to_i)
+    assert equal?(ssn_female[10].to_i)
 
     assert_raise ArgumentError do
       FFaker::SSNSE.ssn(gender: :unkown)
@@ -29,17 +29,15 @@ class TestSSNSE < Test::Unit::TestCase
   end
 
   def test_ssn_with_from_to
-    10.times do
-      from = Time.local(1980, 2, 28)
-      to = Time.local(2000, 2, 28)
+    from = Time.local(1980, 2, 28)
+    to = Time.local(2000, 2, 28)
 
+    assert_random_between(from...to) do
       ssn = FFaker::SSNSE.ssn(from: from, to: to)
       year = ssn[0..3].to_i
       month = ssn[4..5].to_i
       day = ssn[6..7].to_i
-      ssn_birth_date = Time.local(year, month, day)
-      assert ssn_birth_date < to
-      assert ssn_birth_date >= from
+      Time.local(year, month, day)
     end
   end
 end

data/test/test_string.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestString < Test::Unit::TestCase
   include DeterministicHelper
@@ -30,11 +30,11 @@ class TestString < Test::Unit::TestCase
   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_match(/\A-\z/, FS.from_regexp(/-/))
 
     assert_deterministic { FS.from_regexp(/[a-z-]/) }
     assert_deterministic { FS.from_regexp(/[a-]/) }
-    assert_deterministic { FS.from_regexp(/[-]/) }
+    assert_deterministic { FS.from_regexp(/-/) }
   end
 
   def test_spaces
@@ -43,8 +43,8 @@ class TestString < Test::Unit::TestCase
   end
 
   def test_escaped_characters
-    assert_equal '\\/.()[]{}', FS.from_regexp(/\\\/\.\(\)\[\]\{\}/)
-    assert_deterministic { FS.from_regexp(%r|\\\/\.\(\)\[\]\{\}|) }
+    assert_equal '\\/.()[]{}', FS.from_regexp(%r{\\/\.\(\)\[\]\{\}})
+    assert_deterministic { FS.from_regexp(%r|\\/\.\(\)\[\]\{\}|) }
   end
 
   def test_atom_sets
@@ -53,8 +53,8 @@ class TestString < Test::Unit::TestCase
   end
 
   def test_special_sets
-    assert_match(/\A[\w\d]\z/, FS.from_regexp(/[\w\d]/))
-    assert_deterministic { FS.from_regexp(/[\w\d]/) }
+    assert_match(/\A[\s\d]\z/, FS.from_regexp(/[\s\d]/))
+    assert_deterministic { FS.from_regexp(/[\s\d]/) }
   end
 
   def test_atom_question

data/test/test_time.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 require 'date'
 
 class TestFakerTime < Test::Unit::TestCase
@@ -40,6 +40,17 @@ class TestFakerTime < Test::Unit::TestCase
     assert_deterministic { @tester.datetime(hours: 4, minutes: 20) }
   end
 
+  def test_datetime_year_range_and_year_latest
+    current_year = ::DateTime.now.year
+    [[0, 0], [1, 1], [2, 4], [8, 6]].each do |year_range, year_latest|
+      assert_random_between(
+        (current_year - year_range - year_latest)..(current_year - year_latest)
+      ) do
+        @tester.datetime(year_range: year_range, year_latest: year_latest).year
+      end
+    end
+  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)
@@ -49,12 +60,7 @@ class TestFakerTime < Test::Unit::TestCase
     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
+    assert_random_between(from..to) { @tester.between(from, to) }
   end
 
   def test_between_for_string

data/test/test_tweet.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestTweet < Test::Unit::TestCase
   include DeterministicHelper
@@ -20,40 +20,40 @@ class TestTweet < Test::Unit::TestCase
   end
 
   def test_mention
-    assert_match(/\@\S*/, FFaker::Tweet.mention)
+    assert_match(/@\S*/, FFaker::Tweet.mention)
   end
 
   def test_mentions_three
-    assert_match(/\@\S*\s\@\S*\s\@\S*/, FFaker::Tweet.mentions(3))
+    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)
+    assert_less_than_or_equal_to FFaker::Tweet.body.size, 140
   end
 
   def test_shortish_body
-    assert(FFaker::Tweet.body(20).size <= 20)
+    assert_less_than_or_equal_to FFaker::Tweet.body(20).size, 20
   end
 
   def test_short_body
-    assert(FFaker::Tweet.body(2).size.between?(2, 20))
+    assert_between(FFaker::Tweet.body(2).size, 2..20)
   end
 
   def test_tweet
-    100.times { assert(FFaker::Tweet.tweet.size <= 140) }
+    assert_random_less_than_or_equal_to(140) { FFaker::Tweet.tweet.size }
   end
 
   def test_tweet_with_reply
-    assert_match(/^\@/, FFaker::Tweet.tweet(reply: true))
+    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)
+    assert_less_than_or_equal_to FFaker::Tweet.tweet(body_length: 200).size, 140
   end
 
   def test_undersize_body_length
-    assert(FFaker::Tweet.tweet(body_length: 2).size <= 140)
+    assert_less_than_or_equal_to FFaker::Tweet.tweet(body_length: 2).size, 140
   end
 end

data/test/test_unique_utils.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
 
 class TestUniqueUtils < Test::Unit::TestCase
   def test_generates_unique_values
@@ -39,16 +39,40 @@ class TestUniqueUtils < Test::Unit::TestCase
       unique_object.test
     end
 
-    FFaker::UniqueUtils.clear
+    unique_object.clear
 
     assert_equal(1, unique_object.test)
+  end
 
-    assert_raises FFaker::UniqueUtils::RetryLimitExceeded do
-      unique_object.test
+  def test_clears_all_unique_values
+    stubbed_generator = Object.new
+    def stubbed_generator.test
+      1
+    end
+    other_stubbed_generator = Object.new
+    def other_stubbed_generator.test
+      1
     end
 
-    unique_object.clear
+    unique_object = FFaker::UniqueUtils.add_instance(stubbed_generator, 3)
+    other_unique_object = FFaker::UniqueUtils.add_instance(other_stubbed_generator, 3)
 
-    assert_equal(1, unique_object.test)
+    [unique_object, other_unique_object].each do |tested_unique_object|
+      assert_equal(1, tested_unique_object.test)
+
+      assert_raises FFaker::UniqueUtils::RetryLimitExceeded do
+        tested_unique_object.test
+      end
+    end
+
+    FFaker::UniqueUtils.clear
+
+    [unique_object, other_unique_object].each do |tested_unique_object|
+      assert_equal(1, tested_unique_object.test)
+    end
+  end
+
+  def test_generates_unique_numbers
+    assert_nothing_raised { FFaker::Number.unique.number(digits: 1) }
   end
 end

data/test/test_units.rb

@@ -1,8 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'helper'
+require_relative 'helper'
+require 'ostruct'
 
-# Author: lurraca github.com/lurraca
 class TestUnits < Test::Unit::TestCase
   include DeterministicHelper
 
@@ -13,25 +13,25 @@ class TestUnits < Test::Unit::TestCase
 
   def setup
     @tester = FFaker::Unit
-    @time_units = @tester::TIME_UNITS.map { |u| OpenStruct.new u }
-    @temperature_units = @tester::TEMPERATURE_UNITS.map { |u| OpenStruct.new u }
+    @time_units = @tester::TIME_UNITS
+    @temperature_units = @tester::TEMPERATURE_UNITS
   end
 
   def test_time_name
-    assert_include @time_units.map(&:name), @tester.time_name
+    assert_include @time_units.map { |unit| unit[:name] }, @tester.time_name
   end
 
   def test_time_abbr
-    assert_include @time_units.map(&:abbreviation), @tester.time_abbr
+    assert_include @time_units.map { |unit| unit[:abbreviation] }, @tester.time_abbr
   end
 
   def test_temperature_name
-    assert_include @temperature_units.map(&:name), @tester.temperature_name
+    assert_include @temperature_units.map { |unit| unit[:name] }, @tester.temperature_name
   end
 
   def test_temperature_abbr
     assert_include \
-      @temperature_units.map(&:abbreviation),
+      @temperature_units.map { |unit| unit[:abbreviation] },
       @tester.temperature_abbr
   end
 end