forgery 0.4.3 → 0.8.1

data/spec/forgery/credit_card_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Forgery::CreditCard do
+  describe ".number" do
+    # basics
+    it "should be valid (pass a Luhn test)" do
+      expect(valid_number?(Forgery::CreditCard.number)).to eql(true)
+    end
+
+    it "should start with a valid prefix" do
+      expect(which_type?(Forgery::CreditCard.number)).not_to eql(false)
+    end
+
+    # type specified
+    it "should be valid if type specified" do
+      expect(valid_number?(Forgery::CreditCard.number :type => 'Discover')).to eql(true)
+    end
+
+    it "should start with a valid prefix for type specified" do
+      expect(which_type?(Forgery::CreditCard.number :type => 'MasterCard')).to eql(:master)
+    end
+
+    # type and length specified
+    it "should be valid if type and length specified" do
+      expect(valid_number?(Forgery::CreditCard.number :type => 'Visa', :length => 13)).to eql(true)
+    end
+
+    it "should be the length specified" do
+      expect((Forgery::CreditCard.number :type => 'Visa', :length => 13).length).to eql(13)
+    end
+
+    # length and prefixes specified
+    it "should be valid if length and prefixes specified" do
+      expect(valid_number?(Forgery::CreditCard.number :length => 14, :prefixes => %w"300 301 302 303 36 38")).to eql(true)
+    end
+
+    it "should be a valid Diners Club card, since its length and prefixes are specified" do
+      expect(which_type?(Forgery::CreditCard.number :length => 14, :prefixes => %w"300 301 302 303 36 38")).to eql(:diners)
+    end
+  end
+
+  describe ".type" do
+    it "should return a valid type" do
+      expect(which_type?(Forgery::CreditCard.number :type => Forgery::CreditCard.type)).not_to eql(false)
+    end
+  end
+
+  # helper functions below originally from: https://gist.github.com/1182499
+  def valid_number?(number)
+    number.reverse!
+    relative_number = {'0' => 0, '1' => 2, '2' => 4, '3' => 6, '4' => 8, '5' => 1, '6' => 3, '7' => 5, '8' => 7, '9' => 9}
+    sum = 0
+    number.split("").each_with_index do |n, i|
+      sum += (i % 2 == 0) ? n.to_i : relative_number[n]
+    end
+    sum % 10 == 0
+  end
+
+  def which_type?(number)
+    return :diners   if number.length == 14 && number =~ /^3(0[0-5]|[68])/   # 300xxx-305xxx, 36xxxx, 38xxxx
+    return :amex     if number.length == 15 && number =~ /^3[47]/            # 34xxxx, 37xxxx
+    return :visa     if [13,16].include?(number.length) && number =~ /^4/    # 4xxxxx
+    return :master   if number.length == 16 && number =~ /^5[1-5]/           # 51xxxx-55xxxx
+    return :discover if number.length == 16 && number =~ /^6011/             # 6011xx
+    return false
+  end
+
+end

data/spec/forgery/currency_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Forgery::Currency do
+  describe ".currency_descriptions" do
+    it "should be able to generate a currency description" do
+      expect(Forgery::Currency.description).not_to eql(nil)
+    end
+  end
+
+  describe ".currency_codes" do
+    it "should have the same output when encrypting twice" do
+      expect(Forgery::Currency.code).not_to eql(nil)
+    end
+  end
+end

