ffaker 1.32.1 → 2.0.0

data/test/test_address_de.rb

@@ -4,22 +4,22 @@ require 'helper'
 
 class TestAddressDE < Test::Unit::TestCase
   def test_city
-    assert_match /[ a-z]+/, Faker::AddressDE.city
+    assert_match /[ a-z]+/, FFaker::AddressDE.city
   end
 
   def test_state
-    assert_match /[ a-z]/, Faker::AddressDE.state
+    assert_match /[ a-z]/, FFaker::AddressDE.state
   end
 
   def test_zip_code
-    assert_match /^\d{5}$/, Faker::AddressDE.zip_code
+    assert_match /^\d{5}$/, FFaker::AddressDE.zip_code
   end
 
   def test_street_name
-    assert_match /[ a-z]+/, Faker::AddressDE.street_name
+    assert_match /[ a-z]+/, FFaker::AddressDE.street_name
   end
 
   def test_street_address
-    assert_match /[ a-z]+/, Faker::AddressDE.street_address
+    assert_match /[ a-z]+/, FFaker::AddressDE.street_address
   end
 end

data/test/test_address_fi.rb

@@ -4,23 +4,23 @@ require 'helper'
 
 # Test features related to Finnish addresses
 class TestAddressFI < Test::Unit::TestCase
-  ALPHA = /\A[[:alpha:]]+/
+  ALPHA = /\A[\p{Alpha}]+/
   DIGIT = /\d{1}/
 
   def test_fi_city
-    assert_match ALPHA, Faker::AddressFI.city
+    assert_match ALPHA, FFaker::AddressFI.city
   end
 
   def test_fi_zip_code
-    assert_match(/\d{2}/, Faker::AddressFI.zip_code)
+    assert_match(/\d{2}/, FFaker::AddressFI.zip_code)
   end
 
   def test_countries
-    assert Faker::AddressFI::COUNTRIES.include?(Faker::AddressFI.random_country)
+    assert FFaker::AddressFI::COUNTRIES.include?(FFaker::AddressFI.random_country)
   end
 
   def test_fi_full_address
-    address = Faker::AddressFI.full_address
+    address = FFaker::AddressFI.full_address
     assert_match ALPHA, address
     assert_match DIGIT, address
     assert_match(/SUOMI/, address)
@@ -28,6 +28,6 @@ class TestAddressFI < Test::Unit::TestCase
   end
 
   def test_fi_zip_code_frozen
-    assert Faker::AddressFI.zip_code.frozen? == false
+    assert FFaker::AddressFI.zip_code.frozen? == false
   end
 end

data/test/test_address_mx.rb

@@ -5,22 +5,22 @@ require 'helper'
 # Author: guapolo github.com/guapolo
 class TestAddressMX < Test::Unit::TestCase
   def test_mx_state
-    assert_match /[\sa-z]/i, Faker::AddressMX.state
+    assert_match /[\sa-z]/i, FFaker::AddressMX.state
   end
 
   def test_mx_state_abbr
-    assert_match /[A-Z]/, Faker::AddressMX.state_abbr
+    assert_match /[A-Z]/, FFaker::AddressMX.state_abbr
   end
 
   def test_postal_code
-    assert_match /[0-9]/, Faker::AddressMX.postal_code
+    assert_match /[0-9]/, FFaker::AddressMX.postal_code
   end
 
   def test_zip_code
-    assert_match /[0-9]/, Faker::AddressMX.zip_code
+    assert_match /[0-9]/, FFaker::AddressMX.zip_code
   end
 
   def test_mx_municipality
-    assert_match /[\sa-z]/i, Faker::AddressMX.municipality
+    assert_match /[\sa-z]/i, FFaker::AddressMX.municipality
   end
 end

data/test/test_address_nl.rb

@@ -5,7 +5,7 @@ require 'helper'
 class TestAddressNL < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::AddressNL
+    @tester = FFaker::AddressNL
   end
 
   def test_city

data/test/test_address_se.rb

@@ -4,23 +4,23 @@ require 'helper'
 
 class TestAddressSE < Test::Unit::TestCase
 
-  ALPHA = /\A[[:alpha:]]+/
+  ALPHA = /\A[\p{Alpha}]+/
   DIGIT = /\d{1}/
 
   def test_se_city
-    assert_match ALPHA, Faker::AddressSE.city
+    assert_match ALPHA, FFaker::AddressSE.city
   end
 
   def test_se_zip_code
-    assert_match(/\d{2}/, Faker::AddressSE.zip_code)
+    assert_match(/\d{2}/, FFaker::AddressSE.zip_code)
   end
 
   def test_countries
-    assert Faker::AddressSE::COUNTRIES.include?(Faker::AddressSE.random_country)
+    assert FFaker::AddressSE::COUNTRIES.include?(FFaker::AddressSE.random_country)
   end
 
   def test_se_full_address
