ffaker 1.32.1 → 2.0.0

data/test/test_name_nb.rb

@@ -5,23 +5,23 @@ require 'helper'
 class TestFakerNameNB < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameNB
+    @tester = FFaker::NameNB
   end
 
   def test_last_name
-    assert Faker::NameNB::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameNB::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name_male
-    assert Faker::NameNB::FIRST_NAMES_MALE.include?(@tester.first_name_male)
+    assert FFaker::NameNB::FIRST_NAMES_MALE.include?(@tester.first_name_male)
   end
 
   def test_first_name_female
-    assert Faker::NameNB::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert FFaker::NameNB::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
   end
 
   def test_prefix
-    assert Faker::NameNB::PREFIXES.include?(@tester.prefix)
+    assert FFaker::NameNB::PREFIXES.include?(@tester.prefix)
   end
 
   def test_first_name

data/test/test_name_nl.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameNL < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameNL
+    @tester = FFaker::NameNL
   end
 
   def test_name

data/test/test_name_ph.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNamePH < Test::Unit::TestCase
   def setup
-    @tester = Faker::NamePH
+    @tester = FFaker::NamePH
   end
 
   def test_name

data/test/test_name_ru.rb

@@ -4,7 +4,7 @@ require 'helper'
 
 class TestFakerNameRu < Test::Unit::TestCase
   def setup
-    @tester = Faker::NameRU
+    @tester = FFaker::NameRU
   end
 
   def test_name
@@ -23,7 +23,7 @@ class TestFakerNameRu < Test::Unit::TestCase
   end
 
   def test_male_last_name
-    assert Faker::NameRU::LAST_NAMES[:male].include?(@tester.last_name(:male))
+    assert FFaker::NameRU::LAST_NAMES[:male].include?(@tester.last_name(:male))
   end
 
   def test_first_name
@@ -31,7 +31,7 @@ class TestFakerNameRu < Test::Unit::TestCase
   end
 
   def test_male_first_name
-    assert Faker::NameRU::FIRST_NAMES[:male].include?(@tester.first_name(:male))
+    assert FFaker::NameRU::FIRST_NAMES[:male].include?(@tester.first_name(:male))
   end
 
   def test_patronymic
@@ -39,7 +39,7 @@ class TestFakerNameRu < Test::Unit::TestCase
   end
 
   def test_male_patronymic
-    assert Faker::NameRU::PATRONYMICS[:male].include?(@tester.patronymic(:male))
+    assert FFaker::NameRU::PATRONYMICS[:male].include?(@tester.patronymic(:male))
   end
 
   def test_with_same_sex
@@ -66,7 +66,7 @@ class TestFakerNameRu < Test::Unit::TestCase
   def same_sex?(words, sex = :any)
     (sex == :any ? [:male, :female] : [sex]).any? do |sex|
       words.all? do |word|
-        [Faker::NameRU::LAST_NAMES, Faker::NameRU::FIRST_NAMES, Faker::NameRU::PATRONYMICS].any? do |names|
+        [FFaker::NameRU::LAST_NAMES, FFaker::NameRU::FIRST_NAMES, FFaker::NameRU::PATRONYMICS].any? do |names|
           names[sex].include?(word)
         end
       end

data/test/test_name_se.rb

@@ -5,23 +5,23 @@ require 'helper'
 class TestFakerNameSE < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameSE
+    @tester = FFaker::NameSE
   end
 
   def test_last_name
-    assert Faker::NameSE::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameSE::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name_male
-    assert Faker::NameSE::FIRST_NAMES_MALE.include?(@tester.first_name_male)
+    assert FFaker::NameSE::FIRST_NAMES_MALE.include?(@tester.first_name_male)
   end
 
   def test_first_name_female
-    assert Faker::NameSE::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert FFaker::NameSE::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
   end
 
   def test_prefix
-    assert Faker::NameSE::PREFIXES.include?(@tester.prefix)
+    assert FFaker::NameSE::PREFIXES.include?(@tester.prefix)
   end
 
   def test_first_name

