ffaker 2.2.0 → 2.3.0

data/test/test_airline.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAirline < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Airline, :name, :flight_number)
+
+  def test_name
+    assert_match(/\A.+\z/, FFaker::Airline.name)
+  end
+
+  def test_flight_number
+    assert_match(/\w{2,3} \d{1,4}\z/, FFaker::Airline.flight_number)
+  end
+end

data/test/test_array_utils.rb

@@ -4,16 +4,18 @@ require 'helper'
 require 'set'
 
 class TestArrayUtils < Test::Unit::TestCase
+  include DeterministicHelper
+
   def setup
-    @array = FFaker::ArrayUtils.const_array("a".."c")
-    @elems = Set.new("a".."c")
+    @array = FFaker::ArrayUtils.const_array('a'..'c')
+    @elems = Set.new('a'..'c')
   end
 
   def test_provides_a_way_of_freezing_the_elements_and_itself
     assert @array.respond_to?(:freeze_all)
     @array.freeze_all
     assert @array.frozen?
-    @array.each { |e| assert e.frozen?  }
+    @array.each { |e| assert e.frozen? }
   end
 
   def test_provides_a_way_of_getting_a_random_element
@@ -49,4 +51,50 @@ class TestArrayUtils < Test::Unit::TestCase
 
     assert different_arrangements > 0
   end
+
+  def test_self_random_pick_is_deterministic
+    supress_warn_output do
+      array = Array.new(10) { rand(10) }
+      assert_deterministic { FFaker::ArrayUtils.random_pick(array, 3) }
+    end
+  end
+
+  def test_self_rand_is_deterministic
+    supress_warn_output do
+      array = Array.new(10) { rand(10) }
+      assert_deterministic { FFaker::ArrayUtils.rand(array) }
+    end
+  end
+
+  def test_self_shuffle_is_deterministic
+    array = Array.new(10) { rand(10) }
+    assert_deterministic { FFaker::ArrayUtils.shuffle(array) }
+  end
+
+  def test_rand_is_deterministic
+    supress_warn_output do
+      assert_deterministic { @array.rand }
+    end
+  end
+
+  def test_random_pick_is_deterministic
+    supress_warn_output do
+      assert_deterministic { @array.random_pick(2) }
+    end
+  end
+
+  def test_shuffle_is_deterministic
+    assert_deterministic { @array.shuffle }
+  end
+
+  private
+
+  # Supress the deprecation warning that some methods output, so we get less
+  # noise in our test run.
+  def supress_warn_output
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    yield
+    $VERBOSE = original_verbosity
+  end
 end

data/test/test_avatar.rb

@@ -1,7 +1,11 @@
 require 'helper'
 
 class TestAvatar < Test::Unit::TestCase
-  ROBOHASH = 'https://robohash.org'
+  include DeterministicHelper
+
+  ROBOHASH = 'https://robohash.org'.freeze
+
+  assert_methods_are_deterministic(FFaker::Avatar, :image)
 
   def setup
     @tester = FFaker::Avatar

data/test/test_aws.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestAWS < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::AWS, :instance_type)
+
+  def test_instance_type
+    assert_match(%r{\A[a-z]+\d\.\d*[a-z]+}, FFaker::AWS.instance_type)
+  end
+
+  def test_offering_type
+    assert_match(%r{\A[ a-zA-Z]+\z}i, FFaker::AWS.offering_type)
+  end
+
+  def test_instance_tenancy
+    assert_match(%r{\A(?:default|dedicated|host)+\z}i, FFaker::AWS.instance_tenancy)
+  end
+
+  def test_product_description
+    assert_match(%r{\A[ \/a-zA-Z\(\)]+\z}i, FFaker::AWS.product_description)
+  end
+end

data/test/test_bacon_ipsum.rb

@@ -3,28 +3,34 @@
 require 'helper'
 
 class TestBaconIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::BaconIpsum,
+    :paragraph, :sentence, :paragraphs, :sentences, :words, :word
+  )
 
   def test_paragraph
-    assert_match /1\+|[ a-z]+/i, FFaker::BaconIpsum.paragraph
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.paragraph)
   end
 
   def test_sentence
-    assert_match /1\+|[ a-z]+/i, FFaker::BaconIpsum.sentence
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.sentence)
   end
 
   def test_paragraphs
-    assert_match /1\+|[ a-z]+/i, FFaker::BaconIpsum.paragraphs.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.paragraphs.join(' '))
   end
 
   def test_sentences
-    assert_match /1\+|[ a-z]+/i, FFaker::BaconIpsum.sentences.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.sentences.join(' '))
   end
 
   def test_words
