ffakerTW 0.1.0

data/test/test_phone_number_ua.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestPhoneNumberUA < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::PhoneNumberUA,
+    :phone_number, :home_phone_number, :mobile_phone_number,
+    :international_home_phone_number, :international_mobile_phone_number
+  )
+
+  def setup
+    @tester = FFakerTW::PhoneNumberUA
+  end
+
+  def test_phone_number
+    assert_match(/^(\+(380)\s|0)[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.phone_number)
+  end
+
+  def test_home_phone_number
+    assert_match(/^0{1}[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.home_phone_number)
+  end
+
+  def test_mobile_phone_number
+    assert_match(/^0{1}[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.mobile_phone_number)
+  end
+
+  def test_international_home_phone_number
+    assert_match(/^\+(380)\s[0-9]{2}\s[0-9]{3}-[0-9]{4}$/, @tester.international_home_phone_number)
+  end
+
+  def international_mobile_phone_number
+    assert_match(/^\+(380)\s[0-9]{2}\s[0-9]{3}-[0-9]{4}$/,
+                 @tester.international_mobile_phone_number)
+  end
+end

data/test/test_products.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestProducts < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Product,
+    :brand, :product_name, :product, :model
+  )
+
+  def test_letters_max_as_int
+    assert_match(/\A[A-Z]{10}\z/, FFakerTW::Product.letters(10))
+    assert_deterministic { FFakerTW::Product.letters(10) }
+  end
+
+  def test_letters_max_as_range
+    assert_match(/\A[A-Z]{5,10}\z/, FFakerTW::Product.letters(5..10))
+    assert_deterministic { FFakerTW::Product.letters(5..10) }
+  end
+end

data/test/test_sem_ver.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSemVer < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::SemVer, :next)
+
+  def setup
+    @tester = FFakerTW::SemVer
+  end
+
+  def test_next
+    assert_includes(%w[0.0.1 0.1.0 1.0.0], @tester.next)
+    assert_includes(%w[2.0.0 1.3.0 1.2.4], @tester.next('1.2.3'))
+  end
+end

data/test/test_skill.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSkill < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Skill,
+    :tech_skill, :tech_skills, :specialty, :specialties
+  )
+
+  def test_tech_skill
+    assert_match(/[a-z]+/i, FFakerTW::Skill.tech_skill)
+  end
+
+  def test_tech_skills
+    tech_skills = FFakerTW::Skill.tech_skills
+    assert_instance_of Array, tech_skills
+  end
+
+  def test_specialty
+    assert_match(/[ a-z]+/i, FFakerTW::Skill.specialty)
+  end
+
+  def test_specialties
+    specialties = FFakerTW::Skill.specialties
+    assert_instance_of Array, specialties
+  end
+end

data/test/test_sport_pl.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSportPL < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::SportPL,
+    :name,
+    :summer,
+    :winter
+  )
+
+  def setup
+    @tester = FFakerTW::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_sport_ru.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSportRU < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::SportRU,
+    :name,
+    :summer,
+    :winter
+  )
+
+  def setup
+    @tester = FFakerTW::SportRU
+  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_sport_us.rb

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

data/test/test_sports.rb

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

data/test/test_ssn.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSSN < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::SSN, :ssn)
+
+  def setup
+    @actual_ssn = FFakerTW::SSN.ssn
+  end
+
+  def test_ssn_format
+    assert_no_match(/\A666/, @actual_ssn)
+    assert_match(/\A[0-8]\d{2}-\d{2}-\d{4}\Z/, @actual_ssn)
+  end
+
+  def test_ssn_groups_non_zero
+    first_group, second_group, third_group = @actual_ssn.split('-')
+    with_all_zeros = /\A0+\Z/
+
+    assert_no_match(with_all_zeros, first_group)
+    assert_no_match(with_all_zeros, second_group)
+    assert_no_match(with_all_zeros, third_group)
+  end
+end

data/test/test_ssn_mx.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSSNMX < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::SSNMX,
+    :ssn, :ssn_undashed, :imss, :imss_undashed, :issste, :issste_undashed
+  )
+
+  def test_ssn
+    assert_match(/\d{10}-\d/, FFakerTW::SSNMX.ssn)
+  end
+
+  def test_ssn_undashed
+    assert_match(/\d{11}/, FFakerTW::SSNMX.ssn_undashed)
+  end
+
+  def test_imss
+    assert_match(/\d{10}-\d/, FFakerTW::SSNMX.imss)
+  end
+
+  def test_imss_undashed
+    assert_match(/\d{11}/, FFakerTW::SSNMX.imss_undashed)
+  end
+
+  def test_issste
+    assert_match(/\d{10}-\d/, FFakerTW::SSNMX.issste)
+  end
+
+  def test_issste_undashed
+    assert_match(/\d{11}/, FFakerTW::SSNMX.issste_undashed)
+  end
+end

