feedjira 1.3.1 → 1.4.0

data/spec/feedjira/feed_utilities_spec.rb

@@ -12,7 +12,7 @@ describe Feedjira::FeedUtilities do
     context "when the flag is not set" do
       it "does not call the preprocessing method" do
         @klass.preprocess_xml = false
-        @klass.should_not_receive :preprocess
+        expect(@klass).to_not receive :preprocess
         @klass.parse sample_rss_feed
       end
     end
@@ -20,7 +20,7 @@ describe Feedjira::FeedUtilities do
     context "when the flag is set" do
       it "calls the preprocessing method" do
         @klass.preprocess_xml = true
-        @klass.should_receive(:preprocess).
+        expect(@klass).to receive(:preprocess).
           and_return sample_rss_feed
         @klass.parse sample_rss_feed
       end
@@ -30,36 +30,36 @@ describe Feedjira::FeedUtilities do
   describe "instance methods" do
     it "should provide an updated? accessor" do
       feed = @klass.new
-      feed.should_not be_updated
+      expect(feed).to_not be_updated
       feed.updated = true
-      feed.should be_updated
+      expect(feed).to be_updated
     end
 
     it "should provide a new_entries accessor" do
       feed = @klass.new
-      feed.new_entries.should == []
+      expect(feed.new_entries).to eq []
       feed.new_entries = [:foo]
-      feed.new_entries.should == [:foo]
+      expect(feed.new_entries).to eq [:foo]
     end
 
     it "should provide an etag accessor" do
       feed = @klass.new
       feed.etag = "foo"
-      feed.etag.should == "foo"
+      expect(feed.etag).to eq "foo"
     end
 
     it "should provide a last_modified accessor" do
       feed = @klass.new
       time = Time.now
       feed.last_modified = time
-      feed.last_modified.should == time
-      feed.last_modified.class.should == Time
+      expect(feed.last_modified).to eq time
+      expect(feed.last_modified.class).to eq Time
     end
 
     it "should return new_entries? as true when entries are put into new_entries" do
       feed = @klass.new
       feed.new_entries << :foo
-      feed.should have_new_entries
+      expect(feed).to have_new_entries
     end
 
     it "should return a last_modified value from the entry with the most recent published date if the last_modified date hasn't been set" do
@@ -67,7 +67,7 @@ describe Feedjira::FeedUtilities do
       entry =Feedjira::Parser::AtomEntry.new
       entry.published = Time.now.to_s
       feed.entries << entry
-      feed.last_modified.should == entry.published
+      expect(feed.last_modified).to eq entry.published
     end
 
     it "should not throw an error if one of the entries has published date of nil" do
@@ -76,7 +76,7 @@ describe Feedjira::FeedUtilities do
       entry.published = Time.now.to_s
       feed.entries << entry
       feed.entries << Feedjira::Parser::AtomEntry.new
-      feed.last_modified.should == entry.published
+      expect(feed.last_modified).to eq entry.published
     end
   end
 
@@ -96,36 +96,36 @@ describe Feedjira::FeedUtilities do
       it "should update the title if changed" do
         @updated_feed.title = "new title"
         @feed.update_from_feed(@updated_feed)
-        @feed.title.should == @updated_feed.title
-        @feed.should be_updated
+        expect(@feed.title).to eq @updated_feed.title
+        expect(@feed).to be_updated
       end
 
       it "should not update the title if the same" do
         @feed.update_from_feed(@updated_feed)
-        @feed.should_not be_updated
+        expect(@feed).to_not be_updated
       end
 
       it "should update the feed_url if changed" do
         @updated_feed.feed_url = "a new feed url"
         @feed.update_from_feed(@updated_feed)
-        @feed.feed_url.should == @updated_feed.feed_url
-        @feed.should be_updated
+        expect(@feed.feed_url).to eq @updated_feed.feed_url
+        expect(@feed).to be_updated
       end
 
       it "should not update the feed_url if the same" do
         @feed.update_from_feed(@updated_feed)
-        @feed.should_not be_updated
+        expect(@feed).to_not be_updated
       end
 
       it "should update the url if changed" do
         @updated_feed.url = "a new url"
         @feed.update_from_feed(@updated_feed)