-    assert_match /1\+|[ a-z]+/i, FFaker::BaconIpsum.words.join(" ")
+    assert_match(/1\+|[ a-z]+/i, FFaker::BaconIpsum.words.join(' '))
   end
 
   def test_word
-    assert_match /1\+|[a-z]+/i, FFaker::BaconIpsum.word
+    assert_match(/1\+|[a-z]+/i, FFaker::BaconIpsum.word)
   end
 end

data/test/test_book.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestBook < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Book,
+    :title, :genre, :author, :isbn, :description, :cover
+  )
+
+  def setup
+    @tester = FFaker::Book
+  end
+
+  def test_title
+    assert_match(/[\sa-z]+/, @tester.title)
+  end
+
+  def test_genre
+    assert_match(%r([\w\s'\/]+), @tester.genre)
+  end
+
+  def test_author
+    assert_match(/[\sa-z]+/, @tester.author)
+  end
+
+  def test_isbn
+    assert_match(/[\d]+/, @tester.isbn)
+  end
+
+  def test_description
+    assert_match(/[\sa-z]+/, @tester.description)
+  end
+
+  def test_cover
+    assert_match(%r(\Ahttps:\/\/robohash\.org\/.+\.png\?size=300x300\z),
+                 @tester.cover)
+  end
+end

data/test/test_boolean.rb

@@ -3,6 +3,10 @@
 require 'helper'
 
 class TestBoolean < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::Boolean, :maybe)
+
   def test_maybe
     maybe = FFaker::Boolean.maybe
     assert (maybe == false || maybe == true)

data/test/test_cheesy_lingo.rb

@@ -1,37 +1,41 @@
 require 'helper'
 
 class TestCheesyLingo < Test::Unit::TestCase
+  include DeterministicHelper
 
   TEST_REGEX = /\+1|[a-z]+/i
 
+  assert_methods_are_deterministic(
+    FFaker::CheesyLingo,
+    :title, :word, :words, :sentence, :paragraph
+  )
 
   def setup
     @tester = FFaker::CheesyLingo
   end
 
   def test_title
-    assert_match TEST_REGEX, @tester.title
+    assert_match(TEST_REGEX, @tester.title)
   end
 
   def test_word
-    assert_match TEST_REGEX, @tester.word
+    assert_match(TEST_REGEX, @tester.word)
   end
 
   def test_words
-    assert_match TEST_REGEX, @tester.words(3).join(" ")
+    assert_match(TEST_REGEX, @tester.words(3).join(' '))
   end
 
   def test_sentence
-    assert_match TEST_REGEX, @tester.sentence
-    assert_match /1\+|[ a-zA-Z]+./, @tester.sentence
+    assert_match(TEST_REGEX, @tester.sentence)
+    assert_match(/1\+|[ a-zA-Z]+./, @tester.sentence)
   end
 
-  def test_paragraph #without passing count
-    assert_match /\+|[a-zA-Z]*./, @tester.paragraph(1)
+  def test_paragraph # without passing count
+    assert_match(/\+|[a-zA-Z]*./, @tester.paragraph(1))
   end
 
   def test_paragraph_with_arg
-    assert_match /\+1|[a-zA-Z]+./, @tester.paragraph(3)
+    assert_match(/\+1|[a-zA-Z]+./, @tester.paragraph(3))
   end
-
-end
+end

data/test/test_color.rb

@@ -3,7 +3,132 @@
 require 'helper'
 
 class TestColor < Test::Unit::TestCase
+  include DeterministicHelper
+
+  VALID_RGB_REGEX = /\A([0-9]{1,3})\z/
+  VALID_OPACITY_REGEX = /^([0-9].[0-9]{1,2})$/
+  VALID_PERCENTAGE_REGEX = /^([0-9]{1,3}%)$/
+
+  assert_methods_are_deterministic(
+    FFaker::Color,
+    :name, :hex_code, :rgb_array, :rgb_list,
+    :rgba_array, :rgba_list, :hsl_array, :hsl_list,
+    :hsla_array, :hsla_list
+  )
+
   def test_name
-    assert_match /\A[a-z]+\z/, FFaker::Color.name
+    assert_match(/\A[a-z]+\z/, FFaker::Color.name)
+  end
+
+  def test_hex_code
+    assert_match /\A\h{6}\z/, FFaker::Color.hex_code
+  end
+
+  def test_rgb_array
+    fake_array = FFaker::Color.rgb_array
+
+    assert fake_array.size == 3
+
+    red_value = fake_array[0]
+    assert_match VALID_RGB_REGEX, red_value.to_s
+    assert red_value.between? 0, 255
+
+    green_value = fake_array[1]
+    assert_match VALID_RGB_REGEX, green_value.to_s
+    assert green_value.between? 0, 255
+
+    blue_value = fake_array[2]
+    assert_match VALID_RGB_REGEX, blue_value.to_s
+    assert blue_value.between? 0, 255
+  end
+
+  def test_rgb_list
+    assert_match(
+      /\A([0-9]{1,3},[0-9]{1,3},[0-9]{1,3})\z/,
+      FFaker::Color.rgb_list
+    )
+  end
+
+  def test_rgba_array
+    fake_array = FFaker::Color.rgba_array
+
+    assert fake_array.size == 4
+
+    red_value = fake_array[0]
+    assert_match VALID_RGB_REGEX, red_value.to_s
+    assert red_value.between? 0, 255
+
+    green_value = fake_array[1]
+    assert_match VALID_RGB_REGEX, green_value.to_s
+    assert green_value.between? 0, 255
+
+    blue_value = fake_array[2]
+    assert_match VALID_RGB_REGEX, blue_value.to_s
+    assert blue_value.between? 0, 255
+
+    opacity_value = fake_array[3]
+    assert_match VALID_OPACITY_REGEX, opacity_value.to_s
+    assert opacity_value.between? 0.0, 1.0
+  end
+
+  def test_rgba_list
+    assert_match(
+      /^([0-9]{1,3},[0-9]{1,3},[0-9]{1,3}),([0-9].[0-9]{1,2})$/,
+      FFaker::Color.rgba_list
+    )
+  end
+
+  def test_hsl_array
+    fake_array = FFaker::Color.hsl_array
+
+    assert fake_array.size == 3
+
+    hue_value = fake_array[0]
+    assert_match VALID_RGB_REGEX, hue_value.to_s
+    assert hue_value.between? 0, 360
+
+    saturation_value = fake_array[1]
+    assert_match VALID_PERCENTAGE_REGEX, saturation_value
+    assert saturation_value.delete('%').to_i.between? 0, 100
+
+    lightness_value = fake_array[2]
+    assert_match VALID_PERCENTAGE_REGEX, lightness_value
+    assert lightness_value.delete('%').to_i.between? 0, 100
+  end
+
+  def test_hsl_list
+    assert_match(
+      /^([0-9]{1,3},[0-9]{1,3}%,[0-9]{1,3}%)$/,
+      FFaker::Color.hsl_list
+    )
+  end
+
+  def test_hsla_array
+    fake_array = FFaker::Color.hsla_array
+
+    assert fake_array.size == 4
+
+    hue_value = fake_array[0]
+    assert_match VALID_RGB_REGEX, hue_value.to_s
+    assert hue_value.between? 0, 360
+
+    saturation_value = fake_array[1]
+    assert_match VALID_PERCENTAGE_REGEX, saturation_value
+    assert saturation_value.delete('%').to_i.between? 0, 100
+
+    lightness_value = fake_array[2]
+    assert_match VALID_PERCENTAGE_REGEX, lightness_value
+    assert lightness_value.delete('%').to_i.between? 0, 100
+
+    opacity_value = fake_array[3]
+    assert_match VALID_OPACITY_REGEX, opacity_value.to_s
+    assert opacity_value.between? 0.0, 1.0
+  end
+
+  def test_hsla_list
+    assert_match(
+      /^([0-9]{1,3},[0-9]{1,3}%,[0-9]{1,3}%,[0-9].[0-9]{1,2})$/,
+      FFaker::Color.hsla_list
+    )
   end
 end

data/test/test_color_ua.rb

@@ -3,7 +3,11 @@
 require 'helper'
 
 class TestColorUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFaker::ColorUA, :name)
+
   def test_name
-    assert_match /\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/, FFaker::ColorUA.name
+    assert_match(/\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/, FFaker::ColorUA.name)
   end
 end

data/test/test_company.rb

@@ -3,6 +3,13 @@
 require 'helper'
 
 class TestCompany < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::Company,
+    :bs, :catch_phrase, :name, :suffix
+  )
+
   def setup
     @tester = FFaker::Company
   end

data/test/test_company_cn.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestCompanyCN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFaker::CompanyCN,
+    :name, :suffix, :type
+  )
+
+  def test_name
+    assert_match(/.{4,}公司\z/, FFaker::CompanyCN.name)
+  end
+
+  def test_suffix
+    assert_match(/公司\z/i, FFaker::CompanyCN.suffix)
+  end
+
+  def test_type
+    assert_match(/.{2,}/i, FFaker::CompanyCN.type)
+  end
+end