ffaker 2.12.0 → 2.17.0

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 = Array('1900'..(::Time.now.year + 1).to_s).freeze
     TRANSMISSIONS_ABBR = %w[AT MT AM CVT].freeze
     CYLINDERS = %w[2 5 6 8].freeze
 

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FFaker
+  VERSION = '2.17.0'
+end

data/scripts/benchmark.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
-require 'rubygems'
 require 'benchmark'
 
-N = 10_000
+NAMES_COUNT = 10_000
 
 def run(name)
-  require name
   Benchmark.bm do |rep|
-    rep.report("generating #{N} names (#{name} #{FFaker::VERSION})") do
-      N.times do
-        FFaker::Name.name
-      end
+    rep.report("generating #{NAMES_COUNT} names (#{name})") do
+      mod = name == 'ffaker' ? FFaker : Faker
+      NAMES_COUNT.times { mod::Name.name }
     end
   end
-  $stdout.flush
-  exit(0)
 end
 
-fork { run('faker') }; Process.wait
-fork { run('ffaker') }; Process.wait
+%w[faker ffaker].each do |gem_name|
+  require gem_name
+
+  fork { run(gem_name) }
+  Process.wait
+end

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_au.rb

@@ -33,7 +33,7 @@ class TestAddressAU < Test::Unit::TestCase
   end
 
   def test_full_address
-    assert_match(/[\, a-z]/, FFaker::AddressAU.full_address)
+    assert_match(/[, a-z]/, FFaker::AddressAU.full_address)
   end
 
   def test_au_suburb_with_states
@@ -60,7 +60,7 @@ class TestAddressAU < Test::Unit::TestCase
 
   def test_full_address_with_states
     FFaker::AddressAU::STATE_ABBR.each do |st_abbr|
-      assert_match(/[\, a-z]/, FFaker::AddressAU.full_address(st_abbr))
+      assert_match(/[, a-z]/, FFaker::AddressAU.full_address(st_abbr))
       assert_deterministic { FFaker::AddressAU.full_address(st_abbr) }
     end
   end

data/test/test_address_br.rb

@@ -32,6 +32,6 @@ class TestAddressBR < Test::Unit::TestCase
 
   def test_street
     prefixes = FFaker::AddressBR::STREET_PREFIX
