forgery 0.5.0 → 0.6.0

data/spec/extensions/string_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe String do
+  it "should change a single # to a number 0-9" do
+    (0..9).should include(Integer(Forgery::Extend("#").to_numbers))
+  end
+
+  it "should change two #'s to two numbers 0-9" do
+    Forgery::Extend("##").to_numbers.split("").each do |s|
+      (0..9).should include(Integer(s))
+    end
+  end
+
+  it "should only replace #'s in the string with numbers 0-9" do
+    s = Forgery::Extend('###-###-####')
+    n = s.to_numbers
+    0.upto(s.size - 1) do |i|
+      if s[i, 1] == "#"
+        ('0'..'9').should include(n[i, 1])
+      else
+        ('0'..'9').should_not include(n[i, 1])
+      end
+    end
+  end
+
+  it "should allow the replacing of a different character" do
+    (0..9).should include(Integer(Forgery::Extend("-").to_numbers("-")))
+  end
+end

data/spec/file_reader_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Forgery::FileReader do
+  it "should return an array when calling read_dictionary" do
+    Forgery::FileReader.read_dictionary(:colors).should be_is_a(Array)
+  end
+
+  it "should return an array when calling read_format" do
+    Forgery::FileReader.read_format(:phone).should be_is_a(Array)
+  end
+
+  it "should override default dictionaries if Forgery#load_from! was called" do
+    Forgery.load_from! "spec/data"
+    Forgery::FileReader.read_dictionary(:female_first_names).should == %w(Amber)
+  end
+
+  it "should read dictionaries from custom places if Forgery#load_from! was called" do
+    Forgery.load_from! "spec/data"
+    Forgery::FileReader.read_dictionary(:code_names).should include('Shiretoko')
+  end
+
+  it "should raise an exception if file wasn't found in load paths" do
+    lambda {
+      Forgery::FileReader.read_dictionary(:non_existing_dictionary)
+    }.should raise_error(ArgumentError)
+  end
+  after do
+    # reset load_paths
+    Forgery.load_paths.clear
+    Forgery.load_paths << File.expand_path("lib/forgery")
+  end
+end

data/spec/forgery/address_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Forgery::Address do
+  it "should return a random street" do
+    Forgery.dictionaries[:streets].should include(Forgery::Address.street_name)
+  end
+
+  it "should return a random street number" do
+    original_format = Forgery::Address.street_number.gsub(/\d/, '#')
+    Forgery.formats[:street_number].should include(original_format)
+  end
+
+  it "should return a random street suffix" do
+    Forgery.dictionaries[:street_suffixes].should include(Forgery::Address.street_suffix)
+  end
+
+  describe ".street_address" do
+    before do
+      @split_address = Forgery::Address.street_address.split
+    end
+
+    it "should return a random street suffix" do
+      street_suffix = @split_address.pop
+      Forgery.dictionaries[:street_suffixes].should include(street_suffix)
+    end
+
+    it "should return a random street number" do
+      street_number_format = @split_address.shift.gsub(/\d/, '#')
+      Forgery.formats[:street_number].should include(street_number_format)
+    end
+
+    it "should return a random street" do
+      @split_address.pop
+      @split_address.shift
+      street = @split_address.join(" ")
+      Forgery.dictionaries[:streets].should include(street)
+    end
+  end
+
+  it "should return a random city" do
+    city = Forgery::Address.city
+    Forgery.dictionaries[:cities].should include(city)
+  end
+
+  it "should return a random state" do
+    state = Forgery::Address.state
+    Forgery.dictionaries[:states].should include(state)
+  end
+
+  it "should return a random state abbreviation" do
+    state_abbrev = Forgery::Address.state_abbrev
+    Forgery.dictionaries[:state_abbrevs].should include(state_abbrev)
+  end
+
+  it "should return a random Canadian province or territory" do
+    province = Forgery::Address.province
+    Forgery.dictionaries[:provinces].should include(province)
+  end
+
+  it "should return a random Canadian province or territory abbreviation" do
+    province_abbrev = Forgery::Address.province_abbrev
+    Forgery.dictionaries[:province_abbrevs].should include(province_abbrev)
+  end
+
+  it "should return a random country" do
+    country = Forgery::Address.country
+    Forgery.dictionaries[:countries].should include(country)
+  end
+
+  it "should return a random continent" do
+    continent = Forgery::Address.continent
+    Forgery.dictionaries[:continents].should include(continent)
+  end
+
+  it "should return a random zip code" do
+    zip_format = Forgery::Address.zip.gsub(/\d/, '#')
+    Forgery.formats[:zip].should include(zip_format)
+  end
+
+  it "should return a random phone number" do
+    phone_format = Forgery::Address.phone.gsub(/\d/, '#')
+    Forgery.formats[:phone].should include(phone_format)
+  end
+end

