ffakerer 1.0.1

data/test/test_faker_name_ph.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestFakerNamePH < Test::Unit::TestCase
+  def setup
+    @tester = Faker::NamePH
+  end
+
+  def test_name
+    assert @tester.name.match(/(\w+\.? ?){2,3}/)
+  end
+
+  def test_prefix
+    assert @tester.prefix.match(/[A-Z][a-z]+\.?/)
+  end
+end

data/test/test_faker_name_ru.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestFakerNameRu < Test::Unit::TestCase
+  def setup
+    @tester = Faker::NameRU
+  end
+
+  def test_name
+    @words = @tester.name.split
+    assert [2,3].include?(@words.size)
+    assert @words.each { |word| word.match /[А-Я][а-я]+/ }
+  end
+
+  def test_name_sex
+    @words = @tester.name.split
+    assert same_sex?(@words)
+  end
+
+  def test_uniqueness
+    unique_names = (1..10000).map { @tester.name }.uniq.size
+    assert unique_names > 9850, "got only #{unique_names} unique names out of 10000"
+  end
+
+  def test_last_name
+    assert @tester.last_name.match(/[А-Я][а-я]+/)
+  end
+
+  def test_male_last_name
+    assert Faker::NameRU::LAST_NAMES[:male].include?(@tester.last_name(:male))
+  end
+
+  def test_first_name
+    assert @tester.first_name.match(/[А-Я][а-я]+/)
+  end
+
+  def test_male_first_name
+    assert Faker::NameRU::FIRST_NAMES[:male].include?(@tester.first_name(:male))
+  end
+
+  def test_patronymic
+    assert @tester.patronymic.match(/[А-Я][а-я]+/)
+  end
+
+  def test_male_patronymic
+    assert Faker::NameRU::PATRONYMICS[:male].include?(@tester.patronymic(:male))
+  end
+
+  def test_with_same_sex
+    names = []
+    @tester.with_same_sex do
+      names << @tester.last_name
+      names << @tester.first_name
+      names << @tester.patronymic
+    end
+    assert same_sex?(names)
+  end
+
+  def test_with_same_sex_for_male
+    names = []
+    @tester.with_same_sex(:male) do
+      names << @tester.last_name
+      names << @tester.first_name
+      names << @tester.patronymic
+    end
+    assert same_sex?(names, :male)
+  end
+
+  # 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|
+        [Faker::NameRU::LAST_NAMES, Faker::NameRU::FIRST_NAMES, Faker::NameRU::PATRONYMICS].any? do |names|
+          names[sex].include?(word)
+        end
+      end
+    end
+  end
+end

data/test/test_faker_name_se.rb

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

data/test/test_faker_name_sn.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require 'helper'
+
+# Author: PapePathe<pathe.sene@gmail.com> github.com/PapePathe
+class TestFakerNameSn < Test::Unit::TestCase
+
+  def setup
+    @tester = Faker::NameSN
+  end
+
+  def test_last_name
+    assert Faker::NameSN::LAST_NAMES.include?(@tester.last_name)
+  end
+
+  def test_first_name_male
+    assert Faker::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)
+  end
+
+  def test_prefix_male
+    assert Faker::NameSN::PREFIX_MALE.include?(@tester.prefix_male)
+  end
+
+  def test_prefix_female
+    assert Faker::NameSN::PREFIX_FEMALE.include?(@tester.prefix_female)
+  end
+
+  def test_name_male
+    # => split the name_male into an array of words
+    parts = @tester.name_male.split(' ')
+
+    if parts.count == 3
+      # the value at the index 0 should be a valid! male_prefix
+      assert Faker::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])
+
+      # the value at the index 2 should be a valid! last_name
+      assert Faker::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])
+
+      # the value at the index 1 should be a valid! last_name
+      assert Faker::NameSN::LAST_NAMES.include?(parts[1])
+    end
+  end
+
+  def test_name_female
+    # => split the name_female into an array of words
+    parts = @tester.name_female.split(' ')
+
+    if parts.count == 3
+      # the value at the index 0 should be a valid! male_prefix
+      assert Faker::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])
+
+      # the value at the index 2 should be a valid! last_name
+      assert Faker::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])
+
+      # the value at the index 1 should be a valid! last_name
+      assert Faker::NameSN::LAST_NAMES.include?(parts[1])
+    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 Faker::NameSN::PREFIX_FEMALE.include?(parts[0]) || Faker::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])
+
+      # the value at the index 2 should be a valid! firstname male or female
+      assert Faker::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])
+
+      # the value at the index 0 should be a valid! firstname male or female
+      assert Faker::NameSN::LAST_NAMES.include?(parts[1])
+    end
+  end
+end

data/test/test_geolocation.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestGeolocation < Test::Unit::TestCase
+  def test_lat
+    assert_match /[0-9]+/, Faker::Geolocation.lat.to_s
+  end
+
+  def test_lng
+    assert_match /[0-9]+/, Faker::Geolocation.lng.to_s
+  end
+
+  def test_boxed_coords
+    coords_list = [
+      [[1,1], [3,3]],
+      [[12.3455,23.3434], [34.3434,36.34343]],
+      [[12.3455,23.3434], [10.3434,6.34343]]
+    ]
+
+    coords_list.each do |coords|
+      lat_min = [coords[0][0], coords[1][0]].min
+      lat_max = [coords[0][0], coords[1][0]].max
+      lon_min = [coords[0][1], coords[1][1]].min
+      lon_max = [coords[0][1], coords[1][1]].max
+
+      new_coords = Faker::Geolocation.boxed_coords(coords[0], coords[1])
+
+      assert (lat_min..lat_max).include?new_coords[0]
+      assert (lon_min..lon_max).include?new_coords[1]
+    end
+
+  end
+end