data/test/test_ssn_se.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestSSNSE < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::SSNSE, :ssn)
+
+  def test_ssn_format
+    ssn = FFakerTW::SSNSE.ssn
+    assert_match(/(19|20)\d{10}/, ssn, "With no arguments year should start with 19 or 20, #{ssn}")
+  end
+
+  def equal?(other)
+    other % 2
+  end
+
+  def test_ssn_with_gender
+    ssn_male = FFakerTW::SSNSE.ssn(gender: :male)
+    assert equal?(ssn_male[10].to_i)
+
+    ssn_female = FFakerTW::SSNSE.ssn(gender: :female)
+    assert equal?(ssn_female[10].to_i)
+
+    assert_raise ArgumentError do
+      FFakerTW::SSNSE.ssn(gender: :unkown)
+    end
+  end
+
+  def test_ssn_with_from_to
+    from = Time.local(1980, 2, 28)
+    to = Time.local(2000, 2, 28)
+
+    assert_random_between(from...to) do
+      ssn = FFakerTW::SSNSE.ssn(from: from, to: to)
+      year = ssn[0..3].to_i
+      month = ssn[4..5].to_i
+      day = ssn[6..7].to_i
+      Time.local(year, month, day)
+    end
+  end
+end

data/test/test_string.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestString < Test::Unit::TestCase
+  include DeterministicHelper
+
+  FS = FFakerTW::String
+
+  def test_atoms
+    assert_equal 'abc', FS.from_regexp(/abc/)
+    assert_deterministic { FS.from_regexp(/abc/) }
+  end
+
+  def test_digits
+    assert_match(/\A\d\d\d\z/, FS.from_regexp(/\d\d\d/))
+    assert_deterministic { FS.from_regexp(/\d\d\d/) }
+  end
+
+  def test_word_characters
+    assert_match(/\A\w\w\w\z/, FS.from_regexp(/\w\w\w/))
+    assert_deterministic { FS.from_regexp(/\w\w\w/) }
+  end
+
+  def test_word_range_character
+    assert_match(/\A[a-z]\z/, FS.from_regexp(/[a-z]/))
+    assert_deterministic { FS.from_regexp(/[a-z]/) }
+  end
+
+  def test_dash_character
+    assert_match(/\A[a-z-]\z/, FS.from_regexp(/[a-z-]/))
+    assert_match(/\A[a-]\z/, FS.from_regexp(/[a-]/))
+    assert_match(/\A-\z/, FS.from_regexp(/-/))
+
+    assert_deterministic { FS.from_regexp(/[a-z-]/) }
+    assert_deterministic { FS.from_regexp(/[a-]/) }
+    assert_deterministic { FS.from_regexp(/-/) }
+  end
+
+  def test_spaces
+    assert_match(/\A\s\s\s\z/, FS.from_regexp(/\s\s\s/))
+    assert_deterministic { FS.from_regexp(/\s\s\s/) }
+  end
+
+  def test_escaped_characters
+    assert_equal '\\/.()[]{}', FS.from_regexp(%r{\\/\.\(\)\[\]\{\}})
+    assert_deterministic { FS.from_regexp(%r|\\/\.\(\)\[\]\{\}|) }
+  end
+
+  def test_atom_sets
+    assert_include %w[a b c], FS.from_regexp(/[abc]/)
+    assert_deterministic { FS.from_regexp(/[abc]/) }
+  end
+
+  def test_special_sets
+    assert_match(/\A[\s\d]\z/, FS.from_regexp(/[\s\d]/))
+    assert_deterministic { FS.from_regexp(/[\s\d]/) }
+  end
+
+  def test_atom_question
+    assert_match(/\Aa?\z/, FS.from_regexp(/a?/))
+    assert_deterministic { FS.from_regexp(/a?/) }
+  end
+
+  def test_special_question
+    assert_match(/\A\w?\z/, FS.from_regexp(/\w?/))
+    assert_deterministic { FS.from_regexp(/\w?/) }
+  end
+
+  def test_set_question
+    assert_match(/\A[abc]?\z/, FS.from_regexp(/[abc]?/))
+    assert_deterministic { FS.from_regexp(/[abc]?/) }
+  end
+
+  def test_atom_plus
+    assert_match(/\Aa+\z/, FS.from_regexp(/a+/))
+    assert_deterministic { FS.from_regexp(/a+/) }
+  end
+
+  def test_special_plus
+    assert_match(/\A\w+\z/, FS.from_regexp(/\w+/))
+    assert_deterministic { FS.from_regexp(/\w+/) }
+  end
+
+  def test_set_plus
+    assert_match(/\A[abc]+\z/, FS.from_regexp(/[abc]+/))
+    assert_deterministic { FS.from_regexp(/[abc]+/) }
+  end
+
+  def test_atom_star
+    assert_match(/\Aa*\z/, FS.from_regexp(/a*/))
+    assert_deterministic { FS.from_regexp(/a*/) }
+  end
+
+  def test_special_star
+    assert_match(/\A\w*\z/, FS.from_regexp(/\w*/))
+    assert_deterministic { FS.from_regexp(/\w*/) }
+  end
+
+  def test_set_star
+    assert_match(/\A[abc]*\z/, FS.from_regexp(/[abc]*/))
+    assert_deterministic { FS.from_regexp(/[abc]*/) }
+  end
+
+  def test_braces
+    assert_equal 'a' * 13, FS.from_regexp(/a{13}/)
+    assert_match(/\A[abc]{13}\z/, FS.from_regexp(/[abc]{13}/))
+    assert_match(/\A\w{13}\z/, FS.from_regexp(/\w{13}/))
+
+    assert_deterministic { FS.from_regexp(/a{13}/) }
+    assert_deterministic { FS.from_regexp(/[abc]{13}/) }
+    assert_deterministic { FS.from_regexp(/\w{13}/) }
+  end
+end

