factory-helper 1.7.5 → 1.7.6

data/test/legacy/test_faker_hacker_talk.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
+
+class TestFakerHacker < Test::Unit::TestCase
+  def setup
+     @hacker = Faker::Hacker
+     @phrases = @hacker.phrases
+  end
+
+  def test_phrases
+    assert @phrases.size == 8
+    @phrases.each do |phrase|
+       assert !phrase.nil?
+       assert phrase != ""
+    end
+  end
+
+  def test_noun
+    assert @hacker.noun.match(/\w+/)
+  end
+
+  def test_abbreviation
+    assert @hacker.abbreviation.match(/\w+/)
+  end
+
+  def test_adjective
+    assert @hacker.adjective.match(/\w+/)
+  end
+
+  def test_verb
+    assert @hacker.verb.match(/\w+/)
+  end
+
+  def test_ingverb
+    assert @hacker.ingverb.match(/\w+/)
+  end
+
+end

data/test/legacy/test_faker_internet.rb

@@ -0,0 +1,146 @@
+# coding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
+
+class TestFakerInternet < Test::Unit::TestCase
+
+  def setup
+    @tester = Faker::Internet
+  end
+
+  def test_email
+    assert @tester.email.match(/.+@.+\.\w+/)
+  end
+
+  def test_free_email
+    assert @tester.free_email.match(/.+@(gmail|hotmail|yahoo)\.com/)
+  end
+
+  def test_safe_email
+    assert @tester.safe_email.match(/.+@example.(com|net|org)/)
+  end
+
+  def test_user_name
+    assert @tester.user_name.match(/[a-z]+((_|\.)[a-z]+)?/)
+  end
+
+  def test_user_name_with_string_arg
+    assert @tester.user_name('bo peep').match(/(bo(_|\.)peep|peep(_|\.)bo)/)
+  end
+
+  def test_user_name_with_integer_arg
+    (1..32).each do |min_length|
+      assert @tester.user_name(min_length).length >= min_length
+    end
+  end
+
+  def test_user_name_with_closed_range_arg
+    (1..32).each do |min_length|
+      (min_length..32).each do |max_length|
+        l = @tester.user_name((min_length..max_length)).length
+        assert l >= min_length
+        assert l <= max_length
+      end
+    end
+  end
+
+  def test_user_name_with_open_range_arg
+    (1..32).each do |min_length|
+      (min_length+1..33).each do |max_length|
+        l = @tester.user_name((min_length...max_length)).length
+        assert l >= min_length
+        assert l <= max_length-1
+      end
+    end
+  end
+
+  def test_user_name_with_range_and_separators
+    (1..32).each do |min_length|
+      (min_length+1..33).each do |max_length|
+        u = @tester.user_name((min_length...max_length), %w(=))
+        assert u.length.between? min_length, max_length-1
+        assert u.match(/\A[a-z]+((=)?[a-z]*)*\z/)
+      end
+    end
+  end
+
+  def test_password
+    assert @tester.password.match(/\w{3}/)
+  end
+
+  def test_password_with_integer_arg
+    (1..32).each do |min_length|
+      assert @tester.password(min_length).length >= min_length
+    end
+  end
+
+  def test_password_max_with_integer_arg
+    (1..32).each do |min_length|
+      max_length = min_length + 4
+      assert @tester.password(min_length, max_length).length <= max_length
+    end
+  end
+
+  def test_domain_name
+    assert @tester.domain_name.match(/\w+\.\w+/)
+  end
+
+  def test_domain_word
+    assert @tester.domain_word.match(/^\w+$/)
+  end
+
+  def test_domain_suffix
+    assert @tester.domain_suffix.match(/^\w+(\.\w+)?/)
+  end
+
+  def test_ip_v4_address
+    assert_equal 3, @tester.ip_v4_address.count('.')
+
+    1000.times do
+      assert @tester.ip_v4_address.split('.').map{|octet| octet.to_i}.max <= 255
+    end
+  end
+
+  def test_mac_address
+    assert_equal 5, @tester.mac_address.count(':')
+    assert_equal 5, @tester.mac_address("").count(':')
+
+    1000.times do
+      assert @tester.mac_address.split(':').map{|d| d.to_i(16)}.max <= 255
+    end
+
+    assert @tester.mac_address("fa:fa:fa").start_with?("fa:fa:fa")
+    assert @tester.mac_address("01:02").start_with?("01:02")
+  end
+
+  def test_ip_v6_address
+    assert_equal 7, @tester.ip_v6_address.count(':')
+
+    1000.times do
+      assert @tester.ip_v6_address.split('.').map{|h| "0x#{h}".hex}.max <= 65535
+    end
+  end
+
+  def test_slug
+    assert @tester.slug.match(/^[a-z]+(_|\.|\-)[a-z]+$/)
+  end
+
+  def test_slug_with_content_arg
+    assert @tester.slug('Foo bAr baZ').match(/^foo(_|\.|\-)bar(_|\.|\-)baz$/)
+  end
+
+  def test_slug_with_glue_arg
+    assert @tester.slug(nil, '+').match(/^[a-z]+\+[a-z]+$/)
+  end
+
+  def test_url
+    assert @tester.url('domain.com', '/username').match(/^http:\/\/domain\.com\/username$/)
+  end
+
+  def test_device_token
+    assert_equal 64, @tester.device_token.size
+  end
+
+  def test_fix_umlauts
+    assert_equal "aeoeuess", FactoryHelper::Internet.fix_umlauts('äöüß')
+  end
+end