-        @feed.url.should == @updated_feed.url
+        expect(@feed.url).to eq @updated_feed.url
       end
 
       it "should not update the url if not changed" do
         @feed.update_from_feed(@updated_feed)
-        @feed.should_not be_updated
+        expect(@feed).to_not be_updated
       end
     end
 
@@ -154,18 +154,18 @@ describe Feedjira::FeedUtilities do
 
       it "should update last-modified from the latest entry date" do
         @feed.update_from_feed(@updated_feed)
-        @feed.last_modified.should == @new_entry.published
+        expect(@feed.last_modified).to eq @new_entry.published
       end
 
       it "should put new entries into new_entries" do
         @feed.update_from_feed(@updated_feed)
-        @feed.new_entries.should == [@new_entry]
+        expect(@feed.new_entries).to eq [@new_entry]
       end
 
       it "should also put new entries into the entries collection" do
         @feed.update_from_feed(@updated_feed)
-        @feed.entries.should include(@new_entry)
-        @feed.entries.should include(@old_entry)
+        expect(@feed.entries).to include(@new_entry)
+        expect(@feed.entries).to include(@old_entry)
       end
     end
 
@@ -207,10 +207,10 @@ describe Feedjira::FeedUtilities do
       context "changing the url of an existing entry" do
         it "should not put the complete feed into new_entries" do
           @feed.update_from_feed(@updated_feed)
-          @feed.new_entries.should_not include(@entry_changed_url)
-          @feed.new_entries.should_not include(@old_entry)
-          @feed.new_entries.size.should == 0
-          @feed.new_entries.size.should_not == 2
+          expect(@feed.new_entries).to_not include(@entry_changed_url)
+          expect(@feed.new_entries).to_not include(@old_entry)
+          expect(@feed.new_entries.size).to eq 0
+          expect(@feed.new_entries.size).to_not eq 2
         end
       end
 
@@ -220,10 +220,10 @@ describe Feedjira::FeedUtilities do
 
         it "should put the complete feed into new_entries" do
           @feed.update_from_feed(@updated_feed)
-          @feed.new_entries.should include(@entry_changed_url)
-          @feed.new_entries.should include(@old_entry)
-          @feed.new_entries.size.should == 2
-          @feed.new_entries.size.should_not == 0
+          expect(@feed.new_entries).to include(@entry_changed_url)
+          expect(@feed.new_entries).to include(@old_entry)
+          expect(@feed.new_entries.size).to eq 2
+          expect(@feed.new_entries.size).to_not eq 0
         end
       end
     end
@@ -248,7 +248,7 @@ describe Feedjira::FeedUtilities do
 
       it 'finds entries with unique ids and urls' do
         feed_one.update_from_feed feed_two
-        feed_one.new_entries.should eq [entry_two]
+        expect(feed_one.new_entries).to eq [entry_two]
       end
 
       context 'when the entries have the same id' do
@@ -256,7 +256,7 @@ describe Feedjira::FeedUtilities do
 
         it 'does not find a new entry' do
           feed_one.update_from_feed feed_two
-          feed_one.new_entries.should eq []
+          expect(feed_one.new_entries).to eq []
         end
       end
 
@@ -265,7 +265,7 @@ describe Feedjira::FeedUtilities do
 
         it 'does not find a new entry' do
           feed_one.update_from_feed feed_two
-          feed_one.new_entries.should eq []
+          expect(feed_one.new_entries).to eq []
         end
       end
     end

data/spec/feedjira/parser/atom_entry_spec.rb

@@ -8,79 +8,75 @@ describe Feedjira::Parser::AtomEntry do
   end
 
   it "should parse the title" do
-    @entry.title.should == "AWS Job: Architect & Designer Position in Turkey"
+    expect(@entry.title).to eq "AWS Job: Architect & Designer Position in Turkey"
   end
 
   it "should parse the url" do
-    @entry.url.should == "http://aws.typepad.com/aws/2009/01/aws-job-architect-designer-position-in-turkey.html"
+    expect(@entry.url).to eq "http://aws.typepad.com/aws/2009/01/aws-job-architect-designer-position-in-turkey.html"
   end
 
   it "should parse the url even when" do