data/spec/forgery/basic_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Forgery::Basic do
+  describe ".password" do
+    it "should only uppercase characters" do
+      Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => true,
+                            :allow_numeric => false,
+                            :allow_special => false).should only_contain(Forgery::Basic::UPPER_ALPHA)
+    end
+
+    it "should only contain lowercase characters" do
+      Forgery::Basic.password(:allow_lower => true,
+                            :allow_upper => false,
+                            :allow_numeric => false,
+                            :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA)
+    end
+
+    it "should only contain numeric characters" do
+      Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => false,
+                            :allow_numeric => true,
+                            :allow_special => false).should only_contain(Forgery::Basic::NUMERIC)
+    end
+
+    it "should only contain special characters" do
+      Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => false,
+                            :allow_numeric => false,
+                            :allow_special => true).should only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+
+    it "should only contain lower and uppercase characters" do
+      Forgery::Basic.password(:allow_lower => true,
+                            :allow_upper => true,
+                            :allow_numeric => false,
+                            :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA,
+                                                                         Forgery::Basic::UPPER_ALPHA)
+    end
+
+    it "should only contain numeric and special characters" do
+      Forgery::Basic.password(:allow_lower => false,
+                            :allow_upper => false,
+                            :allow_numeric => true,
+                            :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                                                                        Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+
+    it "should contain any of the defined characters" do
+      Forgery::Basic.password(:allow_lower => true,
+                            :allow_upper => true,
+                            :allow_numeric => true,
+                            :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                                                                        Forgery::Basic::SPECIAL_CHARACTERS,
+                                                                        Forgery::Basic::LOWER_ALPHA,
+                                                                        Forgery::Basic::UPPER_ALPHA)
+    end
+  end
+
+  describe ".encrypt" do
+    it "should encrypt to hex digits" do
+      Forgery::Basic.encrypt("something").should only_contain(Forgery::Basic::HEX_DIGITS)
+    end
+
+    it "should encrypt different words to different output" do
+      Forgery::Basic.encrypt("foo").should_not == Forgery::Basic.encrypt("bar")
+    end
+
+    it "should allow a salt that changes the output" do
+      Forgery::Basic.encrypt("foo", "baz").should_not == Forgery::Basic.encrypt("foo", "bar")
+    end
+
+    it "should have the same output when encrypting twice" do
+      Forgery::Basic.encrypt("foo", "bar").should == Forgery::Basic.encrypt("foo", "bar")
+    end
+  end
+
+  describe ".boolean" do
+    it "should return true or false" do
+      [true, false].should include(Forgery::Basic.boolean)
+    end
+  end
+
+  describe ".color" do
+    it "should return a random color" do
+      Forgery.dictionaries[:colors].should include(Forgery::Basic.color)
+    end
+  end
+
+  describe ".hex_color" do
+    it "should return a 6-character hex color" do
+      Forgery::Basic.hex_color.should match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){6}/)
+    end
+  end
+
+  describe ".short_hex_color" do
+    it "should return a 3-character hex color" do
+      Forgery::Basic.short_hex_color.should match(/#(#{Forgery::Basic::HEX_DIGITS.join('|')}){3}/)
+    end
+  end
+
+  describe ".number" do
+    it "should return a number >= the at_least option" do
+      Forgery::Basic.number(:at_least => 2).should >= 2
+    end
+
+    it "should return a number <= the at_most option" do
+      Forgery::Basic.number(:at_most => 12).should <= 12
+    end
+  end
+
+  describe ".text" do
+    it "should return text whose length is >= the at_least option" do
+      Forgery::Basic.text(:at_least => 5).size.should >= 5
+    end
+
+    it "should return text whose length is <= the at_most option" do
+      Forgery::Basic.text(:at_most => 15).size.should <= 15
+    end
+    
+    it "should return text whose length is == the exactly option" do
+      Forgery::Basic.text(:exactly => 20).size.should == 20
+    end
+
+    it "should only uppercase characters" do
+      Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => true,
+                        :allow_numeric => false,
+                        :allow_special => false).should only_contain(Forgery::Basic::UPPER_ALPHA)
+    end
+
+    it "should only contain lowercase characters" do
+      Forgery::Basic.text(:allow_lower => true,
+                        :allow_upper => false,
+                        :allow_numeric => false,
+                        :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA)
+    end
+
+    it "should only contain numeric characters" do
+      Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => false,
+                        :allow_numeric => true,
+                        :allow_special => false).should only_contain(Forgery::Basic::NUMERIC)
+    end
+
+    it "should only contain special characters" do
+      Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => false,
+                        :allow_numeric => false,
+                        :allow_special => true).should only_contain(Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+
+    it "should only contain lower and uppercase characters" do
+      Forgery::Basic.text(:allow_lower => true,
+                        :allow_upper => true,
+                        :allow_numeric => false,
+                        :allow_special => false).should only_contain(Forgery::Basic::LOWER_ALPHA,
+                                                                     Forgery::Basic::UPPER_ALPHA)
+    end
+
+    it "should only contain numeric and special characters" do
+      Forgery::Basic.text(:allow_lower => false,
+                        :allow_upper => false,
+                        :allow_numeric => true,
+                        :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                                                                    Forgery::Basic::SPECIAL_CHARACTERS)
+    end
+
+    it "should contain any of the defined characters" do
+      Forgery::Basic.text(:allow_lower => true,
+                        :allow_upper => true,
+                        :allow_numeric => true,
+                        :allow_special => true).should only_contain(Forgery::Basic::NUMERIC,
+                                                                    Forgery::Basic::SPECIAL_CHARACTERS,
+                                                                    Forgery::Basic::LOWER_ALPHA,
+                                                                    Forgery::Basic::UPPER_ALPHA)
+    end
+  end
+end

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
+      valid_number?(Forgery::CreditCard.number).should eql(true)
+    end
+
+    it "should start with a valid prefix" do
+      which_type?(Forgery::CreditCard.number).should_not eql(false)
+    end
+
+    # type specified
+    it "should be valid if type specified" do
+      valid_number?(Forgery::CreditCard.number :type => 'Discover').should eql(true)
+    end
+
+    it "should start with a valid prefix for type specified" do
+      which_type?(Forgery::CreditCard.number :type => 'MasterCard').should eql(:master)
+    end
+
+    # type and length specified
+    it "should be valid if type and length specified" do
+      valid_number?(Forgery::CreditCard.number :type => 'Visa', :length => 13).should eql(true)
+    end
+
+    it "should be the length specified" do
+      (Forgery::CreditCard.number :type => 'Visa', :length => 13).length.should eql(13)
+    end
+
+    # length and prefixes specified
+    it "should be valid if length and prefixes specified" do
+      valid_number?(Forgery::CreditCard.number :length => 14, :prefixes => %w"300 301 302 303 36 38").should eql(true)
+    end
+
+    it "should be a valid Diners Club card, since its length and prefixes are specified" do
+      which_type?(Forgery::CreditCard.number :length => 14, :prefixes => %w"300 301 302 303 36 38").should eql(:diners)
+    end
+  end
+
+  describe ".type" do
+    it "should return a valid type" do
+      which_type?(Forgery::CreditCard.number :type => Forgery::CreditCard.type).should_not 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
+      Forgery::Currency.description.should_not eql(nil)
+    end
+  end
+
+  describe ".currency_codes" do
+    it "should have the same output when encrypting twice" do
+      Forgery::Currency.code.should_not 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
+      Date::DAYNAMES.should 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
+      Date::ABBR_DAYNAMES.should include(Forgery::Date.day_of_week(:abbr => true))
+    end
+  end
+
+  describe '.month' do
+    it 'should return a valid month' do
+      Date::MONTHNAMES.should include(Forgery::Date.month)
+    end
+  end
+
+  describe '.month(:abbr => true)' do
+    it 'should return a valid month in abbreviated form' do
+      Date::ABBR_MONTHNAMES.should include(Forgery::Date.month(:abbr => true))
+    end
+  end
+
+  describe '.month(:numerical => true)' do
+    it 'should return a valid month in numeric form' do
+      [1,2,3,4,5,6,7,8,9,10,11,12].should 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
+      year.should > Date.today.year - 21
+      year.should < 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)
+      year.should >= 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)
+      year.should == 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)
+      (0..5).map { |i| Date.today.year + i + 5 }.should 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)
+      year.should <= 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)
+      year.should == 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)
+      (0..5).map { |i| Date.today.year - i - 5 }.should 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
+      date.should > Date.today - 7300
+      date.should < 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)
+      date.should >= 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)
+      date.should == 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)
+      (0..5).map { |i| Date.today + i + 5 }.should 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)
+      date.should <= 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)
+      date.should == 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)
+      (0..5).map { |i| Date.today - i - 5 }.should include(date)
+    end
+  end
+end