ffakerTW 0.1.0

data/test/test_animal_us.rb

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

data/test/test_array_utils.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'set'
+
+class TestArrayUtils < Test::Unit::TestCase
+  include DeterministicHelper
+
+  def setup
+    @array = FFakerTW::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? }
+  end
+
+  def test_provides_a_way_of_getting_a_random_element
+    set = Set.new
+    1000.times { set << @array.sample }
+    assert set == @elems
+  end
+
+  def test_provides_a_way_of_getting_n_random_elements
+    assert_equal @array.sample(3).sort, @array.sort
+
+    1.upto(3) do |n|
+      1000.times do
+        new_arr = @array.sample(n)
+        assert_equal n, new_arr.length
+        new_arr.each do |e|
+          assert @elems.include? e
+        end
+      end
+    end
+  end
+
+  def test_provides_a_way_of_shuffling_the_array
+    assert_equal @array.shuffle.sort, @array.sort
+
+    different_arrangements = 0
+
+    1000.times do
+      new_arr = @array.shuffle
+      assert new_arr.to_set == @elems
+      different_arrangements += 1 if new_arr != @array
+    end
+
+    assert different_arrangements.positive?
+  end
+
+  def test_self_random_pick_is_deterministic
+    supress_warn_output do
+      array = Array.new(10) { rand(0..9) }
+      assert_deterministic { FFakerTW::ArrayUtils.random_pick(array, 3) }
+    end
+  end
+
+  def test_self_rand_is_deterministic
+    supress_warn_output do
+      array = Array.new(10) { rand(0..9) }
+      assert_deterministic { FFakerTW::ArrayUtils.rand(array) }
+    end
+  end
+
+  def test_self_shuffle_is_deterministic
+    array = Array.new(10) { rand(0..9) }
+    assert_deterministic { FFakerTW::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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestAvatar < Test::Unit::TestCase
+  include DeterministicHelper
+
+  ROBOHASH = 'https://robohash.org'
+
+  assert_methods_are_deterministic(FFakerTW::Avatar, :image)
+
+  def setup
+    @tester = FFakerTW::Avatar
+  end
+
+  def test_avatar
+    assert_match(%r{\Ahttps://robohash\.org/.+\.png\?size=300x300\z},
+                 @tester.image)
+  end
+
+  def test_avatar_with_param
+    assert_equal("#{ROBOHASH}/faker.png?size=300x300", @tester.image('faker'))
+  end
+
+  def test_avatar_with_correct_size
+    assert_equal("#{ROBOHASH}/faker.png?size=150x320",
+                 @tester.image('faker', '150x320'))
+  end
+
+  def test_avatar_with_incorrect_size
+    assert_raise ArgumentError do
+      @tester.image(nil, '150x320z')
+    end
+  end
+
+  def test_avatar_with_supported_format
+    assert_equal("#{ROBOHASH}/faker.jpg?size=300x300",
+                 @tester.image('faker', '300x300', 'jpg'))
+  end
+
+  def test_avatar_with_incorrect_format
+    assert_raise ArgumentError do
+      @tester.image(nil, '300x300', 'wrong_format')
+    end
+  end
+
+  def test_avatar_with_correct_background
+    assert_equal("#{ROBOHASH}/faker.png?size=300x300&bgset=bg1",
+                 @tester.image('faker', '300x300', 'png', '1'))
+  end
+
+  def test_avatar_with_incorrect_background
+    assert_raise ArgumentError do
+      @tester.image('faker', '300x300', 'png', 'not_a_number')
+    end
+  end
+end

data/test/test_aws.rb

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

data/test/test_bacon_ipsum.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBaconIpsum < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::BaconIpsum,
+    :paragraph, :sentence, :paragraphs, :sentences, :words, :word
+  )
+
+  def test_paragraph
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::BaconIpsum.paragraph)
+  end
+
+  def test_sentence
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::BaconIpsum.sentence)
+  end
+
+  def test_paragraphs
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::BaconIpsum.paragraphs.join(' '))
+  end
+
+  def test_sentences
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::BaconIpsum.sentences.join(' '))
+  end
+
+  def test_words
+    assert_match(/1\+|[ a-z]+/i, FFakerTW::BaconIpsum.words.join(' '))
+  end
+
+  def test_word
+    assert_match(/1\+|[a-z]+/i, FFakerTW::BaconIpsum.word)
+  end
+end