-    Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml")).entries.first.url.should == "http://www.innoq.com/blog/phaus/2009/07/ja.html"
+    entries = Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml")).entries
+    expect(entries.first.url).to eq "http://www.innoq.com/blog/phaus/2009/07/ja.html"
   end
 
   it "should parse the author" do
-    @entry.author.should == "AWS Editor"
+    expect(@entry.author).to eq "AWS Editor"
   end
 
   it "should parse the content" do
-    @entry.content.should == sample_atom_entry_content
+    expect(@entry.content).to eq sample_atom_entry_content
   end
 
   it "should provide a summary" do
-    @entry.summary.should == "Late last year an entrepreneur from Turkey visited me at Amazon HQ in Seattle. We talked about his plans to use AWS as part of his new social video portal startup. I won't spill any beans before he's ready to..."
+    expect(@entry.summary).to eq "Late last year an entrepreneur from Turkey visited me at Amazon HQ in Seattle. We talked about his plans to use AWS as part of his new social video portal startup. I won't spill any beans before he's ready to..."
   end
 
   it "should parse the published date" do
-    @entry.published.should == Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
+    expect(@entry.published).to eq Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
   end
 
   it "should parse the categories" do
-    @entry.categories.should == ['Turkey', 'Seattle']
+    expect(@entry.categories).to eq ['Turkey', 'Seattle']
   end
 
   it "should parse the updated date" do
-    @entry.updated.should == Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
+    expect(@entry.updated).to eq Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
   end
 
   it "should parse the id" do
-    @entry.id.should == "tag:typepad.com,2003:post-61484736"
+    expect(@entry.id).to eq "tag:typepad.com,2003:post-61484736"
   end
 
   it "should support each" do
-    @entry.respond_to? :each
+    expect(@entry).to respond_to :each
   end
 
   it "should be able to list out all fields with each" do
     all_fields = []
-    @entry.each do |field, value|
-      all_fields << field
-    end
-    all_fields.sort == ['author', 'categories', 'content', 'id', 'published', 'summary', 'title', 'url']
-  end
-
-  it "should be able to list out all values with each" do
     title_value = ''
+
     @entry.each do |field, value|
+      all_fields << field
       title_value = value if field == 'title'
     end
-    title_value.should == "AWS Job: Architect & Designer Position in Turkey"
+
+    expect(all_fields.sort).to eq ["author", "categories", "content", "entry_id", "links", "published", "summary", "title", "updated", "url"]
+    expect(title_value).to eq "AWS Job: Architect & Designer Position in Turkey"
   end
 
   it "should support checking if a field exists in the entry" do
-    @entry.include?('title') && @entry.include?('author')
+    expect(@entry).to include 'author'
+    expect(@entry).to include 'title'
   end
 
   it "should allow access to fields with hash syntax" do
-    @entry['title'] == @entry.title
-    @entry['title'].should == "AWS Job: Architect & Designer Position in Turkey"
-    @entry['author'] == @entry.author
-    @entry['author'].should == "AWS Editor"
+    expect(@entry['title']).to eq "AWS Job: Architect & Designer Position in Turkey"
+    expect(@entry['author']).to eq "AWS Editor"
   end
 
   it "should allow setting field values with hash syntax" do
     @entry['title'] = "Foobar"
-    @entry.title.should == "Foobar"
+    expect(@entry.title).to eq "Foobar"
   end
-
 end

data/spec/feedjira/parser/atom_feed_burner_entry_spec.rb

@@ -8,40 +8,40 @@ describe Feedjira::Parser::AtomFeedBurnerEntry do
   end
 
   it "should parse the title" do
-    @entry.title.should == "Making a Ruby C library even faster"
+    expect(@entry.title).to eq "Making a Ruby C library even faster"
   end
 
   it "should be able to fetch a url via the 'alternate' rel if no origLink exists" do
     entry = Feedjira::Parser::AtomFeedBurner.parse(File.read("#{File.dirname(__FILE__)}/../../sample_feeds/PaulDixExplainsNothingAlternate.xml")).entries.first
-    entry.url.should == 'http://feeds.feedburner.com/~r/PaulDixExplainsNothing/~3/519925023/making-a-ruby-c-library-even-faster.html'
+    expect(entry.url).to eq 'http://feeds.feedburner.com/~r/PaulDixExplainsNothing/~3/519925023/making-a-ruby-c-library-even-faster.html'
   end
 
   it "should parse the url" do