-    assert_match(/(#{prefixes.join('|')})( [\p{Alpha}]+){1,2}/, FFaker::AddressBR.street)
+    assert_match(/(#{prefixes.join('|')})( \p{Alpha}+){1,2}/, FFaker::AddressBR.street)
   end
 end

data/test/test_address_fi.rb

@@ -5,7 +5,7 @@ require 'helper'
 class TestAddressFI < Test::Unit::TestCase
   include DeterministicHelper
 
-  ALPHA = /\A[\p{Alpha}]+/.freeze
+  ALPHA = /\A\p{Alpha}+/.freeze
   DIGIT = /\d{1}/.freeze
 
   assert_methods_are_deterministic(
@@ -30,7 +30,7 @@ class TestAddressFI < Test::Unit::TestCase
     assert_match(ALPHA, address)
     assert_match(DIGIT, address)
     assert_match(/SUOMI/, address)
-    assert_match(/[\, a-z]/, address)
+    assert_match(/[, a-z]/, address)
   end
 
   def test_fi_zip_code_frozen

data/test/test_address_fr.rb

@@ -7,6 +7,6 @@ class TestAddressFR < Test::Unit::TestCase
 
   assert_methods_are_deterministic(
     FFaker::AddressFR,
-    :city, :full_address, :street_name, :postal_code
+    :city, :full_address, :street_name, :postal_code, :region
   )
 end

data/test/test_address_id.rb

@@ -33,7 +33,7 @@ class TestAddressID < Test::Unit::TestCase
   def test_street
     prefixes = FFaker::AddressID::STREET_PREFIX
     common_street_names = FFaker::AddressID::COMMON_STREET_NAMES
-    regex = /\A(#{prefixes.join('|')})\.(\s(#{common_street_names.join('|')}))\,\sNo\.\s\d+\z/
+    regex = /\A(#{prefixes.join('|')})\.(\s(#{common_street_names.join('|')})),\sNo\.\s\d+\z/
     assert_match(regex, FFaker::AddressID.street)
   end
 end

data/test/test_address_ja.rb

@@ -13,7 +13,7 @@ class TestAddressJA < Test::Unit::TestCase
   )
 
   def test_postal_code
-    assert_match(/^\d{3}\-\d{4}$/, FFaker::AddressJA.postal_code)
+    assert_match(/^\d{3}-\d{4}$/, FFaker::AddressJA.postal_code)
   end
 
   def test_land_number

data/test/test_address_nl.rb

@@ -23,7 +23,7 @@ class TestAddressNL < Test::Unit::TestCase
   end
 
   def test_zip_code
-    assert_match(/^\d{4}\s\w{2}$/, @tester.zip_code)
+    assert_match(/\A[1-9]\d{3} [A-RT-Z][A-Z]\z/, @tester.zip_code)
   end
 
   def test_street_name

data/test/test_address_se.rb

@@ -5,7 +5,7 @@ require 'helper'
 class TestAddressSE < Test::Unit::TestCase
   include DeterministicHelper
 
-  ALPHA = /\A[\p{Alpha}]+/.freeze
+  ALPHA = /\A\p{Alpha}+/.freeze
   DIGIT = /\d{1}/.freeze
 
   assert_methods_are_deterministic(
@@ -30,7 +30,7 @@ class TestAddressSE < Test::Unit::TestCase
     assert_match(ALPHA, address)
     assert_match(DIGIT, address)
     assert_match(/SVERIGE/, address)
-    assert_match(/[\, a-z]/, address)
+    assert_match(/[, a-z]/, address)
   end
 
   def test_se_zip_code_frozen

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_animal_es.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestAnimalsES < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AnimalES, :common_name)
+
+  def setup
+    @tester = FFaker::AnimalES
+  end
+
+  def test_name
+    assert_include @tester::COMMON_NAMES, @tester.common_name
+  end
+end

data/test/test_array_utils.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'helper'
-require 'set'
 
 class TestArrayUtils < Test::Unit::TestCase
   include DeterministicHelper

data/test/test_aws.rb

@@ -20,6 +20,6 @@ class TestAWS < Test::Unit::TestCase
   end
 
   def test_product_description
-    assert_match(%r{\A[ \/a-zA-Z\(\)]+\z}i, FFaker::AWS.product_description)
+    assert_match(%r{\A[ /a-zA-Z()]+\z}i, FFaker::AWS.product_description)
   end
 end

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_book.rb

@@ -19,7 +19,7 @@ class TestBook < Test::Unit::TestCase
   end
 
   def test_genre
-    assert_match(%r{[\w\s'\/]+}, @tester.genre)
+    assert_match(%r{[\w\s'/]+}, @tester.genre)
   end
 
   def test_author
@@ -27,7 +27,7 @@ class TestBook < Test::Unit::TestCase
   end
 
   def test_isbn
-    assert_match(/[\d]+/, @tester.isbn)
+    assert_match(/\d+/, @tester.isbn)
   end
 
   def test_description
@@ -35,12 +35,12 @@ class TestBook < Test::Unit::TestCase
   end
 
   def test_cover
-    assert_match(%r{\Ahttps:\/\/robohash\.org\/.+\.png\?size=300x300\z},
+    assert_match(%r{\Ahttps://robohash\.org/.+\.png\?size=300x300\z},
                  @tester.cover)
   end
 
   def test_orly_cover
-    assert_match(%r{\Ahttps:\/\/orly-appstore\.herokuapp\.com\/generate},
+    assert_match(%r{\Ahttps://orly-appstore\.herokuapp\.com/generate},
                  @tester.orly_cover)
   end
 end

data/test/test_code.rb

@@ -5,7 +5,28 @@ require 'helper'
 class TestCode < Test::Unit::TestCase
   include DeterministicHelper
 
-  assert_methods_are_deterministic(FFaker::Code, :ean)
+  assert_methods_are_deterministic(FFaker::Code, :ean, :npi)
+
+  def test_npi_legacy_regexp
+    assert FFaker::Code.npi(legacy: true).match(/\A(1|2)[0-9]{9}\z/)
+  end
+
+  def test_npi
+    FFaker::Random.seed = 523_456_789
+    assert FFaker::Code.npi == '7411850515'
+  end
+
+  def test_deterministic_npi
+    FFaker::Random.seed = 42
+    v = FFaker::Code.npi
+    FFaker::Random.reset!
+    assert v == FFaker::Code.npi
+  end
+
+  def test_valid_npi
+    FFaker::Random.seed = 123_456_789
+    assert FFaker::Code.npi == '2410167607'
+  end
 
   def test_ean
     assert FFaker::Code.ean.match(/^\d{13}$/)

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_company_ja.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+class TestCompanyJA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::CompanyJA,
+    :name, :position
+  )
+
+  def setup
+    @tester = FFaker::CompanyJA
+  end
+
+  def test_name
+    assert_match(japanese_regex(''), @tester.name)
+  end
+
+  def test_position
+    assert_match(japanese_regex(''), @tester.position)
+  end
+
+  def japanese_regex(word)
+    /\A(?:\p{Hiragana}|\p{Katakana}|[ー－]|[一-龠々])+#{word}\z/
+  end
+end

data/test/{test_faker.rb → test_ffaker.rb}

@@ -2,9 +2,13 @@
 
 require 'helper'
 
-class TestFaker < Test::Unit::TestCase
+class TestFFaker < Test::Unit::TestCase
   include DeterministicHelper
 
+  def test_version
+    assert FFaker::VERSION.is_a?(String)
+  end
+
   def test_numerify
     assert FFaker.numerify('###').match(/\d{3}/)
     assert_deterministic { FFaker.numerify('###') }

data/test/test_filesystem.rb

@@ -15,14 +15,22 @@ class TestFakerFilesystem < Test::Unit::TestCase
   end
 
   def test_extension
-    assert @tester.extension.match(/(flac|mp3|wav|bmp|gif|jpeg|jpg|png|tiff|css|csv|html|js|json|txt|mp4|avi|mov|webm|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odp|pages|numbers|key|pdf)/)
+    assert_match /\A(?:flac|mp3|wav|bmp|gif|jpeg|jpg|png|tiff|css|csv|html|js|
+                     json|txt|mp4|avi|mov|webm|doc|docx|xls|xlsx|ppt|pptx|odt|
+                     ods|odp|pages|numbers|key|pdf)\z/x,
+                 @tester.extension
   end
 
   def test_mime_type_format
-    assert @tester.mime_type.match(%r{(.*)/(.*)+})
+    assert_match %r{\A\w+/.+\z}, @tester.mime_type
+  end
+
+  def test_directory
+    assert_match %r{\A(?:[a-z_-]+[\\/])+[a-z_-]+\z}, @tester.directory
   end
 
   def test_file_name
-    assert @tester.file_name.match(%r{([a-z\-_]+)(\\|/)([a-z\-_]+)\.([a-z]+)})
+    assert_match %r{\A(?:[a-z_-]+[\\/])+[a-z_-]+\.\w{2,4}\z},
+      @tester.file_name
   end
 end