data/test/test_time.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'date'
+
+class TestFakerTime < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(FFakerTW::Time, :date, :datetime, :month, :day_of_week)
+
+  def setup
+    @tester = FFakerTW::Time
+  end
+
+  def test_date
+    assert_instance_of Date, @tester.date
+  end
+
+  def test_day_of_week
+    day_of_week_short_regex = /\A(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\z/
+    day_of_week_long_regex = /\A(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday)\z/
+    assert_match(day_of_week_short_regex, @tester.day_of_week)
+    assert_match(day_of_week_long_regex, @tester.day_of_week(long: true))
+    assert_deterministic { @tester.day_of_week }
+  end
+
+  def test_datetime
+    assert_instance_of DateTime, @tester.datetime
+  end
+
+  def test_datetime_random_days_and_months
+    1_000.times do
+      @tester.datetime
+    end
+  end
+
+  def test_datetime_hours_and_minutes
+    assert_equal(4, @tester.datetime(hours: 4, minutes: 20).hour)
+    assert_equal(20, @tester.datetime(hours: 4, minutes: 20).min)
+    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)
+  end
+
+  def test_between_for_time
+    from = Time.local(2015, 1, 1)
+    to   = Time.local(2016, 1, 1)
+
+    assert_random_between(from..to) { @tester.between(from, to) }
+  end
+
+  def test_between_for_string
+    from = @tester.datetime
+    to   = @tester.datetime
+    random_date = @tester.between(from, to)
+    assert_instance_of Time, random_date
+  end
+
+  def test_between_for_date
+    from = Date.new(2015, 1, 1)
+    to   = Date.new(2016, 1, 1)
+    random_date = @tester.between(from, to)
+    assert_instance_of Time, random_date
+  end
+
+  def test_between_for_datetime
+    from = DateTime.new(2015, 1, 1, 12, 12)
+    to   = DateTime.new(2016, 1, 1, 12, 12)
+    random_date = @tester.between(from, to)
+    assert_instance_of Time, random_date
+  end
+
+  def test_convert_to_time_string
+    time = @tester.send(:convert_to_time, '2012-12-12 12:12')
+    assert_instance_of Time, time
+  end
+
+  def test_convert_to_time_date
+    time = @tester.send(:convert_to_time, Date.new(2015, 1, 1))
+    assert_instance_of Time, time
+  end
+
+  def test_convert_to_time_datetime
+    time = @tester.send(:convert_to_time, DateTime.new(2015, 1, 1, 12, 12))
+    assert_instance_of Time, time
+  end
+end

