ffaker 2.12.0 → 2.13.0

data/lib/ffaker/utils/random_utils.rb

@@ -20,6 +20,8 @@ module FFaker
     def fetch_sample(list, options = {})
       if (count = options.delete(:count))
         list.sample(count, random: FFaker::Random)
+      elsif list.is_a?(Range)
+        FFaker::Random.rand(list)
       else
         list.sample(random: FFaker::Random)
       end

data/lib/ffaker/vehicle.rb

@@ -6,12 +6,7 @@ module FFaker
     extend self
 
     DRIVETRAINS = %w[4WD 4X4 AWD FWD RWD].freeze
-    YEARS = [*'1900'..(Date.today.year + 1).to_s].freeze
-    COLOR_PREFIXES = k(%w[
-                         beautiful bright calm dangerous dark dull fast magnetic magnificent
-                         majestic melodic metallic mundane mute mysterious new pleasant pretty
-                         resonant royal slate soft tranquil vibrant weak
-                       ])
+    YEARS = [*'1900'..(::Time.now.year + 1).to_s].freeze
     TRANSMISSIONS_ABBR = %w[AT MT AM CVT].freeze
     CYLINDERS = %w[2 5 6 8].freeze
 

data/test/helper.rb

@@ -28,6 +28,41 @@ module DeterministicHelper
     assert(returns.uniq.length == 1, options[:message])
   end
 
+  %w[< > <= >=].each do |operator|
+    operator_name =
+      case operator[0]
+      when '<' then 'less_than'
+      when '>' then 'greater_than'
+      else raise 'Unexpected operator'
+      end
+    operator_name += '_or_equal_to' if operator[1] == '='
+
+    define_method "assert_#{operator_name}" do |got, expected|
+      assert(
+        got.public_send(operator, expected),
+        "Expected #{operator} \"#{expected}\", but got #{got}"
+      )
+    end
+  end
+
+  def assert_between(got, from, to, exclude_end: false)
+    assert_greater_than_or_equal_to got, from
+    public_send "assert_less_than#{'_or_equal_to' unless exclude_end}", got, to
+  end
+
+  def assert_random(original_block, *args)
+    100.times do
+      yield(*args)
+      assert_deterministic(&original_block)
+    end
+  end
+
+  %w[less_than_or_equal_to between].each do |method_name|
+    define_method "assert_random_#{method_name}" do |*args, &block|
+      assert_random(block) { send "assert_#{method_name}", block.call, *args }
+    end
+  end
+
   # Methods to be called outside of individual examples.
   module ClassMethods
     # Shorthand method to quickly test the determinability of multiple methods.

data/test/test_address_us.rb

@@ -18,6 +18,15 @@ class TestAddressUSUS < Test::Unit::TestCase
 
   def test_us_state_abbr
     assert_match(/[A-Z]/, FFaker::AddressUS.state_abbr)
+    %w[California california CALIFORNIA].each do |state|
+      assert_match('CA', FFaker::AddressUS.state_abbr(state))
+    end
+    ['South Carolina', 'south carolina'].each do |state|
+      assert_match('SC', FFaker::AddressUS.state_abbr(state))
+    end
+    assert_raise ArgumentError, "Unexpected state: 'unknown'" do
+      FFaker::AddressUS.state_abbr('unknown')
+    end
   end
 
   def test_us_state_and_territories_abbr

data/test/test_bank.rb

@@ -5,14 +5,50 @@ require 'helper'
 class TestBank < Test::Unit::TestCase
   include DeterministicHelper
 
-  assert_methods_are_deterministic(FFaker::Bank, :iban)
+  assert_methods_are_deterministic(
+    FFaker::Bank,
+    :iban, :card_number, :card_expiry_date, :card_type
+  )
+
+  def setup
+    @tester = FFaker::Bank
+  end
 
   def test_iban
-    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, FFaker::Bank.iban)
-    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, FFaker::Bank.iban(country_code: 'by'))
-    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, FFaker::Bank.iban(country_code: 'BY'))
+    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, @tester.iban)
+    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, @tester.iban(country_code: 'by'))
+    assert_match(/[A-Z]{2}\d+([A-Z]+)?\d+/, @tester.iban(country_code: 'BY'))
     assert_raise ArgumentError, "Unexpected country code: 'unknown'" do
-      FFaker::Bank.iban(country_code: 'unknown')
+      @tester.iban(country_code: 'unknown')
     end
   end