-    @entry.url.should == "http://www.pauldix.net/2009/01/making-a-ruby-c-library-even-faster.html"
+    expect(@entry.url).to eq "http://www.pauldix.net/2009/01/making-a-ruby-c-library-even-faster.html"
   end
 
   it "should parse the url when there is no alternate" do
     entry = Feedjira::Parser::AtomFeedBurner.parse(File.read("#{File.dirname(__FILE__)}/../../sample_feeds/FeedBurnerUrlNoAlternate.xml")).entries.first
-    entry.url.should == 'http://example.com/QQQQ.html'
+    expect(entry.url).to eq 'http://example.com/QQQQ.html'
   end
 
   it "should parse the author" do
-    @entry.author.should == "Paul Dix"
+    expect(@entry.author).to eq "Paul Dix"
   end
 
   it "should parse the content" do
-    @entry.content.should == sample_feedburner_atom_entry_content
+    expect(@entry.content).to eq sample_feedburner_atom_entry_content
   end
 
   it "should provide a summary" do
-    @entry.summary.should == "Last week I released the first version of a SAX based XML parsing library called SAX-Machine. It uses Nokogiri, which uses libxml, so it's pretty fast. However, I felt that it could be even faster. The only question was how..."
+    expect(@entry.summary).to eq "Last week I released the first version of a SAX based XML parsing library called SAX-Machine. It uses Nokogiri, which uses libxml, so it's pretty fast. However, I felt that it could be even faster. The only question was how..."
   end
 
   it "should parse the published date" do
-    @entry.published.should == Time.parse_safely("Thu Jan 22 15:50:22 UTC 2009")
+    expect(@entry.published).to eq Time.parse_safely("Thu Jan 22 15:50:22 UTC 2009")
   end
 
   it "should parse the categories" do
-    @entry.categories.should == ['Ruby', 'Another Category']
+    expect(@entry.categories).to eq ['Ruby', 'Another Category']
   end
 end

data/spec/feedjira/parser/atom_feed_burner_spec.rb

@@ -3,19 +3,19 @@ require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 describe Feedjira::Parser::AtomFeedBurner do
   describe "#will_parse?" do
     it "should return true for a feedburner atom feed" do
-      Feedjira::Parser::AtomFeedBurner.should be_able_to_parse(sample_feedburner_atom_feed)
+      expect(Feedjira::Parser::AtomFeedBurner).to be_able_to_parse(sample_feedburner_atom_feed)
     end
 
     it "should return false for an rdf feed" do
-      Feedjira::Parser::AtomFeedBurner.should_not be_able_to_parse(sample_rdf_feed)
+      expect(Feedjira::Parser::AtomFeedBurner).to_not be_able_to_parse(sample_rdf_feed)
     end
 
     it "should return false for a regular atom feed" do
-      Feedjira::Parser::AtomFeedBurner.should_not be_able_to_parse(sample_atom_feed)
+      expect(Feedjira::Parser::AtomFeedBurner).to_not be_able_to_parse(sample_atom_feed)
     end
 
     it "should return false for an rss feedburner feed" do
-      Feedjira::Parser::AtomFeedBurner.should_not be_able_to_parse(sample_rss_feed_burner_feed)
+      expect(Feedjira::Parser::AtomFeedBurner).to_not be_able_to_parse(sample_rss_feed_burner_feed)
     end
   end
 
@@ -25,32 +25,32 @@ describe Feedjira::Parser::AtomFeedBurner do
     end
 
     it "should parse the title" do
-      @feed.title.should == "Paul Dix Explains Nothing"
+      expect(@feed.title).to eq "Paul Dix Explains Nothing"
     end
 
     it "should parse the description" do
-      @feed.description.should == "Entrepreneurship, programming, software development, politics, NYC, and random thoughts."
+      expect(@feed.description).to eq "Entrepreneurship, programming, software development, politics, NYC, and random thoughts."
     end
 
     it "should parse the url" do
-      @feed.url.should == "http://www.pauldix.net/"
+      expect(@feed.url).to eq "http://www.pauldix.net/"
     end
 
     it "should parse the feed_url" do
