feedzirra 0.7.1 → 0.8.0

data/spec/feedzirra/feed_utilities_spec.rb

@@ -1,273 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Feedzirra::FeedUtilities do
-  before(:each) do
-    @klass = Class.new do
-      include SAXMachine
-      include Feedzirra::FeedUtilities
-    end
-  end
-
-  describe "preprocessing" 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
-        @klass.parse sample_rss_feed
-      end
-    end
-
-    context "when the flag is set" do
-      it "calls the preprocessing method" do
-        @klass.preprocess_xml = true
-        @klass.should_receive(:preprocess).
-          and_return sample_rss_feed
-        @klass.parse sample_rss_feed
-      end
-    end
-  end
-
-  describe "instance methods" do
-    it "should provide an updated? accessor" do
-      feed = @klass.new
-      feed.should_not be_updated
-      feed.updated = true
-      feed.should be_updated
-    end
-
-    it "should provide a new_entries accessor" do
-      feed = @klass.new
-      feed.new_entries.should == []
-      feed.new_entries = [:foo]
-      feed.new_entries.should == [:foo]
-    end
-
-    it "should provide an etag accessor" do
-      feed = @klass.new
-      feed.etag = "foo"
-      feed.etag.should == "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
-    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
-    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
-      feed = Feedzirra::Parser::Atom.new
-      entry =Feedzirra::Parser::AtomEntry.new
-      entry.published = Time.now.to_s
-      feed.entries << entry
-      feed.last_modified.should == entry.published
-    end
-
-    it "should not throw an error if one of the entries has published date of nil" do
-      feed = Feedzirra::Parser::Atom.new
-      entry = Feedzirra::Parser::AtomEntry.new
-      entry.published = Time.now.to_s
-      feed.entries << entry
-      feed.entries << Feedzirra::Parser::AtomEntry.new
-      feed.last_modified.should == entry.published
-    end
-  end
-
-  describe "#update_from_feed" do
-    describe "updating feed attributes" do
-      before(:each) do
-        # I'm using the Atom class when I know I should be using a different one. However, this update_from_feed
-        # method would only be called against a feed item.
-        @feed = Feedzirra::Parser::Atom.new
-        @feed.title    = "A title"
-        @feed.url      = "http://pauldix.net"
-        @feed.feed_url = "http://feeds.feedburner.com/PaulDixExplainsNothing"
-        @feed.updated  = false
-        @updated_feed = @feed.dup
-      end
-
-      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
-      end
-
-      it "should not update the title if the same" do
-        @feed.update_from_feed(@updated_feed)
-        @feed.should_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
-      end
-
-      it "should not update the feed_url if the same" do
-        @feed.update_from_feed(@updated_feed)
-        @feed.should_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
-      end
-
-      it "should not update the url if not changed" do
-        @feed.update_from_feed(@updated_feed)
-        @feed.should_not be_updated
-      end
-    end
-
-    describe "updating entries" do
-      before(:each) do
-        # I'm using the Atom class when I know I should be using a different one. However, this update_from_feed
-        # method would only be called against a feed item.
-        @feed = Feedzirra::Parser::Atom.new
-        @feed.title    = "A title"
-        @feed.url      = "http://pauldix.net"
-        @feed.feed_url = "http://feeds.feedburner.com/PaulDixExplainsNothing"
-        @feed.updated  = false
-        @updated_feed = @feed.dup
-        @old_entry = Feedzirra::Parser::AtomEntry.new
-        @old_entry.url = "http://pauldix.net/old.html"
-        @old_entry.published = Time.now.to_s
-        @old_entry.entry_id = "entry_id_old"
-        @new_entry = Feedzirra::Parser::AtomEntry.new
-        @new_entry.url = "http://pauldix.net/new.html"
-        @new_entry.published = (Time.now + 10).to_s
-        @new_entry.entry_id = "entry_id_new"
-        @feed.entries << @old_entry
-        @updated_feed.entries << @new_entry
-        @updated_feed.entries << @old_entry
-      end
-
-      it "should update last-modified from the latest entry date" do
-        @feed.update_from_feed(@updated_feed)
-        @feed.last_modified.should == @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]
-      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)
-      end
-    end
-
-    describe "#update_from_feed" do
-      let(:recent_entry_id) { 'entry_id' }
-      let(:old_entry_id) { nil }
-
-      before(:each) do
-        # I'm using the Atom class when I know I should be using a different one. However, this update_from_feed
-        # method would only be called against a feed item.
-        @feed = Feedzirra::Parser::Atom.new
-        @feed.title    = "A title"
-        @feed.url      = "http://pauldix.net"
-        @feed.feed_url = "http://feeds.feedburner.com/PaulDixExplainsNothing"
-        @feed.updated  = false
-        @updated_feed = @feed.dup
-
-        @old_entry = Feedzirra::Parser::AtomEntry.new
-        @old_entry.url = "http://pauldix.net/old.html"
-        @old_entry.entry_id = old_entry_id
-        @old_entry.published = (Time.now - 10).to_s
-
-        @entry = Feedzirra::Parser::AtomEntry.new
-        @entry.published = (Time.now + 10).to_s
-        @entry.entry_id = recent_entry_id
-        @entry.url = "http://pauldix.net/entry.html"
-
-        # only difference is a changed url
-        @entry_changed_url = @entry.dup
-        @entry_changed_url.url = "http://pauldix.net/updated.html"
-
-        # entry with changed url must be first
-        @feed.entries << @entry
-        @feed.entries << @old_entry
-        @updated_feed.entries << @entry_changed_url
-        @updated_feed.entries << @old_entry
-      end
-
-      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
-        end
-      end
-
-      context "feed not have entry id and only difference is a url" do
-        let(:recent_entry_id) { nil }
-        let(:old_entry_id) { nil }
-
-        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
-        end
-      end
-    end
-
-    describe 'updating with a feed' do
-      let(:id_one) { '1' }
-      let(:id_two) { '2' }
-
-      let(:url_one) { 'http://example.com/post_one.html' }
-      let(:url_two) { 'http://example.com/post_two.html' }
-
-      let(:entry_one) { double 'Entry One', entry_id: id_one, url: url_one }
-      let(:entry_two) { double 'Entry Two', entry_id: id_two, url: url_two }
-
-      let(:feed_one) { Feedzirra::Parser::Atom.new }
-      let(:feed_two) { double 'Feed Two', entries: [entry_two] }
-
-      before do
-        stub_const("Feedzirra::FeedUtilities::UPDATABLE_ATTRIBUTES", [])
-        feed_one.entries << entry_one
-      end
-
-      it 'finds entries with unique ids and urls' do
-        feed_one.update_from_feed feed_two
-        feed_one.new_entries.should eq [entry_two]
-      end
-
-      context 'when the entries have the same id' do
-        let(:id_two) { id_one }
-
-        it 'does not find a new entry' do
-          feed_one.update_from_feed feed_two
-          feed_one.new_entries.should eq []
-        end
-      end
-
-      context 'when the entries have the same url' do
-        let(:url_two) { url_one }
-
-        it 'does not find a new entry' do
-          feed_one.update_from_feed feed_two
-          feed_one.new_entries.should eq []
-        end
-      end
-    end
-  end
-end