-    address = Faker::AddressSE.full_address
+    address = FFaker::AddressSE.full_address
     assert_match ALPHA, address
     assert_match DIGIT, address
     assert_match(/SVERIGE/, address)
@@ -28,6 +28,6 @@ class TestAddressSE < Test::Unit::TestCase
   end
 
   def test_se_zip_code_frozen
-    assert Faker::AddressSE.zip_code.frozen? == false
+    assert FFaker::AddressSE.zip_code.frozen? == false
   end
 end

data/test/test_address_sn.rb

@@ -8,18 +8,18 @@ require "helper"
 class TestAddressSn < Test::Unit::TestCase
 
   def setup
-    @subject = Faker::AddressSN
+    @subject = FFaker::AddressSN
   end
 
   def test_region
-    assert Faker::AddressSN::REGIONS.include?(Faker::AddressSN.region)
+    assert FFaker::AddressSN::REGIONS.include?(FFaker::AddressSN.region)
   end
 
   def test_departement
-    assert Faker::AddressSN::DEPARTEMENTS.include?(Faker::AddressSN.departement)
+    assert FFaker::AddressSN::DEPARTEMENTS.include?(FFaker::AddressSN.departement)
   end
 
   def test_arrondissement
-    assert Faker::AddressSN::ARRONDISSEMENTS.include?(Faker::AddressSN.arrondissement)
+    assert FFaker::AddressSN::ARRONDISSEMENTS.include?(FFaker::AddressSN.arrondissement)
   end
 end

data/test/test_address_uk.rb

@@ -4,14 +4,14 @@ require 'helper'
 
 class TestAddressUK < Test::Unit::TestCase
   def test_county
-    assert_match /[ a-z]/, Faker::AddressUK.county
+    assert_match /[ a-z]/, FFaker::AddressUK.county
   end
 
   def test_country
-    assert_match /[ a-z]/, Faker::AddressUK.country
+    assert_match /[ a-z]/, FFaker::AddressUK.country
   end
 
   def test_postcode
-    assert_match /^[A-Z]{2}\d \d[A-Z]{2}|[A-Z]{2}\d\d \d[A-Z]{2}$/, Faker::AddressUK.postcode
+    assert_match /^[A-Z]{2}\d \d[A-Z]{2}|[A-Z]{2}\d\d \d[A-Z]{2}$/, FFaker::AddressUK.postcode
   end
 end

data/test/test_address_us.rb

@@ -4,30 +4,30 @@ require 'helper'
 
 class TestAddressUSUS < Test::Unit::TestCase
   def test_us_state
-    assert_match /[ a-z]/, Faker::AddressUS.state
+    assert_match /[ a-z]/, FFaker::AddressUS.state
   end
 
   def test_us_state_abbr
-    assert_match /[A-Z]/, Faker::AddressUS.state_abbr
+    assert_match /[A-Z]/, FFaker::AddressUS.state_abbr
   end
 
   def test_us_state_and_territories_abbr
-    assert_match /[A-Z]/, Faker::AddressUS.state_and_territories_abbr
+    assert_match /[A-Z]/, FFaker::AddressUS.state_and_territories_abbr
   end
 
   def test_us_continental_state
-    assert_match /[ a-z]/, Faker::AddressUS.continental_state
+    assert_match /[ a-z]/, FFaker::AddressUS.continental_state
   end
 
   def test_us_continental_state_abbr
-    assert_match /[A-Z]/, Faker::AddressUS.continental_state_abbr
+    assert_match /[A-Z]/, FFaker::AddressUS.continental_state_abbr
   end
 
   def test_zip_code
-    assert_match /[0-9]/, Faker::AddressUS.zip_code
+    assert_match /[0-9]/, FFaker::AddressUS.zip_code
   end
 
   def test_zip_code_frozen
-    assert Faker::AddressUS.zip_code.frozen? == false
+    assert FFaker::AddressUS.zip_code.frozen? == false
   end
 end

data/test/test_array_utils.rb

@@ -5,7 +5,7 @@ require 'set'
 
 class TestArrayUtils < Test::Unit::TestCase
   def setup
-    @array = Faker::ArrayUtils.const_array("a".."c")
+    @array = FFaker::ArrayUtils.const_array("a".."c")
     @elems = Set.new("a".."c")
   end
 

data/test/test_bacon_ipsum.rb

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

data/test/test_boolean.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestBoolean < Test::Unit::TestCase
   def test_maybe
-    maybe = Faker::Boolean.maybe
+    maybe = FFaker::Boolean.maybe
     assert (maybe == false || maybe == true)
   end
 end

data/test/test_color.rb

@@ -4,6 +4,6 @@ require 'helper'
 
 class TestColor < Test::Unit::TestCase
   def test_name