data/test/legacy/test_faker_lorem.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestFakerLorem < Test::Unit::TestCase
+
+  def setup
+    @tester = Faker::Lorem
+    @standard_wordlist = I18n.translate('factory_helper.lorem.words')
+    @complete_wordlist =
+      @standard_wordlist + I18n.translate('factory_helper.lorem.supplemental')
+  end
+
+  def test_character
+    assert @tester.character.length == 1
+  end
+
+  def test_character_type
+    assert @tester.character.class == String
+  end
+
+  def test_characters
+    assert @tester.characters.length == 255
+  end
+
+  def test_characters_with_args
+    1000.times { assert @tester.characters(500).length == 500 }
+  end
+
+  # Words delivered by a standard request should be on the standard wordlist.
+  def test_standard_words
+    @words = @tester.words(1000)
+    @words.each {|w| assert @standard_wordlist.include?(w) }
+  end
+
+  # Words requested from the supplemental list should all be in that list.
+  def test_supplemental_words
+    @words = @tester.words(10000, true)
+    @words.each {|w| assert @complete_wordlist.include?(w) }
+  end
+
+  # Faker::Lorem.word generates random word from standart wordlist
+  def test_word
+    @tester = Faker::Lorem
+    @standard_wordlist = I18n.translate('factory_helper.lorem.words')
+    1000.times { assert @standard_wordlist.include?(@tester.word) }
+  end
+
+  def test_exact_count_param
+    assert(@tester.characters(2).length == 2)
+    assert(@tester.words(2).length == 2)
+    assert(@tester.sentences(2).length == 2)
+    assert(@tester.paragraphs(2).length == 2)
+  end
+
+  def test_range_count_param
+    cs = @tester.characters(2..5)
+    ws = @tester.words(2..5)
+    ss = @tester.sentences(2..5)
+    ps = @tester.paragraphs(2..5)
+
+    assert(2 <= cs.length && cs.length <= 5)
+    assert(2 <= ws.length && ws.length <= 5)
+    assert(2 <= ss.length && ss.length <= 5)
+    assert(2 <= ps.length && ps.length <= 5)
+  end
+
+  def test_array_count_param
+    cs = @tester.characters([1,4])
+    ws = @tester.words([1,4])
+    ss = @tester.sentences([1,4])
+    ps = @tester.paragraphs([1,4])
+
+    assert(cs.length == 1 || cs.length == 4)
+    assert(ws.length == 1 || ws.length == 4)
+    assert(ss.length == 1 || ss.length == 4)
+    assert(ps.length == 1 || ps.length == 4)
+  end
+
+  def test_words_with_large_count_params
+    exact = @tester.words(500)
+    range = @tester.words(250..500)
+    array = @tester.words([250, 500])
+
+    assert(exact.length == 500)
+    assert(250 <= range.length && range.length <= 500)
+    assert(array.length == 250 || array.length == 500)
+  end
+end

