ffaker 2.0.0 → 2.1.0

data/test/test_name_nb.rb

@@ -3,36 +3,33 @@
 require 'helper'
 
 class TestFakerNameNB < Test::Unit::TestCase
-
   def setup
     @tester = FFaker::NameNB
   end
 
   def test_last_name
-    assert FFaker::NameNB::LAST_NAMES.include?(@tester.last_name)
+    assert_include @tester::LAST_NAMES, @tester.last_name
   end
 
   def test_first_name_male
-    assert FFaker::NameNB::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::NameNB::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
   end
 
   def test_prefix
-    assert FFaker::NameNB::PREFIXES.include?(@tester.prefix)
+    assert_include @tester::PREFIXES, @tester.prefix
   end
 
   def test_first_name
     parts = @tester.first_name.split(' ')
-    assert [1,2].include? parts.count
+    assert_include [1, 2], parts.count
   end
 
   def test_name
     parts = @tester.name.split(' ')
-    assert [2, 3, 4].include? parts.count
+    assert_include [2, 3, 4], parts.count
   end
-
 end
-

data/test/test_name_nl.rb

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

data/test/test_name_ph.rb

@@ -3,15 +3,25 @@
 require 'helper'
 
 class TestFakerNamePH < Test::Unit::TestCase
+  PH_REGEXP = /\A([\wñÑú-]+\.? ?){2,5}\z/
+
   def setup
     @tester = FFaker::NamePH
   end
 
   def test_name
-    assert @tester.name.match(/(\w+\.? ?){2,3}/)
+    assert_match(PH_REGEXP, @tester.name)
+  end
+
+  def test_last_name
+    assert_match(PH_REGEXP, @tester.last_name)
+  end
+
+  def test_first_name
+    assert_match(PH_REGEXP, @tester.first_name)
   end
 
   def test_prefix
-    assert @tester.prefix.match(/[A-Z][a-z]+\.?/)
+    assert_match(/\A[A-Z][a-z]+\.?\z/, @tester.prefix)
   end
 end

data/test/test_name_ru.rb

@@ -2,15 +2,17 @@
 
 require 'helper'
 
-class TestFakerNameRu < Test::Unit::TestCase
+class TestFakerNameRU < Test::Unit::TestCase
+  RU_REGEX = /[А-Я][а-я]+/
+
   def setup
     @tester = FFaker::NameRU
   end
 
   def test_name
     @words = @tester.name.split
-    assert [2,3].include?(@words.size)
-    assert @words.each { |word| word.match /[А-Я][а-я]+/ }
+    assert_include [2, 3], @words.size
+    assert @words.all? { |word| word.match RU_REGEX }
   end
 
   def test_name_sex
@@ -19,27 +21,27 @@ class TestFakerNameRu < Test::Unit::TestCase
   end
 
   def test_last_name
-    assert @tester.last_name.match(/[А-Я][а-я]+/)
+    assert_match RU_REGEX, @tester.last_name
   end
 
   def test_male_last_name
-    assert FFaker::NameRU::LAST_NAMES[:male].include?(@tester.last_name(:male))
+    assert_include @tester::LAST_NAMES[:male], @tester.last_name(:male)
   end
 
   def test_first_name
-    assert @tester.first_name.match(/[А-Я][а-я]+/)
+    assert_match RU_REGEX, @tester.first_name
   end
 
   def test_male_first_name
-    assert FFaker::NameRU::FIRST_NAMES[:male].include?(@tester.first_name(:male))
+    assert_include @tester::FIRST_NAMES[:male], @tester.first_name(:male)
   end
 
   def test_patronymic
-    assert @tester.patronymic.match(/[А-Я][а-я]+/)
+    assert_match RU_REGEX, @tester.patronymic
   end
 
   def test_male_patronymic
-    assert FFaker::NameRU::PATRONYMICS[:male].include?(@tester.patronymic(:male))
+    assert_include @tester::PATRONYMICS[:male], @tester.patronymic(:male)
   end
 
   def test_with_same_sex
@@ -62,11 +64,13 @@ class TestFakerNameRu < 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::NameRU::LAST_NAMES, FFaker::NameRU::FIRST_NAMES, FFaker::NameRU::PATRONYMICS].any? do |names|
+        [@tester::LAST_NAMES, @tester::FIRST_NAMES, @tester::PATRONYMICS].any? do |names|
           names[sex].include?(word)
         end
       end

data/test/test_name_se.rb

@@ -3,36 +3,33 @@
 require 'helper'
 
 class TestFakerNameSE < Test::Unit::TestCase
-
   def setup
     @tester = FFaker::NameSE
   end
 
   def test_last_name
-    assert FFaker::NameSE::LAST_NAMES.include?(@tester.last_name)
+    assert_include @tester::LAST_NAMES, (@tester.last_name)
   end
 
   def test_first_name_male
-    assert FFaker::NameSE::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::NameSE::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert_include @tester::FIRST_NAMES_FEMALE, (@tester.first_name_female)
   end
 
   def test_prefix