data/test/test_tweet.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestTweet < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Tweet,
+    :tags, :mention, :body, :tweet
+  )
+
+  def test_2_tags
+    assert_match(/\#\S*\s\#\S*/, FFakerTW::Tweet.tags)
+  end
+
+  def test_3_tags
+    assert_match(/\#\S*\s\#\S*\s\#\S*/, FFakerTW::Tweet.tags(3))
+    assert_deterministic { FFakerTW::Tweet.tags(3) }
+  end
+
+  def test_mention
+    assert_match(/@\S*/, FFakerTW::Tweet.mention)
+  end
+
+  def test_mentions_three
+    assert_match(/@\S*\s@\S*\s@\S*/, FFakerTW::Tweet.mentions(3))
+    assert_deterministic { FFakerTW::Tweet.mentions(3) }
+  end
+
+  def test_body
+    assert_less_than_or_equal_to FFakerTW::Tweet.body.size, 140
+  end
+
+  def test_shortish_body
+    assert_less_than_or_equal_to FFakerTW::Tweet.body(20).size, 20
+  end
+
+  def test_short_body
+    assert_between(FFakerTW::Tweet.body(2).size, 2..20)
+  end
+
+  def test_tweet
+    assert_random_less_than_or_equal_to(140) { FFakerTW::Tweet.tweet.size }
+  end
+
+  def test_tweet_with_reply
+    assert_match(/^@/, FFakerTW::Tweet.tweet(reply: true))
+    assert_deterministic { FFakerTW::Tweet.tweet(reply: true) }
+  end
+
+  def test_oversize_body_length
+    assert_less_than_or_equal_to FFakerTW::Tweet.tweet(body_length: 200).size, 140
+  end
+
+  def test_undersize_body_length
+    assert_less_than_or_equal_to FFakerTW::Tweet.tweet(body_length: 2).size, 140
+  end
+end

data/test/test_unique_utils.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class TestUniqueUtils < Test::Unit::TestCase
+  def test_generates_unique_values
+    unique_object = FFakerTW::UniqueUtils.new(FFakerTW::Name, 10_000)
+
+    result = [unique_object.name, unique_object.name]
+    assert_operator(result[0], :!=, result[1])
+  end
+
+  def test_returns_error_when_retries_exceeded
+    stubbed_generator = Object.new
+    def stubbed_generator.test
+      1
+    end
+
+    unique_object = FFakerTW::UniqueUtils.new(stubbed_generator, 3)
+
+    unique_object.test
+
+    assert_raises FFakerTW::UniqueUtils::RetryLimitExceeded do
+      unique_object.test
+    end
+  end
+
+  def test_clears_unique_values
+    stubbed_generator = Object.new
+    def stubbed_generator.test
+      1
+    end
+
+    unique_object = FFakerTW::UniqueUtils.new(stubbed_generator, 3)
+
+    assert_equal(1, unique_object.test)
+
+    assert_raises FFakerTW::UniqueUtils::RetryLimitExceeded do
+      unique_object.test
+    end
+
+    FFakerTW::UniqueUtils.clear
+
+    assert_equal(1, unique_object.test)
+
+    assert_raises FFakerTW::UniqueUtils::RetryLimitExceeded do
+      unique_object.test
+    end
+
+    unique_object.clear
+
+    assert_equal(1, unique_object.test)
+  end
+end

data/test/test_units.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'ostruct'
+
+class TestUnits < Test::Unit::TestCase
+  include DeterministicHelper
+
+  assert_methods_are_deterministic(
+    FFakerTW::Unit,
+    :time_name, :time_abbr, :temperature_name, :temperature_abbr
+  )
+
+  def setup
+    @tester = FFakerTW::Unit
+    @time_units = @tester::TIME_UNITS.map { |u| OpenStruct.new u }
+    @temperature_units = @tester::TEMPERATURE_UNITS.map { |u| OpenStruct.new u }
+  end
+
+  def test_time_name
+    assert_include @time_units.map(&:name), @tester.time_name
+  end
+
+  def test_time_abbr
+    assert_include @time_units.map(&:abbreviation), @tester.time_abbr
+  end
+
+  def test_temperature_name
+    assert_include @temperature_units.map(&:name), @tester.temperature_name
+  end
+
+  def test_temperature_abbr
+    assert_include \
+      @temperature_units.map(&:abbreviation),
+      @tester.temperature_abbr
+  end
+end