data/test/test_healthcare_ipsum.rb

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

data/test/test_hipster_ipsum.rb

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

data/test/test_html_ipsum.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestHTMLIpsum < Test::Unit::TestCase
+  def setup
+    @tester = Faker::HTMLIpsum
+  end
+
+  def test_a
+    assert_match /^<a href="#\w+" title="[ \w]+">[ \w]+<\/a>$/i, Faker::HTMLIpsum.a
+  end
+
+  def test_p
+    # We can't predict the number of times the sentence pattern will repeat
+    # because the Faker::Lorem methods that we are using adds a random
+    # number on top of what we specify for the count argument.
+    assert_match /^<p>([ \w]+\.)+<\/p>$/i, Faker::HTMLIpsum.p
+  end
+
+  def test_p_breaks
+    # Here we can at least test how many <br> tags there are.
+    assert_match /^<p>(?:[ \w\.]+<br>){2}[ \w\.]+<\/p>$/i, Faker::HTMLIpsum.p(3, {:include_breaks => true})
+  end
+
+  def test_p_fancy
+    # We can't predict the number of times the sentence pattern will repeat
+    # because the Faker::Lorem methods that we are using adds a random
+    # number on top of what we specify for the count argument. We also have to
+    # account for the other HTML that is being returned.
+    str = Faker::HTMLIpsum.p(5, {:fancy => true})
+    assert_match /^<p>/, str
+    assert_match /<\/p>$/, str
+    assert str.length > 6, "string contains more than <p></p>"
+  end
+
+  def test_p_fancy_breaks
+    # Here we can at least test how many <br> tags there are. We also have to
+    # account for the other HTML that is being returned.
+    str = Faker::HTMLIpsum.p(10, {:fancy => true, :include_breaks => true})
+    assert_equal 10, str.split("<br>").length
+  end
+
+  def test_dl
+    assert_match /^<dl>(<dt>[ \w]+<\/dt><dd>[ \w.]+<\/dd>){3}<\/dl>$/i, Faker::HTMLIpsum.dl(3)
+  end
+
+  def test_ul_short
+    assert_match /^<ul>(<li>[ \w.]+<\/li>){3}<\/ul>$/i, Faker::HTMLIpsum.ul_short(3)
+  end
+
+  def test_ul_long
+    assert_match /^<ul>(<li>[ \w.]+<\/li>){3}<\/ul>$/i, Faker::HTMLIpsum.ul_long(3)
+  end
+
+  def test_ol_short
+    assert_match /^<ol>(<li>[ \w.]+<\/li>){3}<\/ol>$/i, Faker::HTMLIpsum.ol_short(3)
+  end
+
+  def test_ol_long
+    assert_match /^<ol>(<li>[ \w.]+<\/li>){3}<\/ol>$/i, Faker::HTMLIpsum.ol_long(3)
+  end
+
+  def test_ul_links
+    assert_match /^<ul>(<li><a href="#\w+" title="\w+">[ \w]+<\/a><\/li>){3}<\/ul>$/i, Faker::HTMLIpsum.ul_links(3)
+  end
+
+  def test_table
+    assert_match /(<td>[ \w]+<\/td>\s*){3}/i, Faker::HTMLIpsum.table(3)
+  end
+
+  def test_body
+    # We can't reliably predict what's going to end up inside, so just ensure
+    # that we have a complete string.
+    assert_match /^<h1>.+<\/pre>$/im, Faker::HTMLIpsum.body
+  end
+
+  def test_fancy_string
+    # We can't reliably predict what's going to end up inside, so just ensure
+    # that we have a complete string.
+    assert Faker::HTMLIpsum.fancy_string.is_a?(String), "returns a string"
+    assert Faker::HTMLIpsum.fancy_string.length > 1, "the string is longer than one char"
+  end
+
+  def test_fancy_string_breaks
+    # We can't reliably predict what's going to end up inside, so just ensure
+    # that we have a complete string.
+    str = Faker::HTMLIpsum.fancy_string(3, true)
+    assert_equal 3, str.split("<br>").length
+  end
+end

data/test/test_identification.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'helper'
+
+class TestFakerIdentification < Test::Unit::TestCase
+  def setup
+    @tester = Faker::Identification
+  end
+
+  def test_drivers_license
+    ###-###-##-###-#
+    assert_match /[A-Z]\d{3}-\d{3}-\d{2}-\d{3}-\d{1}/, @tester.drivers_license
+  end
+
+  def test_ssn
+    assert_match /\d{3}-\d{2}-\d{4}/, @tester.ssn
+  end
+
+  def test_gender
+    assert_match /(Male|Female)/, @tester.gender
+  end
+
+  def test_ethnicity
+    ethnicity_regex = /(African American|Asian\/Pacific Islander|Caucasian|Hispanic|Native American|Multiracial|Other|Prefer not to respond)/
+    assert_match ethnicity_regex, @tester.ethnicity
+  end
+end