ffaker 2.0.0 → 2.1.0

data/test/test_name_cs.rb

@@ -9,7 +9,7 @@ class TestFakerNameCS < Test::Unit::TestCase
 
   def test_name
     @words = @tester.name.split
-    assert [2,3,4].include?(@words.size) # just name, or prefix, or prefix+suffix
+    assert_include([2, 3, 4], @words.size) # just name, or prefix, or prefix+suffix
   end
 
   def test_name_sex
@@ -19,19 +19,19 @@ class TestFakerNameCS < Test::Unit::TestCase
   end
 
   def test_male_last_name
-    assert FFaker::NameCS::LAST_NAMES[:male].include?(@tester.last_name(:male))
+    assert_include(@tester::LAST_NAMES[:male], @tester.last_name(:male))
   end
 
   def test_male_first_name
-    assert FFaker::NameCS::FIRST_NAMES[:male].include?(@tester.first_name(:male))
+    assert_include(@tester::FIRST_NAMES[:male], @tester.first_name(:male))
   end
 
   def test_prefix
-    assert FFaker::NameCS::PREFIXES.include?(@tester.prefix)
+    assert_include(@tester::PREFIXES, @tester.prefix)
   end
 
   def test_suffix
-    assert FFaker::NameCS::SUFFIXES.include?(@tester.suffix)
+    assert_include(@tester::SUFFIXES, @tester.suffix)
   end
 
   def test_with_same_sex
@@ -52,11 +52,13 @@ class TestFakerNameCS < Test::Unit::TestCase
     assert same_sex?(names, :male)
   end
 
+  private
+
   # checks if every name is of the same sex
   def same_sex?(words, sex = :any)
     (sex == :any ? [:male, :female] : [sex]).any? do |sex|
       words.all? do |word|
-        [FFaker::NameCS::LAST_NAMES, FFaker::NameCS::FIRST_NAMES].any? do |names|
+        [@tester::LAST_NAMES, @tester::FIRST_NAMES].any? do |names|
           names[sex].include?(word)
         end
       end

data/test/test_name_de.rb

@@ -8,14 +8,14 @@ class TestFakerNameDE < Test::Unit::TestCase
   end
 
   def test_name