data/test/test_name_sn.rb

@@ -6,27 +6,27 @@ require 'helper'
 class TestFakerNameSn < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameSN
+    @tester = FFaker::NameSN
   end
 
   def test_last_name
-    assert Faker::NameSN::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameSN::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name_male
-    assert Faker::NameSN::FIRST_NAMES_MALE.include?(@tester.first_name_male)
+    assert FFaker::NameSN::FIRST_NAMES_MALE.include?(@tester.first_name_male)
   end
 
   def test_first_name_female
-    assert Faker::NameSN::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert FFaker::NameSN::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
   end
 
   def test_prefix_male
-    assert Faker::NameSN::PREFIX_MALE.include?(@tester.prefix_male)
+    assert FFaker::NameSN::PREFIX_MALE.include?(@tester.prefix_male)
   end
 
   def test_prefix_female
-    assert Faker::NameSN::PREFIX_FEMALE.include?(@tester.prefix_female)
+    assert FFaker::NameSN::PREFIX_FEMALE.include?(@tester.prefix_female)
   end
 
   def test_name_male
@@ -35,20 +35,20 @@ class TestFakerNameSn < Test::Unit::TestCase
 
     if parts.count == 3
       # the value at the index 0 should be a valid! male_prefix
-      assert Faker::NameSN::PREFIX_MALE.include?(parts[0])
+      assert FFaker::NameSN::PREFIX_MALE.include?(parts[0])
 
       # the value at the index 1 should be a valid! male_first_name
-      assert Faker::NameSN::FIRST_NAMES_MALE.include?(parts[1])
+      assert FFaker::NameSN::FIRST_NAMES_MALE.include?(parts[1])
 
       # the value at the index 2 should be a valid! last_name
-      assert Faker::NameSN::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameSN::LAST_NAMES.include?(parts[2])
 
     elsif parts.count == 2
       # the value at the index 0 should be a valid! male_prefix
-      assert Faker::NameSN::FIRST_NAMES_MALE.include?(parts[0])
+      assert FFaker::NameSN::FIRST_NAMES_MALE.include?(parts[0])
 
       # the value at the index 1 should be a valid! last_name
-      assert Faker::NameSN::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameSN::LAST_NAMES.include?(parts[1])
     end
   end
 
@@ -58,19 +58,19 @@ class TestFakerNameSn < Test::Unit::TestCase
 
     if parts.count == 3
       # the value at the index 0 should be a valid! male_prefix
-      assert Faker::NameSN::PREFIX_FEMALE.include?(parts[0])
+      assert FFaker::NameSN::PREFIX_FEMALE.include?(parts[0])
 
       # the value at the index 1 should be a valid! male_first_name
-      assert Faker::NameSN::FIRST_NAMES_FEMALE.include?(parts[1])
+      assert FFaker::NameSN::FIRST_NAMES_FEMALE.include?(parts[1])
 
       # the value at the index 2 should be a valid! last_name
-      assert Faker::NameSN::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameSN::LAST_NAMES.include?(parts[2])
     elsif parts.count == 2
       # the value at the index 0 should be a valid! male_prefix
-      assert Faker::NameSN::FIRST_NAMES_FEMALE.include?(parts[0])
+      assert FFaker::NameSN::FIRST_NAMES_FEMALE.include?(parts[0])
 
       # the value at the index 1 should be a valid! last_name
-      assert Faker::NameSN::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameSN::LAST_NAMES.include?(parts[1])
     end
   end
 
@@ -80,19 +80,19 @@ class TestFakerNameSn < Test::Unit::TestCase
 
     if parts.count == 3
       # the value at the index 0 should be a valid! male or female prefix
-      assert Faker::NameSN::PREFIX_FEMALE.include?(parts[0]) || Faker::NameSN::PREFIX_MALE.include?(parts[0])
+      assert FFaker::NameSN::PREFIX_FEMALE.include?(parts[0]) || FFaker::NameSN::PREFIX_MALE.include?(parts[0])
 
       # the value at the index 1 should be a valid! firstname male or female