+
+  def test_card_number
+    assert_match(/\A(\d{4} ){3}\d{4}\z/, @tester.card_number)
+  end
+
+  def test_card_expiry_date
+    assert_instance_of String, @tester.card_expiry_date
+
+    date_today = ::DateTime.now
+
+    assert_random_between(
+      date_today.strftime('%y'), date_today.next_year(5).strftime('%y')
+    ) do
+      @tester.card_expiry_date.split('/').pop
+    end
+
+    year_range = 4
+    year_latest = 8
+    assert_random_between(
+      date_today.prev_year(year_latest + year_range).strftime('%y'),
+      date_today.prev_year(year_latest).strftime('%y')
+    ) do
+      @tester.card_expiry_date(year_range: year_range, year_latest: year_latest).split('/').pop
+    end
+  end
+
+  def test_card_type
+    assert_include @tester::CARD_TYPES, @tester.card_type
+  end
 end

data/test/test_color_pl.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestColorPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::ColorPL, :name)
+
+  def test_name
+    assert_match(/\A[a-ząćęłńóśźżé]+\z/, FFaker::ColorPL.name)
+  end
+end

data/test/test_identification_co.rb

@@ -36,6 +36,6 @@ class TestFakerIdentificationESCO < Test::Unit::TestCase
   end
 
   def test_expedition_date
-    assert(Date.today >= @tester.expedition_date)
+    assert_less_than @tester.expedition_date, Date.today
   end
 end

data/test/test_identification_pl.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestFakerIdentificationPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::IdentificationPL,
+    :pesel, :identity_card, :drivers_license
+  )
+
+  def setup
+    @tester = FFaker::IdentificationPL
+  end
+
+  def test_pesel
+    assert_match(/\A\d{11}\z/, @tester.pesel)
+  end
+
+  def test_identity_card
+    assert_match(/\A[A-Z]{3}\d{6}\z/, @tester.identity_card)
+  end
+
+  def test_drivers_license
+    assert_match(%r{\A\d{5}/\d{2}/\d{4}\z}, @tester.drivers_license)
+  end
+end

data/test/test_internet.rb

@@ -93,15 +93,15 @@ class TestFakerInternet < Test::Unit::TestCase
   end
 
   def test_password_min_length
-    assert @tester.password(3).length > 2
-    assert @tester.password(6).length > 5
-    assert @tester.password(15).length > 14
+    assert_greater_than @tester.password(3).length, 2
+    assert_greater_than @tester.password(6).length, 5
+    assert_greater_than @tester.password(15).length, 14
   end
 
   def test_password_max_length
-    assert @tester.password(3, 10).length < 11
-    assert @tester.password(7, 15).length < 16
-    assert @tester.password(1, 3).length < 4
+    assert_less_than @tester.password(3, 10).length, 11
+    assert_less_than @tester.password(7, 15).length, 16
+    assert_less_than @tester.password(1, 3).length, 4
   end
 
   def test_password_fixed_length
@@ -109,9 +109,9 @@ class TestFakerInternet < Test::Unit::TestCase
   end
 
   def test_password_strange_argument
-    assert @tester.password(10, 2).length > 9
-    assert @tester.password(3, 1).length > 2
-    assert @tester.password(8, 5).length > 7
+    assert_greater_than @tester.password(10, 2).length, 9
+    assert_greater_than @tester.password(3, 1).length, 2
+    assert_greater_than @tester.password(8, 5).length, 7
   end
 
   def test_mac

data/test/test_job_cn.rb

@@ -12,7 +12,7 @@ class TestFakerJobCN < Test::Unit::TestCase
   end
 
   def test_title
-    assert @tester.title.length >= 1
+    assert_greater_than_or_equal_to @tester.title.length, 1
   end
 
   def test_nouns

data/test/test_job_ja.rb

@@ -12,7 +12,7 @@ class TestFakerJobJA < Test::Unit::TestCase
   end
 
   def test_title
-    assert @tester.title.length >= 1
+    assert_greater_than_or_equal_to @tester.title.length, 1
   end
 
   def test_nouns

data/test/test_job_kr.rb

@@ -12,7 +12,7 @@ class TestFakerJobKR < Test::Unit::TestCase
   end
 
   def test_title
-    assert @tester.title.length >= 1
+    assert_greater_than_or_equal_to @tester.title.length, 1
   end
 
   def test_nouns

data/test/test_job_vn.rb

@@ -12,7 +12,7 @@ class TestFakerJobVN < Test::Unit::TestCase
   end
 
   def test_title
-    assert @tester.title.length >= 1
+    assert_greater_than_or_equal_to @tester.title.length, 1
   end
 
   def test_nouns

data/test/test_lorem_cn.rb