data/spec/feedzirra/parser/atom_entry_spec.rb

@@ -1,86 +0,0 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
-
-describe Feedzirra::Parser::AtomEntry do
-  before(:each) do
-    # I don't really like doing it this way because these unit test should only rely on AtomEntry,
-    # but this is actually how it should work. You would never just pass entry xml straight to the AtomEnry
-    @entry = Feedzirra::Parser::Atom.parse(sample_atom_feed).entries.first
-  end
-
-  it "should parse the title" do
-    @entry.title.should == "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"
-  end
-
-  it "should parse the url even when" do
-    Feedzirra::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"
-  end
-
-  it "should parse the author" do
-    @entry.author.should == "AWS Editor"
-  end
-
-  it "should parse the content" do
-    @entry.content.should == 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..."
-  end
-
-  it "should parse the published date" do
-    @entry.published.should == Time.parse_safely("Fri Jan 16 18:21:00 UTC 2009")
-  end
-
-  it "should parse the categories" do
-    @entry.categories.should == ['Turkey', 'Seattle']
-  end
-
-  it "should parse the updated date" do
-    @entry.updated.should == 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"
-  end
-
-  it "should support each" do
-    @entry.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|
-      title_value = value if field == 'title'
-    end
-    title_value.should == "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')
-  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"
-  end
-
-  it "should allow setting field values with hash syntax" do
-    @entry['title'] = "Foobar"
-    @entry.title.should == "Foobar"
-  end
-
-end