-      assert Faker::NameSN::FIRST_NAMES_FEMALE.include?(parts[1]) || Faker::NameSN::FIRST_NAMES_MALE.include?(parts[1])
+      assert FFaker::NameSN::FIRST_NAMES_FEMALE.include?(parts[1]) || FFaker::NameSN::FIRST_NAMES_MALE.include?(parts[1])
 
       # the value at the index 2 should be a valid! firstname male or female
-      assert Faker::NameSN::LAST_NAMES.include?(parts[2])
+      assert FFaker::NameSN::LAST_NAMES.include?(parts[2])
     elsif parts.count == 2
       # the value at the index 0 should be a valid! firstname male or female
-      assert Faker::NameSN::FIRST_NAMES_FEMALE.include?(parts[0]) || Faker::NameSN::FIRST_NAMES_MALE.include?(parts[0])
+      assert FFaker::NameSN::FIRST_NAMES_FEMALE.include?(parts[0]) || FFaker::NameSN::FIRST_NAMES_MALE.include?(parts[0])
 
       # the value at the index 0 should be a valid! firstname male or female
-      assert Faker::NameSN::LAST_NAMES.include?(parts[1])
+      assert FFaker::NameSN::LAST_NAMES.include?(parts[1])
     end
   end
 end

data/test/test_name_th.rb

@@ -5,25 +5,25 @@ require 'helper'
 class TestFakerNameTH < Test::Unit::TestCase
 
   def setup
-    @tester = Faker::NameTH
+    @tester = FFaker::NameTH
   end
 
   def test_last_name
-    assert Faker::NameTH::LAST_NAMES.include?(@tester.last_name)
+    assert FFaker::NameTH::LAST_NAMES.include?(@tester.last_name)
   end
 
   def test_first_name
-    assert Faker::NameTH::FIRST_NAMES.include?(@tester.first_name)
+    assert FFaker::NameTH::FIRST_NAMES.include?(@tester.first_name)
   end
 
   def test_nick_name
-    assert Faker::NameTH::NICK_NAMES.include?(@tester.nick_name)
+    assert FFaker::NameTH::NICK_NAMES.include?(@tester.nick_name)
   end
 
   def test_name
     parts = @tester.name.split(' ')
-    assert Faker::NameTH::FIRST_NAMES.include?(parts[0])
-    assert Faker::NameTH::LAST_NAMES.include?(parts[1])
+    assert FFaker::NameTH::FIRST_NAMES.include?(parts[0])
+    assert FFaker::NameTH::LAST_NAMES.include?(parts[1])
   end
 
 end

data/test/test_nato_alphabet.rb

@@ -4,19 +4,19 @@ require 'helper'
 
 class TestNato < Test::Unit::TestCase
   def setup
-    @tester = Faker::NatoAlphabet
+    @tester = FFaker::NatoAlphabet
   end
 
   def test_code
-    assert Faker::NatoAlphabet::CODES.include?(@tester.code)
+    assert FFaker::NatoAlphabet::CODES.include?(@tester.code)
   end
 
   def test_letter_code
-    assert Faker::NatoAlphabet::ALPHABET_CODES.include?(@tester.alphabetic_code)
+    assert FFaker::NatoAlphabet::ALPHABET_CODES.include?(@tester.alphabetic_code)
   end
 
   def test_numerify_code
-    assert Faker::NatoAlphabet::NUMERIC_CODES.include?(@tester.numeric_code)
+    assert FFaker::NatoAlphabet::NUMERIC_CODES.include?(@tester.numeric_code)
   end
 
   def test_callsign
@@ -26,6 +26,6 @@ class TestNato < Test::Unit::TestCase
   def test_codify
     assert_match /[A-Z]+-[A-Z]+-[A-Z]+/, @tester.codify("?-?-?")
     assert_match /[A-Z]+-[A-Z]+-[A-Z]+/, @tester.codify("?-#-?")