-    assert_match /\A[a-z]+\z/, Faker::Color.name
+    assert_match /\A[a-z]+\z/, FFaker::Color.name
   end
 end

data/test/test_company.rb

@@ -4,20 +4,20 @@ require 'helper'
 
 class TestCompany < Test::Unit::TestCase
   def test_bs
-    assert_match /[ a-z]+/, Faker::Company.bs
-    assert_match /\s/, Faker::Company.bs
+    assert_match /[ a-z]+/, FFaker::Company.bs
+    assert_match /\s/, FFaker::Company.bs
   end
 
   def test_catch_phrase
-    assert_match /[ a-z]+/, Faker::Company.catch_phrase
-    assert_match /\s/, Faker::Company.catch_phrase
+    assert_match /[ a-z]+/, FFaker::Company.catch_phrase
+    assert_match /\s/, FFaker::Company.catch_phrase
   end
 
   def test_name
-    assert_match /[ a-z]+/, Faker::Company.name
+    assert_match /[ a-z]+/, FFaker::Company.name
   end
 
   def test_suffix
-    assert_match /[ a-z]+/i, Faker::Company.suffix
+    assert_match /[ a-z]+/i, FFaker::Company.suffix
   end
 end

data/test/test_company_it.rb

@@ -5,14 +5,14 @@ require 'helper'
 class TestCompanyIT < Test::Unit::TestCase
 
   def test_name
-    assert_match(/[ a-z]+/, Faker::CompanyIT.name)
+    assert_match(/[ a-z]+/, FFaker::CompanyIT.name)
   end
 
   def test_suffix
-    assert_match(/[ a-z]+/i, Faker::CompanyIT.suffix)
+    assert_match(/[ a-z]+/i, FFaker::CompanyIT.suffix)
   end
-  
+
     def test_prefix
-    assert_match(/[ a-z]+/i, Faker::CompanyIT.prefix)
+    assert_match(/[ a-z]+/i, FFaker::CompanyIT.prefix)
   end
 end

data/test/test_company_se.rb

@@ -5,10 +5,10 @@ require 'helper'
 class TestCompanySE < Test::Unit::TestCase
 
   def test_name
-    assert_match(/[ a-z]+/, Faker::CompanySE.name)
+    assert_match(/[ a-z]+/, FFaker::CompanySE.name)
   end
 
   def test_suffix
-    assert_match(/[ a-z]+/i, Faker::CompanySE.suffix)
+    assert_match(/[ a-z]+/i, FFaker::CompanySE.suffix)
   end
 end

data/test/test_conference.rb

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

data/test/test_course_mathematiques.rb

@@ -2,7 +2,7 @@ require "helper"
 
 class TestCourseMathematiques < Test::Unit::TestCase
   def setup
-    @subject = Faker::CoursesFR::Mathematiques
+    @subject = FFaker::CoursesFR::Mathematiques
   end
 
   def test_lesson

data/test/test_course_philosophie.rb

@@ -2,7 +2,7 @@ require "helper"
 
 class TestCoursePhilosophie < Test::Unit::TestCase
   def setup
-    @subject = Faker::CoursesFR::Philosophie
+    @subject = FFaker::CoursesFR::Philosophie
   end
 
   def test_lesson

data/test/test_dizzle_ipsum.rb

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

data/test/test_education.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerEducation < Test::Unit::TestCase
   def setup
-    @tester = Faker::Education
+    @tester = FFaker::Education
   end
 
   def test_degree_short

data/test/test_faker.rb

@@ -4,27 +4,27 @@ require 'helper'
 
 class TestFaker < Test::Unit::TestCase
   def test_numerify
-    assert Faker.numerify('###').match(/\d{3}/)
+    assert FFaker.numerify('###').match(/\d{3}/)
   end
 
   def test_numerify_with_array
-    assert Faker.numerify(['###', '###']).match(/\d{3}/)
+    assert FFaker.numerify(['###', '###']).match(/\d{3}/)
   end
 
   def test_letterify
-    assert Faker.letterify('???').match(/[a-z]{3}/)
+    assert FFaker.letterify('???').match(/[a-z]{3}/)
   end
 
   def test_letterify_with_array
-    assert Faker.letterify(['???', '???']).match(/[a-z]{3}/)
+    assert FFaker.letterify(['???', '???']).match(/[a-z]{3}/)
   end
 
   def test_bothify
-    assert Faker.bothify('???###').match(/[a-z]{3}\d{3}/)
+    assert FFaker.bothify('???###').match(/[a-z]{3}\d{3}/)
   end
 
   def test_bothify_with_array
-    assert Faker.bothify(['???###', '???###']).match(/[a-z]{3}\d{3}/)
+    assert FFaker.bothify(['???###', '???###']).match(/[a-z]{3}\d{3}/)
   end
 
 end