-    assert FFaker::NameSE::PREFIXES.include?(@tester.prefix)
+    assert_include @tester::PREFIXES, (@tester.prefix)
   end
 
   def test_first_name
     parts = @tester.first_name.split(' ')
-    assert [1,2].include? parts.count
+    assert_include [1, 2], parts.count
   end
 
   def test_name
     parts = @tester.name.split(' ')
-    assert [2, 3, 4].include? parts.count
+    assert_include [2, 3, 4], parts.count
   end
-
 end
-

data/test/test_name_sn.rb

@@ -4,95 +4,82 @@ require 'helper'
 
 # Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
 class TestFakerNameSn < Test::Unit::TestCase
-
   def setup
     @tester = FFaker::NameSN
   end
 
   def test_last_name
-    assert FFaker::NameSN::LAST_NAMES.include?(@tester.last_name)
+    assert_include @tester::LAST_NAMES, @tester.last_name
   end
 
   def test_first_name_male
-    assert FFaker::NameSN::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::NameSN::FIRST_NAMES_FEMALE.include?(@tester.first_name_female)
+    assert_include @tester::FIRST_NAMES_FEMALE, @tester.first_name_female
   end
 
   def test_prefix_male
-    assert FFaker::NameSN::PREFIX_MALE.include?(@tester.prefix_male)
+    assert_include @tester::PREFIX_MALE, @tester.prefix_male
   end
 
   def test_prefix_female
-    assert FFaker::NameSN::PREFIX_FEMALE.include?(@tester.prefix_female)
+    assert_include @tester::PREFIX_FEMALE, @tester.prefix_female
   end
 
   def test_name_male
-    # => split the name_male into an array of words
     parts = @tester.name_male.split(' ')
+    assert_include [2, 3], parts.count
 
-    if parts.count == 3
-      # the value at the index 0 should be a valid! male_prefix
-      assert FFaker::NameSN::PREFIX_MALE.include?(parts[0])
-
-      # the value at the index 1 should be a valid! male_first_name
-      assert FFaker::NameSN::FIRST_NAMES_MALE.include?(parts[1])
+    case parts.count
+    when 3
+      male_prefix, male_first_name, last_name = parts
 
-      # the value at the index 2 should be a valid! last_name
-      assert FFaker::NameSN::LAST_NAMES.include?(parts[2])
+      assert_include @tester::PREFIX_MALE, male_prefix
+      assert_include @tester::FIRST_NAMES_MALE, male_first_name
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      male_first_name, last_name = parts
 
-    elsif parts.count == 2
-      # the value at the index 0 should be a valid! male_prefix
-      assert FFaker::NameSN::FIRST_NAMES_MALE.include?(parts[0])
-
-      # the value at the index 1 should be a valid! last_name
-      assert FFaker::NameSN::LAST_NAMES.include?(parts[1])
+      assert_include @tester::FIRST_NAMES_MALE, male_first_name
+      assert_include @tester::LAST_NAMES, last_name
     end
   end
 
   def test_name_female
-    # => split the name_female into an array of words
     parts = @tester.name_female.split(' ')
+    assert_include [2, 3], parts.count
 
-    if parts.count == 3
-      # the value at the index 0 should be a valid! male_prefix
-      assert FFaker::NameSN::PREFIX_FEMALE.include?(parts[0])
-
-      # the value at the index 1 should be a valid! male_first_name
-      assert FFaker::NameSN::FIRST_NAMES_FEMALE.include?(parts[1])
+    case parts.count
+    when 3
+      female_prefix, female_first_name, last_name = parts
 
-      # the value at the index 2 should be a valid! last_name
-      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 FFaker::NameSN::FIRST_NAMES_FEMALE.include?(parts[0])
+      assert_include @tester::PREFIX_FEMALE, female_prefix
+      assert_include @tester::FIRST_NAMES_FEMALE, female_first_name
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      female_first_name, last_name = parts
 
-      # the value at the index 1 should be a valid! last_name
-      assert FFaker::NameSN::LAST_NAMES.include?(parts[1])
+      assert_include @tester::FIRST_NAMES_FEMALE, female_first_name
+      assert_include @tester::LAST_NAMES, last_name
     end
   end
 
   def test_senegalese_name
-    # => split the name into an array of words
     parts = @tester.name_sn.split(' ')
-
-    if parts.count == 3
-      # the value at the index 0 should be a valid! male or female prefix
-      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 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 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 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 FFaker::NameSN::LAST_NAMES.include?(parts[1])
+    assert_include [2, 3], parts.count
+
+    case parts.count
+    when 3
+      prefix, first_name, last_name = parts
+      assert_include(@tester::PREFIX_FEMALE + @tester::PREFIX_MALE, prefix)
+      assert_include(@tester::FIRST_NAMES_FEMALE + @tester::FIRST_NAMES_MALE, first_name)
+      assert_include @tester::LAST_NAMES, last_name
+    when 2
+      first_name, last_name = parts
+      assert_include(@tester::FIRST_NAMES_FEMALE + @tester::FIRST_NAMES_MALE, first_name)
+      assert_include @tester::LAST_NAMES, last_name
     end
   end
 end

