ffaker 2.20.0 → 2.25.0

data/test/test_lorem_fr.rb

@@ -10,9 +10,9 @@ class TestLoremFR < Test::Unit::TestCase
     :paragraph, :paragraphs, :sentence, :sentences, :phrase, :phrases, :word, :words
   )
 
-  REGEX = /\A[ -.ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
-  REGEX_WORD = /\A[-ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
-  REGEX_WORDS = /\A[ -ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i.freeze
+  REGEX = /\A[ -.ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i
+  REGEX_WORD = /\A[-ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i
+  REGEX_WORDS = /\A[ -ÀÂÉÈÊÎÔÚÛàâéèêîôùûa-z]+\z/i
 
   def test_paragraph
     assert_match(REGEX, FFaker::LoremFR.paragraph)

data/test/test_lorem_ie.rb

@@ -11,8 +11,8 @@ class TestLoremIE < Test::Unit::TestCase
     :phrase, :phrases, :word, :words, :question
   )
 
-  WORDS_REGEX = /\A[\w\W]+\z/i.freeze # spaces, alphanumeric & perioids, etc.
-  WORD_REGEX = /\A[áéíóúa-z]+\z/i.freeze
+  WORDS_REGEX = /\A[\w\W]+\z/i # spaces, alphanumeric & perioids, etc.
+  WORD_REGEX = /\A[áéíóúa-z]+\z/i
 
   def test_paragraph
     assert_match(WORDS_REGEX, FFaker::LoremIE.paragraph)

data/test/test_lorem_kr.rb

@@ -5,9 +5,9 @@ require_relative 'helper'
 class TestLoremKR < Test::Unit::TestCase
   include DeterministicHelper
 
-  KOREAN_SENTENCE_MATCHER = /\A[ .가-힣]+\z/.freeze
-  KOREAN_WORDS_MATCHER = /\A[ 가-힣]+\z/.freeze
-  KOREAN_WORD_MATCHER = /\A[가-힣]+\z/.freeze
+  KOREAN_SENTENCE_MATCHER = /\A[ .가-힣]+\z/
+  KOREAN_WORDS_MATCHER = /\A[ 가-힣]+\z/
+  KOREAN_WORD_MATCHER = /\A[가-힣]+\z/
 
   assert_methods_are_deterministic(
     FFaker::LoremKR,

data/test/test_lorem_pl.rb

@@ -5,8 +5,8 @@ require_relative 'helper'
 class TestFakerLoremPL < Test::Unit::TestCase
   include DeterministicHelper
 
-  POLISH_WORD_MATCHER = /\A[A-Ża-ż\s]+\z/.freeze
-  POLISH_SENTENCE_MATCHER = /\A[A-Ża-ż\s.!?,]+\z/.freeze
+  POLISH_WORD_MATCHER = /\A[A-Ża-ż\s]+\z/
+  POLISH_SENTENCE_MATCHER = /\A[A-Ża-ż\s.!?,]+\z/
 
   assert_methods_are_deterministic(
     FFaker::LoremPL,

data/test/test_lorem_ru.rb

@@ -5,9 +5,9 @@ require_relative 'helper'
 class TestLoremRU < Test::Unit::TestCase
   include DeterministicHelper
 
-  SENTENCE_MATCHER = /\A[а-яА-ЯёЁ\-\s.!?,]+\z/.freeze
-  WORDS_MATCHER    = /\A[А-Яа-яёЁ\-\s]+\z/.freeze
-  WORD_MATCHER     = /\A[А-Яа-яёЁ\-]+\z/.freeze
+  SENTENCE_MATCHER = /\A[а-яА-ЯёЁ\-\s.!?,]+\z/
+  WORDS_MATCHER    = /\A[А-Яа-яёЁ\-\s]+\z/
+  WORD_MATCHER     = /\A[А-Яа-яёЁ-]+\z/
 
   assert_methods_are_deterministic(
     FFaker::LoremRU,

data/test/test_lorem_tw.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestLoremTW < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::LoremTW,
+    :paragraph, :paragraphs, :sentence, :sentences, :word, :words
+  )
+
+  def test_paragraph
+    assert_greater_than_or_equal_to FFaker::LoremTW.paragraph.length, 3 * 4 * 2
+  end
+
+  def test_sentence
+    assert_greater_than_or_equal_to FFaker::LoremTW.sentence.length, 4 * 2
+  end
+
+  def test_paragraphs
+    assert_greater_than_or_equal_to FFaker::LoremTW.paragraphs.length, 2
+  end
+
+  def test_paragraphs_is_not_a_string_representation_of_an_array
+    assert !/[\[\]]+/.match([FFaker::LoremTW.paragraphs].flatten.join(' '))
+  end
+
+  def test_paragraphs_is_an_array
+    assert FFaker::LoremTW.paragraphs.instance_of?(Array)
+  end
+
+  def test_sentences
+    assert_greater_than_or_equal_to FFaker::LoremTW.sentences.length, 2
+  end
+
+  def test_sentences_is_an_array
+    assert FFaker::LoremTW.sentences.instance_of?(Array)
+  end
+
+  def test_sentences_via_to_s_produces_string_terminated_with_period
+    string = FFaker::LoremTW.sentences.to_s
+    assert string.instance_of?(String)
+    assert string =~ /。$/
+  end
+
+  def test_words
+    assert_greater_than_or_equal_to FFaker::LoremTW.words.length, 2
+  end
+
+  def test_word
+    assert_greater_than_or_equal_to FFaker::LoremTW.word.length, 1
+  end
+end

data/test/test_lorem_ua.rb

@@ -5,9 +5,9 @@ require_relative 'helper'
 class TestLoremUA < Test::Unit::TestCase
   include DeterministicHelper
 
-  SENTENCE_MATCHER = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s.!?,]+\z/.freeze
-  WORDS_MATCHER    = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/.freeze
-  WORD_MATCHER     = /\A[а-яА-ЯіїєґІЇЄҐ’\-]+\z/.freeze
+  SENTENCE_MATCHER = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s.!?,]+\z/
+  WORDS_MATCHER    = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/
+  WORD_MATCHER     = /\A[а-яА-ЯіїєґІЇЄҐ’-]+\z/
 
   assert_methods_are_deterministic(
     FFaker::LoremUA,

data/test/test_module_utils.rb

@@ -11,4 +11,46 @@ class TestModuleUtils < Test::Unit::TestCase
     assert result.frozen?
     result.each { |e| assert e.frozen? }
   end
+
+  def test_unique
+    generator = Object.new
+    generator.extend FFaker::ModuleUtils
+    # returns [1 1 2 2 1 1 2 2 ..][call_index]
+    def generator.test
+      index = Thread.current[:test_unique] ||= 0
+      Thread.current[:test_unique] = (index > 2 ? 0 : index + 1)
+      (index / 2) + 1
+    end
+
+    assert_equal(1, generator.unique.test)
+    assert_equal(2, generator.unique.test)
+
+    Thread.new do
+      assert_equal(1, generator.unique.test)
+      assert_equal(2, generator.unique.test)
+
+      assert_raises FFaker::UniqueUtils::RetryLimitExceeded do
+        generator.unique.test
+      end
+
+      generator.unique.clear
+      generator.unique.test
+    end.join
+
+    assert_raises FFaker::UniqueUtils::RetryLimitExceeded do
+      generator.unique.test
+    end
+
+    FFaker::UniqueUtils.clear
+    generator.unique.test
+  end
+
+  def test_luhn_check
+    obj = Object.new
+    obj.extend FFaker::ModuleUtils
+    assert obj.luhn_check('97248708') == '6'
+    assert obj.luhn_check('1789372997') == '4'
+    assert obj.luhn_check('8899982700037') == '1'
+    assert obj.luhn_check('1234567820001') == '0'
+  end
 end

data/test/test_music.rb

@@ -11,18 +11,18 @@ class TestMusic < Test::Unit::TestCase
   )
 
   def test_genre
-    assert_match(%r{[A-z]|\W|&/+}, FFaker::Music.genre)
+    assert_match(%r{[A-Za-z]|\W|&/+}, FFaker::Music.genre)
   end
 
   def test_album
-    assert_match(/\s|[A-z]|\W|\d|'|\?+/, FFaker::Music.album)
+    assert_match(/\s|[A-Za-z]|\W|\d|'|\?+/, FFaker::Music.album)
   end
 
   def test_artist
-    assert_match(/\s|[A-z]|\W|\d|'|\?|&|\+|\.|-+/, FFaker::Music.artist)
+    assert_match(/\s|[A-Za-z]|\W|\d|'|\?|&|\+|\.|-+/, FFaker::Music.artist)
   end
 
   def test_song
-    assert_match(/\s|[A-z]|\W|\d|'|\?|&|\+|\.|-+/, FFaker::Music.song)
+    assert_match(/\s|[A-Za-z]|\W|\d|'|\?|&|\+|\.|-+/, FFaker::Music.song)
   end
 end

data/test/test_name_da.rb

@@ -10,7 +10,7 @@ class TestFakerNameDA < Test::Unit::TestCase
     :any_name, :male_name, :female_name, :last_name, :prefix
   )
 
-  RU_REGEX = /[А-Я][а-я]+/.freeze
+  RU_REGEX = /[А-Я][а-я]+/
 
   def setup
     @tester = FFaker::NameDA

data/test/test_name_ph.rb

@@ -5,7 +5,7 @@ require_relative 'helper'
 class TestFakerNamePH < Test::Unit::TestCase
   include DeterministicHelper
 
-  PH_REGEXP = /\A([\wñÑú-]+\.? ?){2,5}\z/.freeze
+  PH_REGEXP = /\A([\wñÑú-]+\.? ?){2,5}\z/
 
   assert_methods_are_deterministic(
     FFaker::NamePH,

data/test/test_name_ru.rb

@@ -5,8 +5,8 @@ require_relative 'helper'
 class TestNameRU < Test::Unit::TestCase
   include DeterministicHelper
 
-  RU_REGEX = /\A[а-яА-Я]{2,}\z/.freeze
-  RU_REGEX_MULTIPLE_WORDS = /\A[а-яА-Я\s]+\z/.freeze
+  RU_REGEX = /\A[а-яА-Я]{2,}\z/
+  RU_REGEX_MULTIPLE_WORDS = /\A[а-яА-Я\s]+\z/
 
   assert_methods_are_deterministic(
     FFaker::NameRU,

data/test/test_name_ua.rb

@@ -15,8 +15,8 @@ class TestNameUA < Test::Unit::TestCase
   def setup
     @tester = FFaker::NameUA
 
-    @single_word_name_regexp    = /\A[а-яА-ЯіїєґІЇЄҐ’\-]+\z/.freeze
-    @multiple_words_name_regexp = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/.freeze
+    @single_word_name_regexp    = /\A[а-яА-ЯіїєґІЇЄҐ’-]+\z/
+    @multiple_words_name_regexp = /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/
   end
 
   def test_first_name_male

data/test/test_number.rb

@@ -5,7 +5,7 @@ require_relative 'helper'
 class TestNumber < Test::Unit::TestCase
   include DeterministicHelper
 
-  assert_methods_are_deterministic(FFaker::Number, :number, :decimal)
+  assert_methods_are_deterministic(FFaker::Number, :number, :decimal, :between)
 
   def setup
     @tester = FFaker::Number
@@ -13,7 +13,7 @@ class TestNumber < Test::Unit::TestCase
 
   def test_number
     assert @tester.number.is_a?(Integer)
-    assert @tester.number.digits.count == 1
+    assert @tester.number.digits.one?
     assert @tester.number(digits: 3).digits.count == 3
     assert_match(/\d/, @tester.number.to_s)
     assert_match(/\d{3}/, @tester.number(digits: 3).to_s)
@@ -42,4 +42,16 @@ class TestNumber < Test::Unit::TestCase
       @tester.decimal(fractional_digits: 0)
     end
   end
+
+  def test_between
+    from = -50
+    to = 50
+    assert_random_between(from..to) { @tester.between(from: from, to: to) }
+    assert_instance_of Integer, @tester.between(from: from, to: to)
+
+    from = -50.0
+    to = 50.0
+    assert_random_between(from..to) { @tester.between(from: from, to: to) }
+    assert_instance_of Float, @tester.between(from: from, to: to)
+  end
 end

data/test/test_phone_number_nl.rb

@@ -24,7 +24,7 @@ class TestPhoneNumberNL < Test::Unit::TestCase
 
   def test_phone_number
     10.times do
-      assert_match(/^0([\s\-]*\d){9}$/, @tester.phone_number)
+      assert_match(/^0([\s-]*\d){9}$/, @tester.phone_number)
     end
   end
 

data/test/test_phone_number_se.rb

@@ -16,7 +16,7 @@ class TestPhoneNumberSE < Test::Unit::TestCase
     @tester = FFaker::PhoneNumberSE
   end
 
-  ALLOWED_CHARS = /[()\d +-]/.freeze
+  ALLOWED_CHARS = /[()\d +-]/
 
   def test_mobile_phone_prefix
     assert FFaker::PhoneNumberSE::MOBILE_PHONE_PREFIX.include?(@tester.mobile_prefix)

data/test/test_phone_number_sg.rb

@@ -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_ssn_se.rb

@@ -24,7 +24,7 @@ class TestSSNSE < Test::Unit::TestCase
     assert equal?(ssn_female[10].to_i)
 
     assert_raise ArgumentError do
-      FFaker::SSNSE.ssn(gender: :unkown)
+      FFaker::SSNSE.ssn(gender: :unknown)
     end
   end
 

data/test/test_unique_utils.rb

@@ -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

@@ -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

data/test/test_units_english.rb

@@ -14,50 +14,50 @@ class TestUnitsEnglish < Test::Unit::TestCase
 
   def setup
     @tester = FFaker::UnitEnglish
-    @length_units = @tester::LENGTH_UNITS.map { |u| OpenStruct.new u }
-    @mass_units = @tester::MASS_UNITS.map { |u| OpenStruct.new u }
-    @liquid_units = @tester::LIQUID_UNITS.map { |u| OpenStruct.new u }
-    @volume_units = @tester::VOLUME_UNITS.map { |u| OpenStruct.new u }
-    @area_units = @tester::AREA_UNITS.map { |u| OpenStruct.new u }
+    @length_units = @tester::LENGTH_UNITS
+    @mass_units = @tester::MASS_UNITS
+    @liquid_units = @tester::LIQUID_UNITS
+    @volume_units = @tester::VOLUME_UNITS
+    @area_units = @tester::AREA_UNITS
   end
 
   def test_length_name
-    assert_include @length_units.map(&:name), @tester.length_name
+    assert_include @length_units.map { |unit| unit[:name] }, @tester.length_name
   end
 
   def test_length_abbrev
-    assert_include @length_units.map(&:abbreviation), @tester.length_abbr
+    assert_include @length_units.map { |unit| unit[:abbreviation] }, @tester.length_abbr
   end
 
   def test_mass_name
-    assert_include @mass_units.map(&:name), @tester.mass_name
+    assert_include @mass_units.map { |unit| unit[:name] }, @tester.mass_name
   end
 
   def test_mass_abbr
-    assert_include @mass_units.map(&:abbreviation), @tester.mass_abbr
+    assert_include @mass_units.map { |unit| unit[:abbreviation] }, @tester.mass_abbr
   end
 
   def test_liquid_name
-    assert_include @liquid_units.map(&:name), @tester.liquid_name
+    assert_include @liquid_units.map { |unit| unit[:name] }, @tester.liquid_name
   end
 
   def test_liquid_abbr
-    assert_include @liquid_units.map(&:abbreviation), @tester.liquid_abbr
+    assert_include @liquid_units.map { |unit| unit[:abbreviation] }, @tester.liquid_abbr
   end
 
   def test_volume_name
-    assert_include @volume_units.map(&:name), @tester.volume_name
+    assert_include @volume_units.map { |unit| unit[:name] }, @tester.volume_name
   end
 
   def test_volume_abbr
-    assert_include @volume_units.map(&:abbreviation), @tester.volume_abbr
+    assert_include @volume_units.map { |unit| unit[:abbreviation] }, @tester.volume_abbr
   end
 
   def test_area_name
-    assert_include @area_units.map(&:name), @tester.area_name
+    assert_include @area_units.map { |unit| unit[:name] }, @tester.area_name
   end
 
   def test_area_abbr
-    assert_include @area_units.map(&:abbreviation), @tester.area_abbr
+    assert_include @area_units.map { |unit| unit[:abbreviation] }, @tester.area_abbr
   end
 end

data/test/test_units_metric.rb

@@ -14,50 +14,50 @@ class TestUnitsMetric < Test::Unit::TestCase
 
   def setup
     @tester = FFaker::UnitMetric
-    @length_units = @tester::LENGTH_UNITS.map { |u| OpenStruct.new u }
-    @mass_units = @tester::MASS_UNITS.map { |u| OpenStruct.new u }
-    @liquid_units = @tester::LIQUID_UNITS.map { |u| OpenStruct.new u }
-    @volume_units = @tester::VOLUME_UNITS.map { |u| OpenStruct.new u }
-    @area_units = @tester::AREA_UNITS.map { |u| OpenStruct.new u }
+    @length_units = @tester::LENGTH_UNITS
+    @mass_units = @tester::MASS_UNITS
+    @liquid_units = @tester::LIQUID_UNITS
+    @volume_units = @tester::VOLUME_UNITS
+    @area_units = @tester::AREA_UNITS
   end
 
   def test_length_name
-    assert_include @length_units.map(&:name), @tester.length_name
+    assert_include @length_units.map { |unit| unit[:name] }, @tester.length_name
   end
 
   def test_length_abbrev
-    assert_include @length_units.map(&:abbreviation), @tester.length_abbr
+    assert_include @length_units.map { |unit| unit[:abbreviation] }, @tester.length_abbr
   end
 
   def test_mass_name
-    assert_include @mass_units.map(&:name), @tester.mass_name
+    assert_include @mass_units.map { |unit| unit[:name] }, @tester.mass_name
   end
 
   def test_mass_abbr
-    assert_include @mass_units.map(&:abbreviation), @tester.mass_abbr
+    assert_include @mass_units.map { |unit| unit[:abbreviation] }, @tester.mass_abbr
   end
 
   def test_liquid_name
-    assert_include @liquid_units.map(&:name), @tester.liquid_name
+    assert_include @liquid_units.map { |unit| unit[:name] }, @tester.liquid_name
   end
 
   def test_liquid_abbr
-    assert_include @liquid_units.map(&:abbreviation), @tester.liquid_abbr
+    assert_include @liquid_units.map { |unit| unit[:abbreviation] }, @tester.liquid_abbr
   end
 
   def test_volume_name
-    assert_include @volume_units.map(&:name), @tester.volume_name
+    assert_include @volume_units.map { |unit| unit[:name] }, @tester.volume_name
   end
 
   def test_volume_abbr
-    assert_include @volume_units.map(&:abbreviation), @tester.volume_abbr
+    assert_include @volume_units.map { |unit| unit[:abbreviation] }, @tester.volume_abbr
   end
 
   def test_area_name
-    assert_include @area_units.map(&:name), @tester.area_name
+    assert_include @area_units.map { |unit| unit[:name] }, @tester.area_name
   end
 
   def test_area_abbr
-    assert_include @area_units.map(&:abbreviation), @tester.area_abbr
+    assert_include @area_units.map { |unit| unit[:abbreviation] }, @tester.area_abbr
   end
 end

data/test/test_uuid.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestUUID < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::UUID,
+    :uuidv4, :uuidv6, :uuidv7, :uuidv8
+  )
+
+  def setup
+    @tester = FFaker::UUID
+  end
+
+  # @see https://stackoverflow.com/a/38191104
+  def test_uuidv4
+    raw_uuid = @tester.uuidv4
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b0100)
+    assert_variant(uuid, 0b10)
+  end
+
+  def test_uuidv6
+    raw_uuid = @tester.uuidv6
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b0110)
+    assert_variant(uuid, 0b10)
+  end
+
+  def test_uuidv7
+    raw_uuid = @tester.uuidv7
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b0111)
+    assert_variant(uuid, 0b10)
+  end
+
+  def test_uuidv8
+    raw_uuid = @tester.uuidv8
+    assert_format(raw_uuid)
+
+    uuid = uuid_to_integer(raw_uuid)
+    assert_version(uuid, 0b1000)
+    assert_variant(uuid, 0b10)
+  end
+
+  private
+
+  # Matches structure of all UUID versions.
+  def assert_format(uuid)
+    assert_match(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\z/,
+                 uuid)
+  end
+
+  def assert_version(uuid, version)
+    assert_equal(version, (uuid >> 76) & 0b1111)
+  end
+
+  def assert_variant(uuid, variant)
+    assert_equal(variant, (uuid >> 62) & 0b11)
+  end
+
+  def uuid_to_integer(uuid)
+    uuid.delete('-').to_i(16)
+  end
+end