-    assert @tester.name.match(/(\w+\.? ?){2,3}/)
+    assert_match(/\A([\w']+\.? ?){2,3}\z/, @tester.name)
   end
 
   def test_prefix
-    assert @tester.prefix.match(/[A-Z][a-z]+\.?/)
+    assert_match(/\A[A-Z][a-z]+\.?\z/, @tester.prefix)
   end
 
   def test_suffix
-    assert @tester.suffix.match(/[A-Z][a-z]*\.?/)
+    assert_include(@tester::SUFFIXES, @tester.suffix)
   end
 end

data/test/test_name_fr.rb

@@ -4,45 +4,43 @@ require 'helper'
 
 # Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameFR < Test::Unit::TestCase
-
   def setup
     @tester = FFaker::NameFR
   end
 
   def test_last_name
-    assert FFaker::NameFR::LAST_NAMES.include?(@tester.last_name)
+    assert_include @tester::LAST_NAMES, @tester.last_name
   end
 
   def test_first_name
-    assert FFaker::NameFR::FIRST_NAMES.include?(@tester.first_name)
+    assert_include @tester::FIRST_NAMES, @tester.first_name
   end
 
   def test_prefix
-    assert FFaker::NameFR::PREFIX.include?(@tester.prefix)
+    assert_include @tester::PREFIX, @tester.prefix
   end
 
-
   def test_name
     # => split the name into an array of words
     parts = @tester.name.split(' ')
-
-    if parts.count == 3
+    case parts.count
+    when 3
+      first_name, prefix, last_name = parts
       # the value at the index 1 should be a valid! prefix
-      assert FFaker::NameFR::PREFIX.include?(parts[1])
+      assert_include @tester::PREFIX, prefix
 
-      # the value at the index 0 should be a valid! male_first_name
-      assert FFaker::NameFR::FIRST_NAMES.include?(parts[0])
+      # the value at the index 0 should be a valid! first_name
+      assert_include @tester::FIRST_NAMES, first_name
 
       # the value at the index 2 should be a valid! last_name
-      assert FFaker::NameFR::LAST_NAMES.include?(parts[2])
-
-    elsif parts.count == 2
-      # the value at the index 0 should be a valid! prefix
-      assert FFaker::NameFR::FIRST_NAMES.include?(parts[0])
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      first_name, last_name = parts
+      # the value at the index 0 should be a valid! first_name
+      assert_include @tester::FIRST_NAMES, first_name
 
       # the value at the index 1 should be a valid! last_name
-      assert FFaker::NameFR::LAST_NAMES.include?(parts[1])
+      assert_include @tester::LAST_NAMES, last_name
     end
   end
-
 end

data/test/test_name_ga.rb

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

data/test/test_name_it.rb

@@ -4,45 +4,44 @@ require 'helper'
 
 # Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameIT < Test::Unit::TestCase
-
   def setup
     @tester = FFaker::NameIT
   end
 
   def test_last_name
-    assert FFaker::NameIT::LAST_NAMES.include?(@tester.last_name)
+    assert_include @tester::LAST_NAMES, @tester.last_name
   end
 
   def test_first_name
-    assert FFaker::NameIT::FIRST_NAMES.include?(@tester.first_name)
+    assert_include @tester::FIRST_NAMES, @tester.first_name
   end
 
   def test_prefix
-    assert FFaker::NameIT::PREFIX.include?(@tester.prefix)
+    assert_include @tester::PREFIX, @tester.prefix
   end
 
-
   def test_name
     # => split the name into an array of words
     parts = @tester.name.split(' ')
 
-    if parts.count == 3
+    case parts.count
+    when 3
+      prefix, first_name, last_name = parts
       # the value at the index 0 should be a valid! prefix
-      assert FFaker::NameIT::PREFIX.include?(parts[0])
+      assert_include @tester::PREFIX, prefix
 
       # the value at the index 1 should be a valid! first_name
-      assert FFaker::NameIT::FIRST_NAMES.include?(parts[1])
+      assert_include @tester::FIRST_NAMES, first_name
 
       # the value at the index 2 should be a valid! last_name
-      assert FFaker::NameIT::LAST_NAMES.include?(parts[2])
-
-    elsif parts.count == 2
-      # the value at the index 0 should be a valid! prefix
-      assert FFaker::NameIT::FIRST_NAMES.include?(parts[0])
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      first_name, last_name = parts
+      # the value at the index 0 should be a valid! first_name
+      assert_include @tester::FIRST_NAMES, first_name
 
       # the value at the index 1 should be a valid! last_name
-      assert FFaker::NameIT::LAST_NAMES.include?(parts[1])
+      assert_include @tester::LAST_NAMES, last_name
     end
   end
-
 end

data/test/test_name_ja.rb

@@ -8,6 +8,6 @@ class TestFakerNameJA < Test::Unit::TestCase
   end
 
   def test_name
-    assert FFaker::NameJA.name.length >= 2
+    assert @tester.name.length >= 2
   end
 end

data/test/test_name_mx.rb

@@ -4,55 +4,58 @@ require 'helper'
 
 # Author: guapolo github.com/guapolo
 class TestFakerNameMX < Test::Unit::TestCase
-
   def setup
     @tester = FFaker::NameMX
-    @all_names = FFaker::NameMX::MALE_FIRST_NAMES + FFaker::NameMX::FEMALE_FIRST_NAMES
+    @all_names = @tester::MALE_FIRST_NAMES + @tester::FEMALE_FIRST_NAMES
   end
 
   def test_last_name
-    assert FFaker::NameMX::LAST_NAMES.include?(@tester.last_name)
+    assert_include @tester::LAST_NAMES, @tester.last_name
   end
 
   def test_first_name
-    assert @all_names.include?(@tester.first_name)
+    assert_include @all_names, @tester.first_name
   end
 
   def test_middle_name
-    assert @all_names.include?(@tester.middle_name)
+    assert_include @all_names, @tester.middle_name
   end
 
   def test_name
-    assert @all_names.include?(@tester.name)
+    assert_include @all_names, @tester.name
   end
 
   def test_prefix_male
-    assert FFaker::NameMX::MALE_PREFIXES.include?(@tester.male_prefix)
+    assert_include @tester::MALE_PREFIXES, @tester.male_prefix
   end
 
   def test_prefix_female
-    assert FFaker::NameMX::FEMALE_PREFIXES.include?(@tester.female_prefix)
+    assert_include @tester::FEMALE_PREFIXES, @tester.female_prefix
   end
 
   def test_prefix
-    assert FFaker::NameMX::PREFIXES.include?(@tester.prefix)
+    assert_include @tester::PREFIXES, @tester.prefix
   end
 
   def test_male_name
     parts = @tester.male_name.split(' ')
     case parts.count
-    when 1 then assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
-    when 2 then assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0]) &&
-      FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+    when 1
+      assert_include @tester::MALE_FIRST_NAMES, parts[0]
+    when 2
+      assert_include @tester::MALE_FIRST_NAMES, parts[0]
+      assert_include @tester::MALE_FIRST_NAMES, parts[1]
     end
   end
 
   def test_female_name
     parts = @tester.female_name.split(' ')
     case parts.count
-    when 1 then assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
-    when 2 then assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0]) &&
-      FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+    when 1
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[0]
+    when 2
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[0]
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[1]
     end
   end
 
