ffaker 1.15.0 → 1.16.0

data/test/test_address_au.rb

@@ -6,8 +6,8 @@ class TestAddressAU < Test::Unit::TestCase
   
   def test_au_state_abbr
     arr = Faker::AddressAU::STATE_ABBR.sort
-    assert arr = Faker::AddressAU::CITY.keys.sort
-    assert arr = Faker::AddressAU::ZIP_CODE.keys.sort
+    assert arr = Faker::AddressAU::SUBURB.keys.sort
+    assert arr = Faker::AddressAU::POSTCODE.keys.sort
   end
   
   def test_au_state
@@ -18,14 +18,10 @@ class TestAddressAU < Test::Unit::TestCase
     assert_match /[A-Z]/, Faker::AddressAU.state_abbr
   end
 
-  def test_au_city
-    assert_match /[a-zA-Z]/, Faker::AddressAU.city
+  def test_au_suburb
+    assert_match /[a-zA-Z]/, Faker::AddressAU.suburb
   end
   
-  def test_zip_code
-    assert_match /\d{4}/, Faker::AddressAU.zip_code
-  end
-
   def test_postcode
     assert_match /\d{4}/, Faker::AddressAU.postcode
   end
@@ -34,19 +30,19 @@ class TestAddressAU < Test::Unit::TestCase
     assert_match /[\, a-z]/, Faker::AddressAU.full_address
   end
   
-  def test_zip_code_frozen
-    assert Faker::AddressAU.zip_code.frozen? == false
+  def test_postcode_frozen
+    assert Faker::AddressAU.postcode.frozen? == false
   end
 
-  def test_au_city_with_states
+  def test_au_suburb_with_states
     Faker::AddressAU::STATE_ABBR.each do |st_abbr|
-      assert_match /[a-zA-Z]/, Faker::AddressAU.city(st_abbr)
+      assert_match /[a-zA-Z]/, Faker::AddressAU.suburb(st_abbr)
     end
   end
 
-  def test_zip_code_with_states
+  def test_postcode_with_states
     Faker::AddressAU::STATE_ABBR.each do |st_abbr|
-      assert_match /\d{4}/, Faker::AddressAU.zip_code(st_abbr)
+      assert_match /\d{4}/, Faker::AddressAU.postcode(st_abbr)
     end
   end
 

data/test/test_address_de.rb

@@ -12,4 +12,12 @@ class TestAddressDE < Test::Unit::TestCase
   def test_zip_code
     assert_match /^\d{5}$/, Faker::AddressDE.zip_code
   end
+
+  def test_street_name
+    assert_match /[ a-z]+/, Faker::AddressDE.street_name
+  end
+
+  def test_street_address
+    assert_match /[ a-z]+/, Faker::AddressDE.street_address
+  end
 end

data/test/test_address_mx.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# => author: guapolo github.com/guapolo
+require 'helper'
+
+class TestAddressMX < Test::Unit::TestCase
+  def setup
+    @tester = Faker::AddressMX
+  end
+  
+  def test_mx_state
+    assert_match /[ A-Za-z]/, @tester.state
+  end
+
+  def test_mx_state_abbr
+    assert_match /[A-Z]/, @tester.state_abbr
+  end
+
+  def test_postcode
+    assert_match /[0-9]/, @tester.zip_code
+  end
+  
+  def test_mx_municipality
+    assert_match /[ a-z]/, @tester.municipality
+  end
+end

data/test/test_address_se.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'helper'
+
+class TestAddressSE < Test::Unit::TestCase
+
+  ALPHA = /\A[[:alpha:]]+/
+  DIGIT = /\d{1}/
+
+  def test_se_city
+    assert_match ALPHA, Faker::AddressSE.city
+  end
+
+  def test_se_zip_code
+    assert_match(/\d{2}/, Faker::AddressSE.zip_code)
+  end
+
+  def test_countries
+    assert Faker::AddressSE::COUNTRIES.include?(Faker::AddressSE.random_country)
+  end
+
+  def test_se_full_address
+    address = Faker::AddressSE.full_address
+    assert_match ALPHA, address
+    assert_match DIGIT, address
+    assert_match(/SVERIGE/, address)
+  end
+
+  def test_se_zip_code_frozen
+    assert Faker::AddressSE.zip_code.frozen? == false
+  end
+
+  def test_se_full_address
+    assert_match(/[\, a-z]/, Faker::AddressSE.full_address)
+  end
+
+end

data/test/test_company_se.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require 'helper'
+
+class TestCompanySE < Test::Unit::TestCase
+
+  def test_name
+    assert_match(/[ a-z]+/, Faker::CompanySE.name)
+  end
+
+  def test_suffix
+    assert_match(/[ a-z]+/i, Faker::CompanySE.suffix)
+  end
+
+end

data/test/test_conference.rb

@@ -0,0 +1,8 @@
+require 'helper'
+
+class TestConference < Test::Unit::TestCase
+  def test_name
+    assert_match /1\+|[ a-z]+/i, Faker::Conference.name
+  end
+end
+

