forgery 0.6.0 → 0.7.0

data/spec/forgery/credit_card_spec.rb

@@ -4,44 +4,44 @@ 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)
+      expect(valid_number?(Forgery::CreditCard.number)).to eql(true)
     end
 
     it "should start with a valid prefix" do
-      which_type?(Forgery::CreditCard.number).should_not eql(false)
+      expect(which_type?(Forgery::CreditCard.number)).not_to eql(false)
     end
 
     # type specified
     it "should be valid if type specified" do
-      valid_number?(Forgery::CreditCard.number :type => 'Discover').should eql(true)
+      expect(valid_number?(Forgery::CreditCard.number :type => 'Discover')).to eql(true)
     end
 
     it "should start with a valid prefix for type specified" do
-      which_type?(Forgery::CreditCard.number :type => 'MasterCard').should eql(:master)
+      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
-      valid_number?(Forgery::CreditCard.number :type => 'Visa', :length => 13).should eql(true)
+      expect(valid_number?(Forgery::CreditCard.number :type => 'Visa', :length => 13)).to eql(true)
     end
 
     it "should be the length specified" do
-      (Forgery::CreditCard.number :type => 'Visa', :length => 13).length.should eql(13)
+      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
-      valid_number?(Forgery::CreditCard.number :length => 14, :prefixes => %w"300 301 302 303 36 38").should eql(true)
+      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
-      which_type?(Forgery::CreditCard.number :length => 14, :prefixes => %w"300 301 302 303 36 38").should eql(:diners)
+      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
-      which_type?(Forgery::CreditCard.number :type => Forgery::CreditCard.type).should_not eql(false)
+      expect(which_type?(Forgery::CreditCard.number :type => Forgery::CreditCard.type)).not_to eql(false)
     end
   end
 

data/spec/forgery/currency_spec.rb

@@ -3,13 +3,13 @@ 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)
+      expect(Forgery::Currency.description).not_to 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)
+      expect(Forgery::Currency.code).not_to eql(nil)
     end
   end
 end

data/spec/forgery/date_spec.rb

@@ -4,131 +4,131 @@ 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)
+      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
-      Date::ABBR_DAYNAMES.should include(Forgery::Date.day_of_week(:abbr => true))
+      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
-      Date::MONTHNAMES.should include(Forgery::Date.month)
+      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
-      Date::ABBR_MONTHNAMES.should include(Forgery::Date.month(:abbr => true))
+      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
-      [1,2,3,4,5,6,7,8,9,10,11,12].should include(Forgery::Date.month(:numerical => true))
+      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
-      year.should > Date.today.year - 21
-      year.should < Date.today.year + 21
+      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)
-      year.should >= Date.today.year
+      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)
-      year.should == Date.today.year + 5
+      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)
-      (0..5).map { |i| Date.today.year + i + 5 }.should include(year)
+      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)
-      year.should <= Date.today.year
+      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)
-      year.should == Date.today.year - 5
+      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)
-      (0..5).map { |i| Date.today.year - i - 5 }.should include(year)
+      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
-      date.should > Date.today - 7300
-      date.should < Date.today + 7300
+      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)
-      date.should >= Date.today
+      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)
-      date.should == Date.today + 5
+      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)
-      (0..5).map { |i| Date.today + i + 5 }.should include(date)
+      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)
-      date.should <= Date.today
+      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)
-      date.should == Date.today - 5
+      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)
-      (0..5).map { |i| Date.today - i - 5 }.should include(date)
+      expect((0..5).map { |i| Date.today - i - 5 }).to include(date)
     end
   end
 end

data/spec/forgery/internet_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe Forgery::Internet do
   describe ".user_name" do
     it "should return a username that is lowercase" do
-      Forgery::Internet.user_name.should only_contain(Forgery::Basic::LOWER_ALPHA)
+      expect(Forgery::Internet.user_name).to only_contain(Forgery::Basic::LOWER_ALPHA)
     end
   end
 
   it "should return a top level domain" do
-    Forgery.dictionaries[:top_level_domains].should include(Forgery::Internet.top_level_domain)
+    expect(Forgery.dictionaries[:top_level_domains]).to include(Forgery::Internet.top_level_domain)
   end
 
   describe ".domain_name" do
@@ -18,23 +18,23 @@ describe Forgery::Internet do
     end
 
     it "should return a domain name that contains a top level domain" do