@@ -60,25 +63,25 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name(:male).split(' ')
     case parts.count
     when 5
-      assert FFaker::NameMX::MALE_PREFIXES.include?(parts[0])
-      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
+      assert_include @tester::MALE_PREFIXES, parts[0]
+      assert_include @tester::MALE_FIRST_NAMES, parts[1]
       # Middle name
-      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
+      assert_include @tester::MALE_FIRST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
     when 4
-      prefix_or_first_name = FFaker::NameMX::MALE_PREFIXES.include?(parts[0]) ||
-        FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
+      prefix_or_first_name = @tester::MALE_PREFIXES.include?(parts[0]) ||
+                             @tester::MALE_FIRST_NAMES.include?(parts[0])
       assert prefix_or_first_name
-      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert_include @tester::MALE_FIRST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
     when 3
-      assert FFaker::NameMX::MALE_FIRST_NAMES.include?(parts[0])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert_include @tester::MALE_FIRST_NAMES, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
     else
-      flunk "Invalid Male Name"
+      flunk 'Invalid Male Name'
     end
   end
 
@@ -86,25 +89,25 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name(:female).split(' ')
     case parts.count
     when 5
-      assert FFaker::NameMX::FEMALE_PREFIXES.include?(parts[0])
-      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
+      assert_include @tester::FEMALE_PREFIXES, parts[0]
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[1]
       # Middle name
-      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
     when 4
-      prefix_or_first_name = FFaker::NameMX::FEMALE_PREFIXES.include?(parts[0]) ||
-        FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
+      prefix_or_first_name = @tester::FEMALE_PREFIXES.include?(parts[0]) ||
+                             @tester::FEMALE_FIRST_NAMES.include?(parts[0])
       assert prefix_or_first_name
-      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
     when 3
-      assert FFaker::NameMX::FEMALE_FIRST_NAMES.include?(parts[0])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert_include @tester::FEMALE_FIRST_NAMES, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
     else
-      flunk "Invalid Female Name"
+      flunk 'Invalid Female Name'
     end
   end
 
@@ -112,25 +115,25 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name.split(' ')
     case parts.count
     when 5
-      assert FFaker::NameMX::PREFIXES.include?(parts[0])
-      assert @all_names.include?(parts[1])
+      assert_include @tester::PREFIXES, parts[0]
+      assert_include @all_names, parts[1]
       # Middle name
-      assert @all_names.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
+      assert_include @all_names, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
     when 4
-      prefix_or_first_name = FFaker::NameMX::PREFIXES.include?(parts[0]) ||
-        @all_names.include?(parts[0])
+      prefix_or_first_name = @tester::PREFIXES.include?(parts[0]) ||
+                             @all_names.include?(parts[0])
       assert prefix_or_first_name
-      assert @all_names.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert_include @all_names, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
     when 3
-      assert @all_names.include?(parts[0])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert_include @all_names, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
     else
-      flunk "Invalid Name"
+      flunk 'Invalid Name'
     end
   end
 
@@ -138,16 +141,16 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name_no_prefix.split(' ')
     case parts.count
     when 4
-      assert @all_names.include?(parts[0])
-      assert @all_names.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert_include @all_names, parts[0]
+      assert_include @all_names, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
     when 3
-      assert @all_names.include?(parts[0])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert_include @all_names, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
     else
-      flunk "Invalid Name"
+      flunk 'Invalid Name'
     end
   end
 
@@ -155,26 +158,25 @@ class TestFakerNameMX < Test::Unit::TestCase
     parts = @tester.full_name_prefix.split(' ')
     case parts.count
     when 5
-      assert FFaker::NameMX::PREFIXES.include?(parts[0])
-      assert @all_names.include?(parts[1])
+      assert_include @tester::PREFIXES, parts[0]
+      assert_include @all_names, parts[1]
       # Middle name
-      assert @all_names.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[4])
+      assert_include @all_names, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
+      assert_include @tester::LAST_NAMES, parts[4]
     when 4
-      prefix_or_first_name = FFaker::NameMX::PREFIXES.include?(parts[0]) ||
-        @all_names.include?(parts[0])
+      prefix_or_first_name = @tester::PREFIXES.include?(parts[0]) ||
+                             @all_names.include?(parts[0])
       assert prefix_or_first_name
-      assert @all_names.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[3])
+      assert_include @all_names, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
+      assert_include @tester::LAST_NAMES, parts[3]
     when 3
-      assert @all_names.include?(parts[0])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[1])
-      assert FFaker::NameMX::LAST_NAMES.include?(parts[2])
+      assert_include @all_names, parts[0]
+      assert_include @tester::LAST_NAMES, parts[1]
+      assert_include @tester::LAST_NAMES, parts[2]
     else
-      flunk "Invalid Name"
+      flunk 'Invalid Name'
     end
   end
-
 end