-      @feed.feed_url.should == "http://feeds.feedburner.com/PaulDixExplainsNothing"
+      expect(@feed.feed_url).to eq "http://feeds.feedburner.com/PaulDixExplainsNothing"
     end
 
     it "should parse no hub urls" do
-      @feed.hubs.count.should == 0
+      expect(@feed.hubs.count).to eq 0
     end
 
     it "should parse hub urls" do
       feed_with_hub = Feedjira::Parser::AtomFeedBurner.parse(load_sample("TypePadNews.xml"))
-      feed_with_hub.hubs.count.should == 1
+      expect(feed_with_hub.hubs.count).to eq 1
     end
 
     it "should parse entries" do
-      @feed.entries.size.should == 5
+      expect(@feed.entries.size).to eq 5
     end
   end
 
@@ -61,7 +61,7 @@ describe Feedjira::Parser::AtomFeedBurner do
       feed = Feedjira::Parser::AtomFeedBurner.parse sample_feed_burner_atom_xhtml_feed
       entry = feed.entries.first
 
-      entry.content.should match /\A\<p/
+      expect(entry.content).to match /\A\<p/
     end
   end
 end

data/spec/feedjira/parser/atom_spec.rb

@@ -3,19 +3,19 @@ require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 describe Feedjira::Parser::Atom do
   describe "#will_parse?" do
     it "should return true for an atom feed" do
-      Feedjira::Parser::Atom.should be_able_to_parse(sample_atom_feed)
+      expect(Feedjira::Parser::Atom).to be_able_to_parse(sample_atom_feed)
     end
 
     it "should return false for an rdf feed" do
-      Feedjira::Parser::Atom.should_not be_able_to_parse(sample_rdf_feed)
+      expect(Feedjira::Parser::Atom).to_not be_able_to_parse(sample_rdf_feed)
     end
 
     it "should return false for an rss feedburner feed" do
-      Feedjira::Parser::Atom.should_not be_able_to_parse(sample_rss_feed_burner_feed)
+      expect(Feedjira::Parser::Atom).to_not be_able_to_parse(sample_rss_feed_burner_feed)
     end
 
     it "should return true for an atom feed that has line breaks in between attributes in the <feed> node" do
-      Feedjira::Parser::Atom.should be_able_to_parse(sample_atom_feed_line_breaks)
+      expect(Feedjira::Parser::Atom).to be_able_to_parse(sample_atom_feed_line_breaks)
     end
   end
 
@@ -25,41 +25,43 @@ describe Feedjira::Parser::Atom do
     end
 
     it "should parse the title" do
-      @feed.title.should == "Amazon Web Services Blog"
+      expect(@feed.title).to eq "Amazon Web Services Blog"
     end
 
     it "should parse the description" do
-      @feed.description.should == "Amazon Web Services, Products, Tools, and Developer Information..."
+      expect(@feed.description).to eq "Amazon Web Services, Products, Tools, and Developer Information..."
     end
 
     it "should parse the url" do
-      @feed.url.should == "http://aws.typepad.com/aws/"
+      expect(@feed.url).to eq "http://aws.typepad.com/aws/"
     end
 
     it "should parse the url even when it doesn't have the type='text/html' attribute" do
-      Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml")).url.should == "http://www.innoq.com/planet/"
+      feed = Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml"))
+      expect(feed.url).to eq "http://www.innoq.com/planet/"
     end
 
     it "should parse the feed_url even when it doesn't have the type='application/atom+xml' attribute" do
-      Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml")).feed_url.should == "http://www.innoq.com/planet/atom.xml"
+      feed = Feedjira::Parser::Atom.parse(load_sample("atom_with_link_tag_for_url_unmarked.xml"))
+      expect(feed.feed_url).to eq "http://www.innoq.com/planet/atom.xml"
     end
 
     it "should parse the feed_url" do
-      @feed.feed_url.should == "http://aws.typepad.com/aws/atom.xml"
+      expect(@feed.feed_url).to eq "http://aws.typepad.com/aws/atom.xml"
     end
 
     it "should parse no hub urls" do