-      Forgery.dictionaries[:top_level_domains].should include(Forgery::Internet.domain_name.split('.').last)
+      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
-      Forgery::Internet.email_address.should match(/.+@.+\.(#{Forgery.dictionaries[:top_level_domains].join("|")})/)
+      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
-      Forgery.dictionaries[:country_code_top_level_domains].should include(Forgery::Internet.cctld)
+      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
-      Forgery::Internet.cctld.should =~ /\A[a-z]{2}\Z/
+      expect(Forgery::Internet.cctld).to match(/\A[a-z]{2}\Z/)
     end
   end
 
@@ -42,11 +42,11 @@ describe Forgery::Internet do
     it 'should be 4 integers between 0 and 255 seprated by "."' do
       val = Forgery::Internet.ip_v4
       nums = val.split('.')
-      nums.should have(4).items
+      expect(nums.size).to eq(4)
       nums.each do |num|
-        num.should =~ /\d{1,3}/
-        num.to_i.should <= 255
-        num.to_i.should >= 0
+        expect(num).to match(/\d{1,3}/)
+        expect(num.to_i).to be <= 255
+        expect(num.to_i).to be >= 0
       end
     end
   end
@@ -55,7 +55,7 @@ describe Forgery::Internet do
     it 'should be a valid ipv6 address' do
       val = Forgery::Internet.ip_v6
       address = IPAddr.new(val)
-      address.ipv6?.should eq(true)
+      expect(address.ipv6?).to eq(true)
     end
   end
 

data/spec/forgery/lorem_ipsum_spec.rb

@@ -3,96 +3,96 @@ require 'spec_helper'
 describe Forgery::LoremIpsum do
   describe ".paragraphs" do
     it "should return text" do
-      Forgery::LoremIpsum.paragraphs.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.paragraphs).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.paragraphs.size.should >= 1
+      expect(Forgery::LoremIpsum.paragraphs.size).to be >= 1
     end
 
     it "should default to returning 2 paragraphs separated by \\n\\n" do
-      Forgery::LoremIpsum.paragraphs.split("\n\n").size.should == 2
+      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|
-        paragraph.scan(".").size.should == 3
+        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|
-        paragraph.should match(/<p>.+?<\/p>/)
+        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|
-        paragraph.should match(/foo.+bar/)
+        expect(paragraph).to match(/foo.+bar/)
       end
     end
 
     it "should separate paragraphs with the specified string" do
-      Forgery::LoremIpsum.paragraphs(2, :separator => "foo").split("foo").size.should == 2
+      expect(Forgery::LoremIpsum.paragraphs(2, :separator => "foo").split("foo").size).to eq(2)
     end
   end
 
   describe ".paragraph" do
     it "should return text" do
-      Forgery::LoremIpsum.paragraph.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.paragraph).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.paragraph.size.should >= 1
+      expect(Forgery::LoremIpsum.paragraph.size).to be >= 1
     end
 
     it "should return a single paragraph" do
-      Forgery::LoremIpsum.paragraph.scan("\n\n").size.should == 0
+      expect(Forgery::LoremIpsum.paragraph.scan("\n\n").size).to eq(0)
     end
   end
 
   describe ".sentences" do
     it "should return text" do
-      Forgery::LoremIpsum.sentences.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.sentences).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.sentences.size.should >= 1
+      expect(Forgery::LoremIpsum.sentences.size).to be >= 1
     end
 
     it "should return two sentences by default" do
-      Forgery::LoremIpsum.sentences.scan(".").size.should == 2
+      expect(Forgery::LoremIpsum.sentences.scan(".").size).to eq(2)
     end
 
     it "should return as many sentences as you specify" do
-      Forgery::LoremIpsum.sentences(4).scan(".").size.should == 4
+      expect(Forgery::LoremIpsum.sentences(4).scan(".").size).to eq(4)
     end
   end
 
   describe ".sentence" do
     it "should return text" do
-      Forgery::LoremIpsum.sentence.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.sentence).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.sentence.size.should >= 1
+      expect(Forgery::LoremIpsum.sentence.size).to be >= 1
     end
 
     it "should return a single sentence" do
-      Forgery::LoremIpsum.sentence.scan(".").size.should == 1
+      expect(Forgery::LoremIpsum.sentence.scan(".").size).to eq(1)
     end
   end
 
   describe ".words" do
     it "should return text" do
-      Forgery::LoremIpsum.words.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.words).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.words.size.should >= 1
+      expect(Forgery::LoremIpsum.words.size).to be >= 1
     end
 
     it "should return a random set of words" do
@@ -102,31 +102,31 @@ describe Forgery::LoremIpsum do
 
   describe ".word" do
     it "should return text" do
-      Forgery::LoremIpsum.word.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.word).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.word.size.should >= 1
+      expect(Forgery::LoremIpsum.word.size).to be >= 1
     end
   end
 
   describe ".characters" do
     it "should return text" do
-      Forgery::LoremIpsum.characters.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.characters).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.characters.size.should >= 1
+      expect(Forgery::LoremIpsum.characters.size).to be >= 1
     end
   end
 
   describe ".character" do
     it "should return text" do
-      Forgery::LoremIpsum.character.should be_a_kind_of(String)
+      expect(Forgery::LoremIpsum.character).to be_a_kind_of(String)
     end
 
     it "should return text with 1 or more character" do
-      Forgery::LoremIpsum.character.size.should >= 1
+      expect(Forgery::LoremIpsum.character.size).to be >= 1
     end
   end
 end

data/spec/forgery/monetary_spec.rb

@@ -4,11 +4,11 @@ require 'bigdecimal'
 describe Forgery::Monetary do
 
   it "should return random number string" do
-    Forgery(:monetary).money.should match(/^[\d+\.]+$/)
+    expect(Forgery(:monetary).money).to match(/^[\d+\.]+$/)
   end
 
   it "should return random number respecting min and max parameters" do
-    BigDecimal.new(Forgery(:monetary).money({:min => 10, :max => 20})).should be_between(10, 20)
+    expect(BigDecimal.new(Forgery(:monetary).money({:min => 10, :max => 20}))).to be_between(10, 20)
   end
 
 end