data/test/test_bank.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBank < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Bank,
+    :iban, :card_number, :card_expiry_date, :card_type
+  )
+
+  def setup
+    @tester = FFakerTW::Bank
+  end
+
+  def test_iban
+    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
+      @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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBook < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Book,
+    :title, :genre, :author, :isbn, :description, :cover
+  )
+
+  def setup
+    @tester = FFakerTW::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
+
+  def test_orly_cover
+    assert_match(%r{\Ahttps://orly-appstore\.herokuapp\.com/generate},
+                 @tester.orly_cover)
+  end
+end

data/test/test_boolean.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestBoolean < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Boolean, :maybe)
+
+  def test_maybe
+    maybe = FFakerTW::Boolean.maybe
+    assert [true, false].include?(maybe)
+  end
+end

data/test/test_cheesy_lingo.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestCheesyLingo < Test::Unit::TestCase
+  include DeterministicHelper
+
+  TEST_REGEX = /\+1|[a-z]+/i.freeze
+
+  assert_methods_are_deterministic(
+    FFakerTW::CheesyLingo,
+    :title, :word, :words, :sentence, :paragraph
+  )
+
+  def setup
+    @tester = FFakerTW::CheesyLingo
+  end
+
+  def test_title
+    assert_match(TEST_REGEX, @tester.title)
+  end
+
+  def test_word
+    assert_match(TEST_REGEX, @tester.word)
+  end
+
+  def test_words
+    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)
+  end
+
+  def test_paragraph
+    assert_match(/\+|[a-zA-Z]*./, @tester.paragraph(1))
+  end
+
+  def test_paragraph_with_arg
+    assert_match(/\+1|[a-zA-Z]+./, @tester.paragraph(3))
+  end
+end

data/test/test_code.rb

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

data/test/test_color.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestColor < Test::Unit::TestCase
+  include DeterministicHelper
+
+  VALID_RGB_REGEX = /\A([0-9]{1,3})\z/.freeze
+  VALID_OPACITY_REGEX = /^([0-9].[0-9]{1,2})$/.freeze
+  VALID_PERCENTAGE_REGEX = /^([0-9]{1,3}%)$/.freeze
+
+  assert_methods_are_deterministic(
+    FFakerTW::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/, FFakerTW::Color.name)
+  end
+
+  def test_hex_code
+    assert_match(/\A\h{6}\z/, FFakerTW::Color.hex_code)
+  end
+
+  def test_rgb_array
+    fake_array = FFakerTW::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/,
+      FFakerTW::Color.rgb_list
+    )
+  end
+
+  def test_rgba_array
+    fake_array = FFakerTW::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})$/,
+      FFakerTW::Color.rgba_list
+    )
+  end
+
+  def test_hsl_array
+    fake_array = FFakerTW::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}%)$/,
+      FFakerTW::Color.hsl_list
+    )
+  end
+
+  def test_hsla_array
+    fake_array = FFakerTW::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})$/,
+      FFakerTW::Color.hsla_list
+    )
+  end
+end

data/test/test_color_pl.rb

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

data/test/test_color_ua.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestColorUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::ColorUA, :name)
+
+  def test_name
+    assert_match(/\A[а-яА-ЯіїєґІЇЄҐ’\-\s]+\z/, FFakerTW::ColorUA.name)
+  end
+end

data/test/test_company.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestCompany < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Company,
+    :bs, :catch_phrase, :name, :suffix
+  )
+
+  def setup
+    @tester = FFakerTW::Company
+  end
+
+  def test_bs
+    assert_match(%r{\A[ \w'/-]+\z}, @tester.bs)
+  end
+
+  def test_catch_phrase
+    assert_match(%r{\A[ \w'/-]+\z}, @tester.catch_phrase)
+  end
+
+  def test_name
+    assert_match(/\A[ \w,'-]+\z/, @tester.name)
+  end
+
+  def test_suffix
+    assert_include @tester::SUFFIXES, @tester.suffix
+  end
+end

data/test/test_company_cn.rb

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

data/test/test_company_fr.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestCompanyFR < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::CompanyFR,
+    :name, :suffix, :siren, :siret
+  )
+
+  def test_name
+    assert_match(/[ a-z]+/, FFakerTW::CompanyFR.name)
+  end
+
+  def test_suffix
+    assert_match(/[ a-z]+/i, FFakerTW::CompanyFR.suffix)
+  end
+
+  def test_french_siren_number
+    siren = FFakerTW::CompanyFR.siren
+    assert(siren.match(/\A\d{9}\z/))
+    assert(siren[8] == FFakerTW::CompanyFR.send(:luhn_check, siren[0..-2]).to_s)
+  end
+
+  def test_french_siret_number
+    siret = FFakerTW::CompanyFR.siret
+    assert(siret.match(/\A\d{14}\z/))
+    assert(siret[8] == FFakerTW::CompanyFR.send(:luhn_check, siret[0..7]).to_s)
+    assert(siret[13] == FFakerTW::CompanyFR.send(:luhn_check, siret[0..-2]).to_s)
+  end
+end