-      @feed.hubs.count.should == 0
+      expect(@feed.hubs.count).to eq 0
     end
 
     it "should parse the hub urls" do
       feed_with_hub = Feedjira::Parser::Atom.parse(load_sample("SamRuby.xml"))
-      feed_with_hub.hubs.count.should == 1
-      feed_with_hub.hubs.first.should == "http://pubsubhubbub.appspot.com/"
+      expect(feed_with_hub.hubs.count).to eq 1
+      expect(feed_with_hub.hubs.first).to eq "http://pubsubhubbub.appspot.com/"
     end
 
     it "should parse entries" do
-      @feed.entries.size.should == 10
+      expect(@feed.entries.size).to eq 10
     end
   end
 
@@ -70,7 +72,7 @@ describe Feedjira::Parser::Atom do
       feed = Feedjira::Parser::Atom.parse sample_atom_xhtml_feed
       entry = feed.entries.first
 
-      entry.content.should match /\A\<p/
+      expect(entry.content).to match /\A\<p/
     end
 
     it "should not duplicate content when there are divs in content" do
@@ -78,7 +80,7 @@ describe Feedjira::Parser::Atom do
 
       feed = Feedjira::Parser::Atom.parse sample_duplicate_content_atom_feed
       content = Nokogiri::HTML(feed.entries[1].content)
-      content.css('img').length.should == 11
+      expect(content.css('img').length).to eq 11
     end
   end
 
@@ -88,11 +90,11 @@ describe Feedjira::Parser::Atom do
     end
 
     it "should parse url" do
-      @feed.url.should == "http://feedjira.com/blog"
+      expect(@feed.url).to eq "http://feedjira.com/blog"
     end
 
     it "should parse feed url" do
-      @feed.feed_url.should == "http://feedjira.com/blog/feed.xml"
+      expect(@feed.feed_url).to eq "http://feedjira.com/blog/feed.xml"
     end
   end
 end

data/spec/feedjira/parser/google_docs_atom_entry_spec.rb

@@ -8,15 +8,15 @@ describe Feedjira::Parser::GoogleDocsAtomEntry do
     end
 
     it 'should have the custom checksum element' do
-      @entry.checksum.should eql '2b01142f7481c7b056c4b410d28f33cf'
+      expect(@entry.checksum).to eq '2b01142f7481c7b056c4b410d28f33cf'
     end
 
     it 'should have the custom filename element' do
-      @entry.original_filename.should eql "MyFile.pdf"
+      expect(@entry.original_filename).to eq "MyFile.pdf"
     end
 
     it 'should have the custom suggested filename element' do
-      @entry.suggested_filename.should eql "TaxDocument.pdf"
+      expect(@entry.suggested_filename).to eq "TaxDocument.pdf"
     end
   end
 end

data/spec/feedjira/parser/google_docs_atom_spec.rb

@@ -3,11 +3,11 @@ require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 describe Feedjira::Parser::GoogleDocsAtom do
   describe '.able_to_parser?' do
     it 'should return true for Google Docs feed' do
-      Feedjira::Parser::GoogleDocsAtom.should be_able_to_parse(sample_google_docs_list_feed)
+      expect(Feedjira::Parser::GoogleDocsAtom).to be_able_to_parse(sample_google_docs_list_feed)
     end
 
     it 'should not be able to parse another Atom feed' do
-      Feedjira::Parser::GoogleDocsAtom.should_not be_able_to_parse(sample_atom_feed)
+      expect(Feedjira::Parser::GoogleDocsAtom).to_not be_able_to_parse(sample_atom_feed)
     end
   end
 
@@ -17,15 +17,15 @@ describe Feedjira::Parser::GoogleDocsAtom do
     end
 
     it 'should return a bunch of objects' do
-      @feed.entries.should_not be_empty
+      expect(@feed.entries).to_not be_empty
     end
 
     it 'should populate a title, interhited from the Atom entry' do
-      @feed.title.should_not be_nil
+      expect(@feed.title).to_not be_nil
     end
 
     it 'should return a bunch of entries of type GoogleDocsAtomEntry' do
-      @feed.entries.first.should be_a Feedjira::Parser::GoogleDocsAtomEntry
+      expect(@feed.entries.first).to be_a Feedjira::Parser::GoogleDocsAtomEntry
     end
   end
 end