-    assert_match Faker::NatoAlphabet::STOP_CODE, @tester.codify(".")
+    assert_match FFaker::NatoAlphabet::STOP_CODE, @tester.codify(".")
   end
 end

data/test/test_phone_number.rb

@@ -4,10 +4,10 @@ require 'helper'
 
 class TestPhoneNumer < Test::Unit::TestCase
   def test_phone_number
-    assert_match /\d{3}[. -]\d{3}/, Faker::PhoneNumber.phone_number
+    assert_match /\d{3}[. -]\d{3}/, FFaker::PhoneNumber.phone_number
   end
 
   def test_short_phone_number
-    assert_match /\d{3}-\d{3}-\d{4}/, Faker::PhoneNumber.short_phone_number
+    assert_match /\d{3}-\d{3}-\d{4}/, FFaker::PhoneNumber.short_phone_number
   end
 end

data/test/test_phone_number_au.rb

@@ -5,46 +5,46 @@ require 'helper'
 # Author: wiseleyb<wiseleyb@gmail.com>
 class TestPhoneNumberAU < Test::Unit::TestCase
   def setup
-    @tester = Faker::PhoneNumberAU
+    @tester = FFaker::PhoneNumberAU
   end
 
   def test_mobile_phone_prefix
-    assert Faker::PhoneNumberAU::MobileOperatorsPrefix.include?(@tester.mobile_phone_prefix)
+    assert FFaker::PhoneNumberAU::MobileOperatorsPrefix.include?(@tester.mobile_phone_prefix)
   end
 
   def test_home_work_phone_prefix
-    assert Faker::PhoneNumberAU::HomeWorkOperatorsPrefix.include?(@tester.home_work_phone_prefix)
+    assert FFaker::PhoneNumberAU::HomeWorkOperatorsPrefix.include?(@tester.home_work_phone_prefix)
   end
 
   def test_phone_prefix
-    assert Faker::PhoneNumberAU::OperatorsPrefix.include?(@tester.phone_prefix)
+    assert FFaker::PhoneNumberAU::OperatorsPrefix.include?(@tester.phone_prefix)
   end
 
   def test_mobile_phone_number
-    assert_match /04\d{2} \d{3} \d{3}/, Faker::PhoneNumberAU.mobile_phone_number
+    assert_match /04\d{2} \d{3} \d{3}/, FFaker::PhoneNumberAU.mobile_phone_number
   end
 
   def test_home_work_phone_number
-    assert_match /\(\d{2}\) \d{4} \d{4}/, Faker::PhoneNumberAU.home_work_phone_number
+    assert_match /\(\d{2}\) \d{4} \d{4}/, FFaker::PhoneNumberAU.home_work_phone_number
   end
 
   def test_phone_number
     10.times do
-      assert_match /(04\d{1,2} \d{3} \d{3}|\(\d{2}\) \d{4} \d{4})/, Faker::PhoneNumberAU.phone_number
+      assert_match /(04\d{1,2} \d{3} \d{3}|\(\d{2}\) \d{4} \d{4})/, FFaker::PhoneNumberAU.phone_number
     end
   end
 
   def test_international_mobile_phone_number
-    assert_match /\+61 \d{1,2} \d{4} \d{4}/, Faker::PhoneNumberAU.international_mobile_phone_number
+    assert_match /\+61 \d{1,2} \d{4} \d{4}/, FFaker::PhoneNumberAU.international_mobile_phone_number
   end
 
   def test_international_home_work_phone_number
-    assert_match /\+61 \d{1,2} \d{4} \d{4}/, Faker::PhoneNumberAU.international_home_work_phone_number
+    assert_match /\+61 \d{1,2} \d{4} \d{4}/, FFaker::PhoneNumberAU.international_home_work_phone_number
   end
 
   def test_international_phone_number
     10.times do
-      assert_match /\+61 \d{1,2} \d{4} \d{4}/, Faker::PhoneNumberAU.international_phone_number
+      assert_match /\+61 \d{1,2} \d{4} \d{4}/, FFaker::PhoneNumberAU.international_phone_number
     end
   end
 end