data/spec/feedzirra/parser/atom_feed_burner_entry_spec.rb

@@ -1,47 +0,0 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
-
-describe Feedzirra::Parser::AtomFeedBurnerEntry do
-  before(:each) do
-    # I don't really like doing it this way because these unit test should only rely on AtomEntry,
-    # but this is actually how it should work. You would never just pass entry xml straight to the AtomEnry
-    @entry = Feedzirra::Parser::AtomFeedBurner.parse(sample_feedburner_atom_feed).entries.first
-  end
-
-  it "should parse the title" do
-    @entry.title.should == "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 = Feedzirra::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'
-  end
-
-  it "should parse the url" do
-    @entry.url.should == "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 = Feedzirra::Parser::AtomFeedBurner.parse(File.read("#{File.dirname(__FILE__)}/../../sample_feeds/FeedBurnerUrlNoAlternate.xml")).entries.first
-    entry.url.should == 'http://example.com/QQQQ.html'
-  end
-
-  it "should parse the author" do
-    @entry.author.should == "Paul Dix"
-  end
-
-  it "should parse the content" do
-    @entry.content.should == 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..."
-  end
-
-  it "should parse the published date" do
-    @entry.published.should == Time.parse_safely("Thu Jan 22 15:50:22 UTC 2009")
-  end
-
-  it "should parse the categories" do
-    @entry.categories.should == ['Ruby', 'Another Category']
-  end
-end

data/spec/feedzirra/parser/atom_feed_burner_spec.rb

@@ -1,56 +0,0 @@
-require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
-
-describe Feedzirra::Parser::AtomFeedBurner do
-  describe "#will_parse?" do
-    it "should return true for a feedburner atom feed" do
-      Feedzirra::Parser::AtomFeedBurner.should be_able_to_parse(sample_feedburner_atom_feed)
-    end
-
-    it "should return false for an rdf feed" do
-      Feedzirra::Parser::AtomFeedBurner.should_not be_able_to_parse(sample_rdf_feed)
-    end
-
-    it "should return false for a regular atom feed" do
-      Feedzirra::Parser::AtomFeedBurner.should_not be_able_to_parse(sample_atom_feed)
-    end
-
-    it "should return false for an rss feedburner feed" do
-      Feedzirra::Parser::AtomFeedBurner.should_not be_able_to_parse(sample_rss_feed_burner_feed)
-    end
-  end
-
-  describe "parsing" do
-    before(:each) do
-      @feed = Feedzirra::Parser::AtomFeedBurner.parse(sample_feedburner_atom_feed)
-    end
-
-    it "should parse the title" do
-      @feed.title.should == "Paul Dix Explains Nothing"
-    end
-
-    it "should parse the description" do
-      @feed.description.should == "Entrepreneurship, programming, software development, politics, NYC, and random thoughts."
-    end
-
-    it "should parse the url" do
-      @feed.url.should == "http://www.pauldix.net/"
-    end
-
-    it "should parse the feed_url" do
-      @feed.feed_url.should == "http://feeds.feedburner.com/PaulDixExplainsNothing"
-    end
-
-    it "should parse no hub urls" do
-      @feed.hubs.count.should == 0
-    end
-
-    it "should parse hub urls" do
-      feed_with_hub = Feedzirra::Parser::AtomFeedBurner.parse(load_sample("TypePadNews.xml"))
-      feed_with_hub.hubs.count.should == 1
-    end
-
-    it "should parse entries" do
-      @feed.entries.size.should == 5
-    end
-  end
-end