data/spec/forgery/date_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'date'
+
+describe Forgery::Date do
+  describe '.day_of_week' do
+    it 'should return a day of the week' do
+      expect(Date::DAYNAMES).to include(Forgery::Date.day_of_week)
+    end
+  end
+
+  describe '.day_of_week(:abbr => true)' do
+    it 'should return a day of the week in abbreviated form' do
+      expect(Date::ABBR_DAYNAMES).to include(Forgery::Date.day_of_week(:abbr => true))
+    end
+  end
+
+  describe '.month' do
+    it 'should return a valid month' do
+      expect(Date::MONTHNAMES).to include(Forgery::Date.month)
+    end
+  end
+
+  describe '.month(:abbr => true)' do
+    it 'should return a valid month in abbreviated form' do
+      expect(Date::ABBR_MONTHNAMES).to include(Forgery::Date.month(:abbr => true))
+    end
+  end
+
+  describe '.month(:numerical => true)' do
+    it 'should return a valid month in numeric form' do
+      expect([1,2,3,4,5,6,7,8,9,10,11,12]).to include(Forgery::Date.month(:numerical => true))
+    end
+  end
+
+  describe '.year' do
+    it 'should return a valid year within 20 years of the current year' do
+      year = Forgery::Date.year
+      expect(year).to be > Date.today.year - 21
+      expect(year).to be < Date.today.year + 21
+    end
+  end
+
+  describe '.year(:future => true)' do
+    it 'should return a year greater than the current one' do
+      year = Forgery::Date.year(:future => true)
+      expect(year).to be >= Date.today.year
+    end
+  end
+
+  describe '.year(:min_delta => 5, :max_delta => 5, :future => true)' do
+    it 'should return a year 5 years from the current one' do
+      year = Forgery::Date.year(:min_delta => 5, :max_delta => 5, :future => true)
+      expect(year).to eq(Date.today.year + 5)
+    end
+  end
+
+  describe '.year(:min_delta => 5, :max_delta => 10, :future => true)' do
+    it 'should return a year that is between 5 and 10 years greater than the current one' do
+      year = Forgery::Date.year(:min_delta => 5, :max_delta => 10, :future => true)
+      expect((0..5).map { |i| Date.today.year + i + 5 }).to include(year)
+    end
+  end
+
+  describe '.year(:past => true)' do
+    it 'should return a year less than the current one' do
+      year = Forgery::Date.year(:past => true)
+      expect(year).to be <= Date.today.year
+    end
+  end
+
+  describe '.year(:min_delta => 5, :max_delta => 5, :past => true)' do
+    it 'should return a year 5 years until the current one' do
+      year = Forgery::Date.year(:min_delta => 5, :max_delta => 5, :past => true)
+      expect(year).to eq(Date.today.year - 5)
+    end
+  end
+
+  describe '.year(:min_delta => 5, :max_delta => 10, :past => true)' do
+    it 'should return a year that is between 5 and 10 years less than the current one' do
+      year = Forgery::Date.year(:min_delta => 5, :max_delta => 10, :past => true)
+      expect((0..5).map { |i| Date.today.year - i - 5 }).to include(year)
+    end
+  end
+
+  describe '.date' do
+    it 'should return a valid date within 7300 days of the current date' do
+      date = Forgery::Date.date
+      expect(date).to be > Date.today - 7300
+      expect(date).to be < Date.today + 7300
+    end
+  end
+
+  describe '.date(:future => true)' do
+    it 'should return a date greater than the current one' do
+      date = Forgery::Date.date(:future => true)
+      expect(date).to be >= Date.today
+    end
+  end
+
+  describe '.date(:min_delta => 5, :max_delta => 5, :future => true)' do
+    it 'should return a date 5 days from the current one' do
+      date = Forgery::Date.date(:min_delta => 5, :max_delta => 5, :future => true)
+      expect(date).to eq(Date.today + 5)
+    end
+  end
+
+  describe '.date(:min_delta => 5, :max_delta => 10, :future => true)' do
+    it 'should return a date that is between 5 and 10 days greater than the current one' do
+      date = Forgery::Date.date(:min_delta => 5, :max_delta => 10, :future => true)
+      expect((0..5).map { |i| Date.today + i + 5 }).to include(date)
+    end
+  end
+
+  describe '.date(:past => true)' do
+    it 'should return a date less than the current one' do
+      date = Forgery::Date.date(:past => true)
+      expect(date).to be <= Date.today
+    end
+  end
+
+  describe '.date(:min_delta => 5, :max_delta => 5, :past => true)' do
+    it 'should return a date 5 days until the current one' do
+      date = Forgery::Date.date(:min_delta => 5, :max_delta => 5, :past => true)
+      expect(date).to eq(Date.today - 5)
+    end
+  end
+
+  describe '.date(:min_delta => 5, :max_delta => 10, :past => true)' do
+    it 'should return a date that is between 5 and 10 days less than the current one' do
+      date = Forgery::Date.date(:min_delta => 5, :max_delta => 10, :past => true)
+      expect((0..5).map { |i| Date.today - i - 5 }).to include(date)
+    end
+  end
+end