data/test/test_phone_number_cu.rb

@@ -5,24 +5,24 @@ require 'helper'
 # Author: Luilver<luilver@gmail.com>
 class TestPhoneNumberCU < Test::Unit::TestCase
   def setup
-    @tester = Faker::PhoneNumberCU
+    @tester = FFaker::PhoneNumberCU
   end
 
   # Prefix format test
   #
   def test_mobile_phone_prefix
-    assert Faker::PhoneNumberCU::MobileOperatorsPrefix.include?(
+    assert FFaker::PhoneNumberCU::MobileOperatorsPrefix.include?(
       @tester.mobile_phone_prefix)
   end
 
   def test_home_work_phone_prefix
-    assert Faker::PhoneNumberCU::HomeWorkOperatorsPrefix.include?(
+    assert FFaker::PhoneNumberCU::HomeWorkOperatorsPrefix.include?(
       @tester.home_work_phone_prefix)
   end
 
   def test_phone_prefix
     10.times do
-      assert Faker::PhoneNumberCU::OperatorsPrefix.include?(
+      assert FFaker::PhoneNumberCU::OperatorsPrefix.include?(
         @tester.phone_prefix)
     end
   end
@@ -31,18 +31,18 @@ class TestPhoneNumberCU < Test::Unit::TestCase
   #
   def test_mobile_phone_number
     assert_match /05 \d{3} \d{4}/,
-      Faker::PhoneNumberCU.mobile_phone_number
+      FFaker::PhoneNumberCU.mobile_phone_number
   end
 
   def test_home_work_phone_number
     assert_match /\(0(7\) \d{3}|\d{2}\) \d{2}) \d{4}/,
-      Faker::PhoneNumberCU.home_work_phone_number
+      FFaker::PhoneNumberCU.home_work_phone_number
   end
 
   def test_general_phone_number
     10.times do
       assert_match /((05|\(07\)) \d{3}|\(0\d{2}\) \d{2}) \d{4}/,
-        Faker::PhoneNumberCU.general_phone_number
+        FFaker::PhoneNumberCU.general_phone_number
     end
   end
 
@@ -50,18 +50,18 @@ class TestPhoneNumberCU < Test::Unit::TestCase
   #
   def test_international_mobile_phone_number
     assert_match /(00|\+)535 \d{3} \d{4}/,
-      Faker::PhoneNumberCU.international_mobile_phone_number
+      FFaker::PhoneNumberCU.international_mobile_phone_number
   end
 
   def test_international_home_work_phone_number
     assert_match /(00|\+)53(7 \d{3}|\d{2} \d{2}) \d{4}/,
-      Faker::PhoneNumberCU.international_home_work_phone_number
+      FFaker::PhoneNumberCU.international_home_work_phone_number
   end
 
   def test_international_phone_number
     10.times do
       assert_match /(00|\+)53((5|7) \d{3}|\d{2} \d{2}) \d{4}/,
-        Faker::PhoneNumberCU.international_phone_number
+        FFaker::PhoneNumberCU.international_phone_number
     end
   end
 
@@ -69,18 +69,18 @@ class TestPhoneNumberCU < Test::Unit::TestCase
   #
   def test_e164_mobile_phone_number
     assert_match /535\d{7}/,
-      Faker::PhoneNumberCU.e164_mobile_phone_number
+      FFaker::PhoneNumberCU.e164_mobile_phone_number
   end
 
   def test_e164_home_work_phone_number
     assert_match /53(7\d{7}|\d{2}\d{6})/,
-      Faker::PhoneNumberCU.e164_home_work_phone_number
+      FFaker::PhoneNumberCU.e164_home_work_phone_number
   end
 
   def test_e164_phone_number
     10.times do
       assert_match /53((5|7)\d{7}|\d{2}\d{6})/,
-        Faker::PhoneNumberCU.e164_phone_number
+        FFaker::PhoneNumberCU.e164_phone_number
     end
   end
 end