@@ -11,15 +11,15 @@ class TestLoremCN < Test::Unit::TestCase
   )
 
   def test_paragraph
-    assert FFaker::LoremCN.paragraph.length >= 3 * 4 * 2
+    assert_greater_than_or_equal_to FFaker::LoremCN.paragraph.length, 3 * 4 * 2
   end
 
   def test_sentence
-    assert FFaker::LoremCN.sentence.length >= 4 * 2
+    assert_greater_than_or_equal_to FFaker::LoremCN.sentence.length, 4 * 2
   end
 
   def test_paragraphs
-    assert FFaker::LoremCN.paragraphs.length >= 2
+    assert_greater_than_or_equal_to FFaker::LoremCN.paragraphs.length, 2
   end
 
   def test_paragraphs_is_not_a_string_representation_of_an_array
@@ -31,7 +31,7 @@ class TestLoremCN < Test::Unit::TestCase
   end
 
   def test_sentences
-    assert FFaker::LoremCN.sentences.length >= 2
+    assert_greater_than_or_equal_to FFaker::LoremCN.sentences.length, 2
   end
 
   def test_sentences_is_an_array
@@ -45,10 +45,10 @@ class TestLoremCN < Test::Unit::TestCase
   end
 
   def test_words
-    assert FFaker::LoremCN.words.length >= 2
+    assert_greater_than_or_equal_to FFaker::LoremCN.words.length, 2
   end
 
   def test_word
-    assert FFaker::LoremCN.word.length >= 1
+    assert_greater_than_or_equal_to FFaker::LoremCN.word.length, 1
   end
 end

data/test/test_lorem_ja.rb

@@ -33,7 +33,7 @@ class TestLoremJA < Test::Unit::TestCase
   end
 
   def test_word
-    assert @subject.word.length >= 1
+    assert_greater_than_or_equal_to @subject.word.length, 1
     assert_kind_of String, @subject.word
   end
 
@@ -48,7 +48,7 @@ class TestLoremJA < Test::Unit::TestCase
   end
 
   def test_sentence
-    assert @subject.sentence.length >= 1
+    assert_greater_than_or_equal_to @subject.sentence.length, 1
   end
 
   def test_sentences
@@ -62,7 +62,7 @@ class TestLoremJA < Test::Unit::TestCase
   end
 
   def test_paragraph
-    assert @subject.paragraph.length >= 1
+    assert_greater_than_or_equal_to @subject.paragraph.length, 1
   end
 
   def test_paragraphs

data/test/test_name_da.rb

@@ -23,18 +23,18 @@ class TestFakerNameDA < Test::Unit::TestCase
   end
 
   def test_any_name
-    assert @tester.any_name.count(' ') < 3
+    assert_less_than @tester.any_name.count(' '), 3
   end
 
   def test_male_name
     regexp = /#{@tester::MALE_FIRST_NAMES.join('|')}/
-    assert @tester.male_name.count(' ') < 3
+    assert_less_than @tester.male_name.count(' '), 3
     assert_match(regexp, @tester.male_name)
   end
 
   def test_female_name
     regexp = /#{@tester::FEMALE_FIRST_NAMES.join('|')}/
-    assert @tester.female_name.count(' ') < 3
+    assert_less_than @tester.female_name.count(' '), 3
     assert_match(regexp, @tester.female_name)
   end
 

data/test/test_phone_number_se.rb

@@ -33,13 +33,13 @@ class TestPhoneNumberSE < Test::Unit::TestCase
   def test_mobile_phone_number
     assert_match(ALLOWED_CHARS, FFaker::PhoneNumberSE.mobile_phone_number)
     assert_match(/\d{3}/, FFaker::PhoneNumberSE.mobile_phone_number)
-    assert FFaker::PhoneNumberSE.mobile_phone_number.length > 9
+    assert_greater_than FFaker::PhoneNumberSE.mobile_phone_number.length, 9
   end
 
   def test_home_work_phone_number
     assert_match(ALLOWED_CHARS, FFaker::PhoneNumberSE.home_work_phone_number)
     assert_match(/\d{1} \d{2}/, FFaker::PhoneNumberSE.home_work_phone_number)
-    assert FFaker::PhoneNumberSE.mobile_phone_number.length > 9
+    assert_greater_than FFaker::PhoneNumberSE.mobile_phone_number.length, 9
   end
 
   def test_phone_number

data/test/test_sport_pl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require '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_ssn_se.rb

@@ -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, exclude_end: true) 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_time.rb

@@ -40,6 +40,18 @@ 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 +61,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