data/spec/forgery/internet_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Forgery::Internet do
+  describe ".user_name" do
+    it "should return a username that is lowercase" do
+      expect(Forgery::Internet.user_name).to only_contain(Forgery::Basic::LOWER_ALPHA)
+    end
+  end
+
+  it "should return a top level domain" do
+    expect(Forgery.dictionaries[:top_level_domains]).to include(Forgery::Internet.top_level_domain)
+  end
+
+  describe ".domain_name" do
+    it "should return a domain name that contains a lowercase company name" do
+      downcase_company_name = Forgery::Internet.domain_name.split('.').first
+      Forgery.dictionaries[:company_names].any?{ |cn| cn =~ /#{downcase_company_name}/i }
+    end
+
+    it "should return a domain name that contains a top level domain" do
+      expect(Forgery.dictionaries[:top_level_domains]).to include(Forgery::Internet.domain_name.split('.').last)
+    end
+  end
+
+  describe ".email_address" do
+    it "should match the email format" do
+      expect(Forgery::Internet.email_address).to match(/.+@.+\.(#{Forgery.dictionaries[:top_level_domains].join("|")})/)
+    end
+  end
+
+  describe ".cctld" do
+    it "should return a country-code top level domain" do
+      expect(Forgery.dictionaries[:country_code_top_level_domains]).to include(Forgery::Internet.cctld)
+    end
+
+    it "should return the cctld in correct two-letter format" do
+      expect(Forgery::Internet.cctld).to match(/\A[a-z]{2}\Z/)
+    end
+  end
+
+  describe '.ip_v4' do
+    it 'should be 4 integers between 0 and 255 seprated by "."' do
+      val = Forgery::Internet.ip_v4
+      nums = val.split('.')
+      expect(nums.size).to eq(4)
+      nums.each do |num|
+        expect(num).to match(/\d{1,3}/)
+        expect(num.to_i).to be <= 255
+        expect(num.to_i).to be >= 0
+      end
+    end
+  end
+
+  describe '.ip_v6' do
+    it 'should be a valid ipv6 address' do
+      val = Forgery::Internet.ip_v6
+      address = IPAddr.new(val)
+      expect(address.ipv6?).to eq(true)
+    end
+  end
+
+end

data/spec/forgery/lorem_ipsum_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Forgery::LoremIpsum do
+  describe ".paragraphs" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.paragraphs).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.paragraphs.size).to be >= 1
+    end
+
+    it "should default to returning 2 paragraphs separated by \\n\\n" do
+      expect(Forgery::LoremIpsum.paragraphs.split("\n\n").size).to eq(2)
+    end
+
+    it "should default to returning 3 sentences per paragraph" do
+      paragraphs = Forgery::LoremIpsum.paragraphs.split("\n\n")
+      paragraphs.each do |paragraph|
+        expect(paragraph.scan(".").size).to eq(3)
+      end
+    end
+
+    it "should wrap paragraphs in html paragraph tags when the :html option is true" do
+      paragraphs = Forgery::LoremIpsum.paragraphs(2, :html => true).split("\n\n")
+      paragraphs.each do |paragraph|
+        expect(paragraph).to match(/<p>.+?<\/p>/)
+      end
+    end
+
+    it "should wrap paragraphs in specified wrapping text" do
+      paragraphs = Forgery::LoremIpsum.paragraphs(2, :wrap => {:start => "foo", :end => "bar"}).split("\n\n")
+      paragraphs.each do |paragraph|
+        expect(paragraph).to match(/foo.+bar/)
+      end
+    end
+
+    it "should separate paragraphs with the specified string" do
+      expect(Forgery::LoremIpsum.paragraphs(2, :separator => "foo").split("foo").size).to eq(2)
+    end
+  end
+
+  describe ".paragraph" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.paragraph).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.paragraph.size).to be >= 1
+    end
+
+    it "should return a single paragraph" do
+      expect(Forgery::LoremIpsum.paragraph.scan("\n\n").size).to eq(0)
+    end
+  end
+
+  describe ".sentences" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.sentences).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.sentences.size).to be >= 1
+    end
+
+    it "should return two sentences by default" do
+      expect(Forgery::LoremIpsum.sentences.scan(".").size).to eq(2)
+    end
+
+    it "should return as many sentences as you specify" do
+      expect(Forgery::LoremIpsum.sentences(4).scan(".").size).to eq(4)
+    end
+  end
+
+  describe ".sentence" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.sentence).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.sentence.size).to be >= 1
+    end
+
+    it "should return a single sentence" do
+      expect(Forgery::LoremIpsum.sentence.scan(".").size).to eq(1)
+    end
+  end
+
+  describe ".words" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.words).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.words.size).to be >= 1
+    end
+
+    it "should return a random set of words" do
+      Forgery::LoremIpsum.words(2, :random => true)
+    end
+  end
+
+  describe ".word" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.word).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.word.size).to be >= 1
+    end
+  end
+
+  describe ".characters" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.characters).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.characters.size).to be >= 1
+    end
+  end
+
+  describe ".character" do
+    it "should return text" do
+      expect(Forgery::LoremIpsum.character).to be_a_kind_of(String)
+    end
+
+    it "should return text with 1 or more character" do
+      expect(Forgery::LoremIpsum.character.size).to be >= 1
+    end
+  end
+end

data/spec/forgery/monetary_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'bigdecimal'
+
+describe Forgery::Monetary do
+  it 'should return random number string' do
+    expect(Forgery(:monetary).money).to match(/^[\d+\.]+$/)
+  end
+
+  it 'should return random number respecting min and max parameters' do
+    expect(BigDecimal(Forgery(:monetary).money({ min: 10, max: 20 }))).to be_between(10, 20)
+  end
+end

data/spec/forgery/name_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Forgery::Name do
+  it "should return a random first name" do
+    expect(Forgery.dictionaries[:male_first_names] + Forgery.dictionaries[:female_first_names]).to include(Forgery::Name.first_name)
+  end
+
+  it "should return a random last name" do
+    expect(Forgery.dictionaries[:last_names]).to include(Forgery::Name.last_name)
+  end
+end

data/spec/forgery/personal_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Forgery::Personal do
+  describe '.gender' do
+    it 'should return male or female' do
+      expect(Forgery.dictionaries[:genders]).to include(Forgery::Personal.gender)
+    end
+  end
+  
+  describe '.shirt_size' do
+    it 'should return a sane size' do
+      expect(Forgery.dictionaries[:shirt_sizes]).to include(Forgery::Personal.shirt_size)
+    end
+  end
+end