data/test/test_dizzle_ipsum.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class TestDizzleIpsum < Test::Unit::TestCase
+
+  def test_paragraph
+    assert_match /1\+|[ a-z]+/i, Faker::DizzleIpsum.paragraph
+  end
+
+  def test_sentence
+    assert_match /1\+|[ a-z]+/i, Faker::DizzleIpsum.sentence
+  end
+
+  def test_paragraphs
+    assert_match /1\+|[ a-z]+/i, Faker::DizzleIpsum.paragraphs.join(" ")
+  end
+
+  def test_sentences
+    assert_match /1\+|[ a-z]+/i, Faker::DizzleIpsum.sentences.join(" ")
+  end
+
+  def test_words
+    assert_match /1\+|[ a-z]+/i, Faker::DizzleIpsum.words.join(" ")
+  end
+
+  def test_word
+    assert_match /1\+|[a-z]+/i, Faker::DizzleIpsum.word
+  end
+end

data/test/test_faker.rb

@@ -10,18 +10,34 @@ class TestFaker < Test::Unit::TestCase
   end
 
   def test_letterify
-    assert Faker.letterify('???').match(/[a-z]{3}/)
+    assert Faker.letterify(false, '???').match(/[a-z]{3}/)
+  end
+
+  def test_capital_letterify
+    assert Faker.letterify(true, '???').match(/[A-Z]{3}/)
   end
 
   def test_letterify_with_array
-    assert Faker.letterify(['???', '???']).match(/[a-z]{3}/)
+    assert Faker.letterify(false, ['???', '???']).match(/[a-z]{3}/)
   end
 
+  def test_capital_letterify_with_array
+      assert Faker.letterify(true, ['???', '???']).match(/[A-Z]{3}/)
+    end
+
   def test_bothify
     assert Faker.bothify('???###').match(/[a-z]{3}\d{3}/)
   end
 
-  def test_bothify
-    assert Faker.bothify(['???###', '???###']).match(/[a-z]{3}\d{3}/)
+  def test_capital_bothify
+    assert Faker.bothify(true, '???###').match(/[A-Z]{3}\d{3}/)
+  end
+
+  def test_bothify_with_array
+    assert Faker.bothify(false, ['???###', '???###']).match(/[a-z]{3}\d{3}/)
+  end
+
+  def test_capital_bothify_with_array
+    assert Faker.bothify(true, ['???###', '???###']).match(/[A-Z]{3}\d{3}/)
   end
 end

data/test/test_faker_internet_se.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+require 'helper'
+
+class TestFakerInternetSE < Test::Unit::TestCase
+
+  def setup
+    @tester = Faker::InternetSE
+  end
+
+  def test_email
+    assert @tester.email.match(/.+@.+\.\w+/)
+  end
+
+  def test_email_frozen
+    assert @tester.email.frozen? == false
+  end
+
+  def test_disposable_email
+    assert @tester.disposable_email.match(/.+@(mailinator\.com|suremail\.info|spamherelots\.com|binkmail\.com|safetymail\.info)/)
+  end
+
+  def test_free_email
+    email = @tester.free_email
+    assert email.match(/.+@(gmail\.com|hotmail\.com|yahoo\.com|spray\.se|passagen\.se)/), "mail: #{email} does not match"
+  end
+
+  def test_login_user_name
+    assert @tester.login_user_name.match(/[a-z]+((_|)[a-z]+)?/)
+  end
+
+  def test_user_name
+    assert @tester.user_name.match(/[a-z]+((_|\.)[a-z]+)?/)
+  end
+
+  def test_user_name_with_arg
+    assert @tester.user_name('joel larsson').match(/(joel(_|\.)larsson|larsson(_|\.)joel)/)
+  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_uri
+    assert @tester.uri("ftp").match(/^ftp:\/\/.+/)
+    assert @tester.uri("http").match(/^http:\/\/.+/)
+    assert @tester.uri("https").match(/^https:\/\/.+/)
+  end
+
+  def test_http_url
+    assert @tester.http_url.match(/^http:\/\/.+/)
+  end
+
+  def test_ip_v4_address
+    assert @tester.ip_v4_address.match(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/)
+  end
+
+end
+

data/test/test_faker_name_ga.rb

@@ -0,0 +1,54 @@
+require 'helper'
+
+class TestFakerNameGa < Test::Unit::TestCase
+	
+	def setup
+		@tester = Faker::NameGA
+	end
+
+	def test_last_name
+		assert Faker::NameGA::LAST_NAMES.include?(@tester.last_name)
+	end
+
+	def test_first_name_male
+		assert Faker::NameGA::FIRST_NAMES_MALE.include?(@tester.first_name_male)
+	end
+
+	def test_first_name_female
+		assert Faker::NameGA::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+	end
+
+  def test_name_male
+    # => split the name_male into an array of words
+    parts = @tester.name_male.split(' ')
+
+	# the value at the index 0 should be a valid! male_prefix
+	assert Faker::NameGA::FIRST_NAMES_MALE.include?(parts[0])
+
+	# the value at the index 1 should be a valid! last_name
+	assert Faker::NameGA::LAST_NAMES.include?(parts[1])
+  end	
+
+  def test_name_female
+    # => split the name_male into an array of words
+    parts = @tester.name_female.split(' ')
+
+	# the value at the index 0 should be a valid! male_prefix
+	assert Faker::NameGA::FIRST_NAMES_FEMALE.include?(parts[0])
+
+	# the value at the index 1 should be a valid! last_name
+	assert Faker::NameGA::LAST_NAMES.include?(parts[1])
+  end	
+
+
+  def test_name
+    # => split the name_male into an array of words
+    parts = @tester.name.split(' ')
+
+	# the value at the index 0 should be a valid! male_prefix
+	assert Faker::NameGA::FIRST_NAMES_FEMALE.include?(parts[0]) || Faker::NameGA::FIRST_NAMES_MALE.include?(parts[0])
+
+	# the value at the index 1 should be a valid! last_name
+	assert Faker::NameGA::LAST_NAMES.include?(parts[1])
+  end
+end