data/test/legacy/test_faker_name.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
+
+class TestFakerName < Test::Unit::TestCase
+
+  def setup
+    @tester = Faker::Name
+  end
+
+  def test_name
+    assert @tester.name.match(/(\w+\.? ?){2,3}/)
+  end
+
+  def test_prefix
+    assert @tester.prefix.match(/[A-Z][a-z]+\.?/)
+  end
+
+  def test_suffix
+    assert @tester.suffix.match(/[A-Z][a-z]*\.?/)
+  end
+end

data/test/legacy/test_faker_number.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
+
+class TestFakerNumber < Test::Unit::TestCase
+  def setup
+    @tester = Faker::Number
+  end
+
+  def test_number
+    assert @tester.number(10).match(/[0-9]{10}/)
+
+    10.times do |digits|
+      digits += 1
+      assert @tester.number(digits).match(/^[0-9]{#{digits}}$/)
+    end
+
+    assert @tester.number(10).length == 10
+    assert @tester.number(1).length == 1
+    assert @tester.number(0) == ""
+  end
+
+  def test_decimal
+    assert @tester.decimal(2).match(/[0-9]{2}\.[0-9]{2}/)
+    assert @tester.decimal(4, 5).match(/[0-9]{4}\.[0-9]{5}/)
+  end
+
+  def test_digit
+    assert @tester.digit.match(/[0-9]{1}/)
+    assert (1..1000).collect {|i| @tester.digit == "9"}.include?(true)
+  end
+
+  def test_between
+    100.times do
+      random_number = @tester.between(-50, 50)
+      assert random_number >= -50, "Expected >= -50, but got #{random_number}"
+      assert random_number <=  50, "Expected <= 50, but got #{random_number}"
+    end
+  end
+
+  def test_positive
+    100.times do
+      random_number = @tester.positive(1, 100)
+      assert random_number >= 1,   "Expected >= 1, but got #{random_number}"
+      assert random_number <= 100, "Expected <= 100, but got #{random_number}"
+    end
+  end
+
+  def test_negative
+    100.times do
+      random_number = @tester.negative(-1, -100)
+      assert random_number <= -1,   "Expected <= -1, but got #{random_number}"
+      assert random_number >= -100, "Expected >= -100, but got #{random_number}"
+    end
+  end
+
+  def test_force_positive
+    random_number = @tester.positive(-1, -100)
+    assert random_number >= 1,   "Expected >= 1, but got #{random_number}"
+    assert random_number <= 100, "Expected <= 100, but got #{random_number}"
+  end
+
+  def test_force_negative
+    random_number = @tester.negative(1, 100)
+    assert random_number <= -1,   "Expected <= -1, but got #{random_number}"
+    assert random_number >= -100, "Expected >= -100, but got #{random_number}"
+  end
+
+  def test_parameters_order
+    random_number = @tester.between(100, 1)
+    assert random_number >= 1,   "Expected >= 1, but got #{random_number}"
+    assert random_number <= 100, "Expected <= 100, but got #{random_number}"
+  end
+
+  def test_hexadecimal
+    assert @tester.hexadecimal(4).match(/[0-9a-f]{4}/)
+    assert @tester.hexadecimal(7).match(/[0-9a-f]{7}/)
+  end
+end

data/test/legacy/test_faker_street.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestFakerStreet < Test::Unit::TestCase
+  def setup
+    I18n.reload!
+    shire = {
+      :factory_helper => {
+        :address => {
+          :street_name => ['#{street_prefix} #{street_root} #{street_suffix}'],
+          :street_prefix => ["Wide"],
+          :street_root => ["Cheerful"],
+          :street_suffix => ["Path"],
+          :secondary_address => ["(Green Door)"],
+          :street_address => ['#{street_name} #{building_number}'],
+          :building_number => ["#"],
+          :time_zone => ["Pacific/Pago_Pago"],
+        }
+      }
+    }
+    I18n.backend.store_translations(:shire, shire)
+  end
+
+  def test_street_name_supports_flexible_formats
+    I18n.with_locale(:shire) do
+      assert_equal "Wide Cheerful Path", Faker::Address.street_name
+    end
+  end
+
+  def test_street_address_supports_flexible_formats
+    I18n.with_locale(:shire) do
+      assert_match(/Wide Cheerful Path \d/, Faker::Address.street_address)
+    end
+  end
+
+  def test_street_address_optionally_provides_secondary_address
+    I18n.with_locale(:shire) do
+      assert_match(/Wide Cheerful Path \d \(Green Door\)/, Faker::Address.street_address(:include_secondary))
+    end
+  end
+
+  def test_street_address_with_locale_fallback
+    I18n.with_locale('en-GB') do
+      assert_match(/^\d+ [\w']+ \w+/, Faker::Address.street_address)
+    end
+  end
+
+  def test_timezone_support
+    I18n.with_locale(:shire) do
+      assert_equal "Pacific/Pago_Pago", Faker::Address.time_zone
+    end
+  end
+
+end

data/test/legacy/test_faker_team.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
+
+class TestFakerTeam < Test::Unit::TestCase
+
+  def setup
+    @tester = Faker::Team
+  end
+
+  def test_name
+    assert @tester.name.match(/(\w+\.? ?){2}/)
+  end
+
+end

data/test/legacy/test_faker_time.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper.rb')
+
+class TestFakerTime < Test::Unit::TestCase
+  def setup
+    @tester      = Faker::Time
+    @time_ranges = Faker::Time::TIME_RANGES
+  end
+
+  def test_between
+    from = Time.local(2012, 01, 01,  0,  0,  0)
+    to   = Time.local(2013, 01, 01, 23, 59, 59)
+
+    100.times do
+      random_time = @tester.between(from, to)
+      assert random_time >= from, "Expected >= \"#{from}\", but got #{random_time}"
+      assert random_time <= to  , "Expected <= \"#{to}\", but got #{random_time}"
+    end
+  end
+
+  def test_forward
+    today = Date.today
+
+    100.times do
+      random_time = @tester.forward(10)
+      assert random_time > today.to_time, "Expected > \"#{today}\", but got #{random_time}"
+    end
+  end
+
+  def test_backward
+    tomorrow = Date.today + 1
+
+    100.times do
+      random_time = @tester.backward(10)
+      assert random_time < tomorrow.to_time, "Expected < \"#{tomorrow}\", but got #{random_time}"
+    end
+  end
+
+  def test_invalid_period_error
+    from = Date.today
+    to   = Date.today + 15
+
+    assert_raise ArgumentError do
+      @tester.between(from, to, :invalid_period)
+    end
+  end
+
+  def test_return_type
+    random_backward = @tester.backward(5)
+    random_between  = @tester.between(Date.today, Date.today + 5)
+    random_forward  = @tester.forward(5)
+
+    [random_backward, random_between, random_forward].each do |result|
+      assert result.is_a?(Time), "Expected a Time object, but got #{result.class}"
+    end
+  end
+
+  def test_time_period
+    from = Date.today
+    to   = Date.today + 15
+
+    100.times do
+      period          = @time_ranges.keys.to_a.sample
+      period_range    = @time_ranges[period]
+
+      random_backward = @tester.backward(30, period)
+      random_between  = @tester.between(from, to, period)
+      random_forward  = @tester.forward(30, period)
+
+      [random_backward, random_between, random_forward].each do |result|
+        assert period_range.include?(result.hour.to_i), "\"#{result.hour}\" expected to be included in Faker::Time::TIME_RANGES[:#{period}] range"
+      end
+    end
+  end
+end