data/test/test_name_th.rb

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

data/test/test_phone_number.rb

@@ -10,4 +10,13 @@ class TestPhoneNumer < Test::Unit::TestCase
   def test_short_phone_number
     assert_match /\d{3}-\d{3}-\d{4}/, FFaker::PhoneNumber.short_phone_number
   end
+
+  def test_imei
+    assert_match /^\d{15}$/, FFaker::PhoneNumber.imei
+  end
+
+  def test_imei_with_sn
+    sn = rand(1_000_000)
+    assert_match /^\d{8}#{sprintf('%06d', sn)}\d{1}$/, FFaker::PhoneNumber.imei(sn)
+  end
 end

data/test/test_sports.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestSports < Test::Unit::TestCase
+  def setup
+    @tester = FFaker::Sport
+  end
+
+  def test_name
+    assert_include @tester::NAMES, @tester.name
+  end
+end

data/test/test_string.rb

@@ -6,66 +6,76 @@ class TestString < Test::Unit::TestCase
   FS = FFaker::String
 
   def test_atoms
-    assert_equal "abc", FS.from_regexp(/abc/)
+    assert_equal 'abc', FS.from_regexp(/abc/)
   end
 
   def test_digits
-    assert_match /\d\d\d/, FS.from_regexp(/\d\d\d/)
+    assert_match(/\A\d\d\d\z/, FS.from_regexp(/\d\d\d/))
   end
 
   def test_word_characters
-    assert_match /\w\w\w/, FS.from_regexp(/\w\w\w/)
+    assert_match(/\A\w\w\w\z/, FS.from_regexp(/\w\w\w/))
+  end
+
+  def test_word_range_character
+    assert_match(/\A[a-z]\z/, FS.from_regexp(/[a-z]/))
+  end
+
+  def test_dash_character
+    assert_match(/\A[a-z-]\z/, FS.from_regexp(/[a-z-]/))
+    assert_match(/\A[a-]\z/, FS.from_regexp(/[a-]/))
+    assert_match(/\A[-]\z/, FS.from_regexp(/[-]/))
   end
 
   def test_spaces
-    assert_match /\s\s\s/, FS.from_regexp(/\s\s\s/)
+    assert_match(/\A\s\s\s\z/, FS.from_regexp(/\s\s\s/))
   end
 
   def test_escaped_characters
-    assert_equal "\\/.()[]{}", FS.from_regexp(/\\\/\.\(\)\[\]\{\}/)
+    assert_equal '\\/.()[]{}', FS.from_regexp(/\\\/\.\(\)\[\]\{\}/)
   end
 
   def test_atom_sets
-    assert ['a', 'b', 'c'].include?(FS.from_regexp(/[abc]/))
+    assert_include %w(a b c), FS.from_regexp(/[abc]/)
   end
 
   def test_special_sets
-    assert_match /[\w\d]/, FS.from_regexp(/[\w\d]/)
+    assert_match(/\A[\w\d]\z/, FS.from_regexp(/[\w\d]/))
   end
 
   def test_atom_question
-    assert_match /a?/, FS.from_regexp(/a?/)
+    assert_match(/\Aa?\z/, FS.from_regexp(/a?/))
   end
 
   def test_special_question
-    assert_match /^\w?$/, FS.from_regexp(/\w?/)
+    assert_match(/\A\w?\z/, FS.from_regexp(/\w?/))
   end
 
   def test_set_question
-    assert_match /^[abc]?$/, FS.from_regexp(/[abc]?/)
+    assert_match(/\A[abc]?\z/, FS.from_regexp(/[abc]?/))
   end
 
   def test_atom_plus
-    assert_match /a+/, FS.from_regexp(/a+/)
+    assert_match(/\Aa+\z/, FS.from_regexp(/a+/))
   end
 
   def test_special_plus
-    assert_match /\w+/, FS.from_regexp(/\w+/)
+    assert_match(/\A\w+\z/, FS.from_regexp(/\w+/))
   end
 
   def test_set_plus
-    assert_match /^[abc]+$/, FS.from_regexp(/[abc]+/)
+    assert_match(/\A[abc]+\z/, FS.from_regexp(/[abc]+/))
   end
 
   def test_atom_star
-    assert_match /a*/, FS.from_regexp(/a*/)
+    assert_match(/\Aa*\z/, FS.from_regexp(/a*/))
   end
 
   def test_special_star
-    assert_match /\w*/, FS.from_regexp(/\w*/)
+    assert_match(/\A\w*\z/, FS.from_regexp(/\w*/))
   end
 
   def test_set_star
-    assert_match /^[abc]*$/, FS.from_regexp(/[abc]*/)
+    assert_match(/\A[abc]*\z/, FS.from_regexp(/[abc]*/))
   end
 end