data/test/test_faker_name_mx.rb

@@ -0,0 +1,177 @@
+# encoding: utf-8
+# => author: guapolo github.com/guapolo
+require 'helper'
+
+class TestFakerNameMX < Test::Unit::TestCase
+  def setup
+    @tester = Faker::NameMX
+  end
+
+  def test_last_name
+    assert Faker::NameMX::LAST_NAMES.include?(@tester.last_name)
+  end
+  
+  def test_first_name
+    assert Faker::NameMX::FIRST_NAMES.include?(@tester.first_name)
+  end
+  
+  def test_middle_name
+    assert Faker::NameMX::FIRST_NAMES.include?(@tester.middle_name)
+  end
+  
+  def test_name
+    assert Faker::NameMX::FIRST_NAMES.include?(@tester.name)
+  end
+
+  def test_prefix_male
+    assert Faker::NameMX::MALE_PREFIXES.include?(@tester.male_prefix)
+  end
+
+  def test_prefix_female
+    assert Faker::NameMX::FEMALE_PREFIXES.include?(@tester.female_prefix)
+  end
+  
+  def test_prefix
+    assert Faker::NameMX::PREFIXES.include?(@tester.prefix)
+  end
+
+  def test_male_name
+    parts = @tester.male_name.split(' ')
+    case parts.count
+      when 1 then assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+      when 2 then assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0]) &&
+        Faker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+    end
+  end
+
+  def test_female_name
+    parts = @tester.female_name.split(' ')
+    case parts.count
+      when 1 then assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+      when 2 then assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0]) &&
+        Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+    end
+  end
+
+  def test_full_name_male
+    parts = @tester.full_name(:male).split(' ')
+    case parts.count
+    when 5
+      assert Faker::NameMX::MALE_PREFIXES.include?(parts[0])
+      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+      # Middle name
+      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+    when 4
+      prefix_or_first_name = Faker::NameMX::MALE_PREFIXES.include?(parts[0]) ||
+        Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+      assert prefix_or_first_name
+      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+    when 3
+      assert Faker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+    else
+      flunk "Invalid Male Name"
+    end
+  end
+
+  def test_full_name_female
+    parts = @tester.full_name(:female).split(' ')
+    case parts.count
+    when 5
+      assert Faker::NameMX::FEMALE_PREFIXES.include?(parts[0])
+      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+      # Middle name
+      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+    when 4
+      prefix_or_first_name = Faker::NameMX::FEMALE_PREFIXES.include?(parts[0]) ||
+        Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+      assert prefix_or_first_name
+      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+    when 3
+      assert Faker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+    else
+      flunk "Invalid Female Name"
+    end
+  end
+
+  def test_full_name
+    parts = @tester.full_name.split(' ')
+    case parts.count
+    when 5
+      assert Faker::NameMX::PREFIXES.include?(parts[0])
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[1])
+      # Middle name
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+    when 4
+      prefix_or_first_name = Faker::NameMX::PREFIXES.include?(parts[0]) ||
+        Faker::NameMX::FIRST_NAMES.include?(parts[0])
+      assert prefix_or_first_name
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+    when 3
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[0])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+    else
+      flunk "Invalid Name"
+    end
+  end
+  
+  def test_full_name_no_prefix
+    parts = @tester.full_name_no_prefix.split(' ')
+    case parts.count
+    when 4
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[0])
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+    when 3
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[0])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+    else
+      flunk "Invalid Name"
+    end
+  end
+  
+  def test_full_name_prefix
+    parts = @tester.full_name_prefix.split(' ')
+    case parts.count
+    when 5
+      assert Faker::NameMX::PREFIXES.include?(parts[0])
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[1])
+      # Middle name
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[4])
+    when 4
+      prefix_or_first_name = Faker::NameMX::PREFIXES.include?(parts[0]) ||
+        Faker::NameMX::FIRST_NAMES.include?(parts[0])
+      assert prefix_or_first_name
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[3])
+    when 3
+      assert Faker::NameMX::FIRST_NAMES.include?(parts[0])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[1])
+      assert Faker::NameMX::LAST_NAMES.include?(parts[2])
+    else
+      flunk "Invalid Name"
+    end
+  end
+
+end