hootenanny 0.0.1 → 0.1.0

data/spec/lib/hootenanny/feed/null_feed_spec.rb

@@ -0,0 +1,9 @@
+require 'rspectacular'
+require 'hootenanny/feed/null_feed'
+
+module    Hootenanny
+class     Feed
+describe  NullFeed do
+end
+end
+end

data/spec/lib/hootenanny/feed/rss_feed_item_spec.rb

@@ -0,0 +1,9 @@
+require 'rspectacular'
+require 'hootenanny/feed/rss_feed_item'
+
+module    Hootenanny
+class     Feed
+describe  RSSFeedItem do
+end
+end
+end

data/spec/lib/hootenanny/feed/rss_feed_spec.rb

@@ -0,0 +1,143 @@
+require 'rspectacular'
+require 'hootenanny/feed'
+
+module    Hootenanny
+class     Feed
+describe  RSSFeed do
+  let(:rss_content_path)         { ::File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss') }
+  let(:rss_content)              { ::File.read(rss_content_path).chomp }
+  let(:minimal_rss_content_path) { ::File.expand_path('./spec/fixtures/feeds/rss/minimal_feed.rss') }
+  let(:minimal_rss_content)      { ::File.read(minimal_rss_content_path).chomp }
+
+  it 'can create itself from some RSS' do
+    allow(RSS::Parser).to       receive(:parse)
+                               .and_return('content')
+
+    adapter = RSSFeed.from_content(rss_content)
+
+    expect(adapter).to          be_a Hootenanny::Feed::RSSFeed
+    expect(adapter.content).to  eql  'content'
+    expect(RSS::Parser).to      have_received(:parse)
+                               .with(rss_content)
+  end
+
+  it 'throws an error if the content is not parsable' do
+    expect { RSSFeed.from_content('<asdf') }
+      .to raise_error(Hootenanny::Feed::ParseError)
+  end
+
+  it 'can iterate over each of the items in the feed' do
+    adapter = RSSFeed.from_content(rss_content)
+
+    expect(adapter).to have(2).items
+  end
+
+  it 'can wrap each item in a RSSFeedItem' do
+    adapter = RSSFeed.from_content(rss_content)
+
+    expect(adapter.items.first).to be_a Hootenanny::Feed::RSSFeedItem
+  end
+
+  it 'it properly sets items to an empty array even if the parsed RSS is nil' do
+    feed = RSSFeed.from_content('')
+
+    expect(feed.items).to eql []
+  end
+
+  it 'can properly set content for itself from a String' do
+    rss  = RSS::Parser.parse(minimal_rss_content)
+    feed = RSSFeed.from_content(rss)
+
+    expect(feed.to_s).to eql minimal_rss_content
+  end
+
+  it 'if it is not blank, it always returns a String containing items' do
+    rss  = RSS::Parser.parse(minimal_rss_content)
+    feed = RSSFeed.from_content(rss)
+
+    expect(feed.to_s).to eql minimal_rss_content
+  end
+
+  it 'if it is blank' do
+    feed = RSSFeed.from_content('')
+
+    expect(feed.to_s).to eql ''
+  end
+
+  it 'it properly sets items to an empty array even if no items are in the content' do
+    rss  = RSS::Parser.parse(minimal_rss_content)
+    feed = RSSFeed.from_content(rss)
+
+    expect(feed.items).to eql []
+  end
+
+  it 'it properly sets items to an empty array even if the parsed RSS is nil' do
+    feed = RSSFeed.from_content('')
+
+    expect(feed.items).to eql []
+  end
+
+  it 'can properly set content for itself from a String' do
+    rss  = RSS::Parser.parse(minimal_rss_content)
+    feed = RSSFeed.from_content(rss)
+
+    expect(feed.content).to      be_an RSS::Rss
+    expect(feed.content.to_s).to include rss.to_s
+  end
+
+  it 'can properly set content for itself from an RSS feed' do
+    rss  = RSS::Parser.parse(minimal_rss_content)
+    feed = RSSFeed.from_content(rss)
+
+    expect(feed.content).to      be_an RSS::Rss
+    expect(feed.content.to_s).to include rss.to_s
+  end
+
+  it 'raises an error if it does not know how to parse content' do
+    expect { RSSFeed.from_content(2) }.to raise_error Hootenanny::Feed::ParseError
+  end
+
+  it 'can determine the difference between two feeds' do
+    first_content_path  = ::File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    first_content       = ::File.read(first_content_path)
+
+    second_content_path = ::File.expand_path('./spec/fixtures/feeds/rss/feed_with_one_item.rss')
+    second_content      = ::File.read(second_content_path)
+
+    first_feed          = Feed.infer(first_content,   type: :rss)
+    second_feed         = Feed.infer(second_content,  type: :rss)
+
+    difference_feed     = first_feed - second_feed
+
+    expect(difference_feed.items).to                            have(1).item
+    expect(difference_feed.items).to                            eql [first_feed.items[1]]
+    expect(difference_feed.content.channel.title).to            eql 'Ruby Rogues'
+    expect(difference_feed.items.first.send(:content).title).to eql '108 RR Ruby Trends'
+
+    expect(difference_feed.to_s).to                             include 'Ruby Rogues'
+    expect(difference_feed.to_s).to                             include '108 RR Ruby Trends'
+    expect(difference_feed.to_s).not_to                         include '109 RR Extreme Programming with Will Read'
+  end
+
+  it 'can determine the difference between two feeds of differing types' do
+    first_content_path = ::File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    first_content      = ::File.read(first_content_path)
+
+    second_content     = '{"items": ["01bfe038abb650189f78891be1581a52a7754a9be5fee7f8feeb0f7d617d3dd6"]}'
+
+    first_feed         = Feed.infer(first_content,  type: :rss)
+    second_feed        = Feed.infer(second_content, type: :digest)
+
+    difference_feed    = first_feed - second_feed
+
+    expect(difference_feed.items).to                 have(1).item
+    expect(difference_feed.items).to                 eql [first_feed.items[1]]
+    expect(difference_feed.content.channel.title).to eql 'Ruby Rogues'
+
+    expect(difference_feed.to_s).to                  include 'Ruby Rogues'
+    expect(difference_feed.to_s).to                  include '108 RR Ruby Trends'
+    expect(difference_feed.to_s).not_to              include '109 RR Extreme Programming with Will Read'
+  end
+end
+end
+end

data/spec/lib/hootenanny/feed_spec.rb

@@ -0,0 +1,159 @@
+require 'rspectacular'
+require 'hootenanny/feed'
+
+module    Hootenanny
+describe  Feed do
+  context 'when the content passed in is to be parsed as an RSS document' do
+    let(:content_path) { File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss') }
+    let(:content)      { File.read(content_path) }
+    let(:type)         { :rss }
+
+    it 'can properly create a feed from that' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed).to be_a Hootenanny::Feed::RSSFeed
+    end
+
+    it 'knows it is an RSS feed' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed.type).to eql :rss
+    end
+  end
+
+  context 'when the content passed in is to be parsed as an JSON document' do
+    let(:content_path) { File.expand_path('./spec/fixtures/feeds/json/sample_feed.json') }
+    let(:content)      { File.read(content_path) }
+    let(:type)         { :json }
+
+    it 'can properly create a feed from that' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed).to be_a Hootenanny::Feed::JSONFeed
+    end
+
+    it 'knows it is a JSON feed' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed.type).to eql :json
+    end
+  end
+
+  context 'when the content passed in is to be parsed as an Atom document' do
+    let(:content_path) { File.expand_path('./spec/fixtures/feeds/atom/sample_feed.atom') }
+    let(:content)      { File.read(content_path) }
+    let(:type)         { :atom }
+
+    it 'can properly create a feed from that' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed).to be_a Hootenanny::Feed::AtomFeed
+    end
+
+    it 'knows it is an Atom feed' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed.type).to eql :atom
+    end
+  end
+
+  context 'when the content passed in is to be parsed as an Digest document' do
+    let(:content_path) { File.expand_path('./spec/fixtures/feeds/digest/sample_feed.digest') }
+    let(:content)      { File.read(content_path) }
+    let(:type)         { :digest }
+
+    it 'can properly create a feed from that' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed).to be_a Hootenanny::Feed::DigestFeed
+    end
+
+    it 'knows it is a digest feed' do
+      feed = Feed.infer(content, type: type)
+
+      expect(feed.type).to eql :digest
+    end
+  end
+
+  context 'when the content passed in cannot be parsed as any known type' do
+    let(:type)         { :unknown }
+
+    it 'can properly create a feed from that' do
+      expect { Feed.infer('test content', type: type) }
+        .to raise_error(Hootenanny::Feed::UnknownContentTypeError)
+    end
+  end
+
+  it 'can combine two feeds of the same type together' do
+    first_content_path  = File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    first_content       = File.read(first_content_path)
+
+    second_content_path = File.expand_path('./spec/fixtures/feeds/rss/sample_feed_2.rss')
+    second_content      = File.read(second_content_path)
+
+    first_feed         = Feed.infer(first_content,  type: :rss)
+    second_feed        = Feed.infer(second_content, type: :rss)
+
+    expect(first_feed + second_feed).to have(4).items
+  end
+
+  it 'eliminates duplicates when combining feeds' do
+    first_content_path  = File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    first_content       = File.read(first_content_path)
+
+    second_content_path = File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    second_content      = File.read(second_content_path)
+
+    first_feed         = Feed.infer(first_content,  type: :rss)
+    second_feed        = Feed.infer(second_content, type: :rss)
+
+    expect(first_feed + second_feed).to have(2).items
+  end
+
+  it 'cannot combine feeds of a different type' do
+    first_content_path  = File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    first_content       = File.read(first_content_path)
+
+    second_content_path = File.expand_path('./spec/fixtures/feeds/digest/sample_feed.digest')
+    second_content      = File.read(second_content_path)
+
+    first_feed         = Feed.infer(first_content,  type: :rss)
+    second_feed        = Feed.infer(second_content, type: :digest)
+
+    expect { first_feed + second_feed }.to raise_error Hootenanny::Feed::CombinationError
+  end
+
+  it 'can convert an RSS feed into a Digest feed' do
+    content_path  = File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    content       = File.read(content_path)
+
+    feed = Feed::RSSFeed.from_content(content)
+
+    expect(feed.to_digest_feed.to_s).to eql %Q{{"items":["01bfe038abb650189f78891be1581a52a7754a9be5fee7f8feeb0f7d617d3dd6","a97acd993db7ef4cc74022f357954d3c4b52ab659218b89a59cdd355880d4ef6"]}}
+  end
+
+  it 'can convert a JSON feed into a Digest feed' do
+    content_path  = File.expand_path('./spec/fixtures/feeds/json/sample_feed.json')
+    content       = File.read(content_path)
+
+    feed = Feed::JSONFeed.from_content(content)
+
+    expect(feed.to_digest_feed.to_s).to eql %Q{{"items":["1a6ed1752c74c2b7fcc0f43ce39e53f8f220cd85f85e339b06eb75a0f16bbea8","6d557b1225129abebcb56d4c986dc63bf644ee865c3833f52ca69e75b4275052"]}}
+  end
+
+  it 'can convert a Digest feed into a Digest feed' do
+    content_path  = File.expand_path('./spec/fixtures/feeds/digest/sample_feed.digest')
+    content       = File.read(content_path)
+
+    feed = Feed::DigestFeed.from_content(content)
+
+    expect(feed.to_digest_feed.to_s).to eql %Q{{"items":["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"]}}
+  end
+
+  it 'can convert an empty feed into a Digest feed' do
+    feed = Feed::RSSFeed.from_content('')
+
+    expect(feed.to_digest_feed.to_s).to eql %Q{{"items":[]}}
+  end
+end
+end

data/spec/lib/hootenanny/feed_store/file_feed_store_spec.rb

@@ -0,0 +1,58 @@
+require 'rspectacular'
+require 'hootenanny/feed_store/file_feed_store'
+require 'securerandom'
+
+module    Hootenanny
+class     FeedStore
+describe  FileFeedStore do
+  it 'can create a feed from the retrieved RSS content', :integration do
+    sample_feed_location = './spec/fixtures/feeds/rss'
+
+    store = FileFeedStore.new(location: sample_feed_location)
+
+    expect(store.fetch(url: 'http://topic.com')).to be_an Hootenanny::Feed::RSSFeed
+  end
+
+  it 'can create a feed from the retrieved JSON content', :integration do
+    sample_feed_location = './spec/fixtures/feeds/json'
+
+    store = FileFeedStore.new(location: sample_feed_location)
+
+    expect(store.fetch(url: 'http://topic.com')).to be_an Hootenanny::Feed::JSONFeed
+  end
+
+  it 'can create a feed from the retrieved Atom content', :integration do
+    sample_feed_location = './spec/fixtures/feeds/atom'
+
+    store = FileFeedStore.new(location: sample_feed_location)
+
+    expect(store.fetch(url: 'http://topic.com')).to be_an Hootenanny::Feed::AtomFeed
+  end
+
+  it 'can create a feed from the retrieved Digest content', :integration do
+    sample_feed_location = './spec/fixtures/feeds/digest'
+
+    store = FileFeedStore.new(location: sample_feed_location)
+
+    expect(store.fetch(url: 'http://topic.com')).to be_an Hootenanny::Feed::DigestFeed
+  end
+
+  it 'can store the contents of a feed into a file' do
+    feed = double(to_s: 'feed contents',
+                  type: 'feedtype')
+
+    file_base_path = "./tmp/#{SecureRandom.hex(4)}"
+
+    store = FileFeedStore.new(location: file_base_path)
+
+    store.store(feed: feed,
+                url:  'http://example.com',
+                path: 'more_pathy')
+
+    stored_file_contents = ::File.read("#{file_base_path}/more_pathy/f0e6a6a97042a4f1f.feedtype")
+
+    expect(stored_file_contents).to eql 'feed contents'
+  end
+end
+end
+end

data/spec/lib/hootenanny/feed_store/web_feed_store_spec.rb

@@ -0,0 +1,47 @@
+require 'rspectacular'
+require 'hootenanny/feed_store/web_feed_store'
+
+module    Hootenanny
+class     FeedStore
+describe  WebFeedStore do
+  it 'can create a feed from the retrieved RSS content', :integration do
+    sample_feed         = File.expand_path('./spec/fixtures/feeds/rss/sample_feed.rss')
+    sample_feed_content = File.read(sample_feed)
+
+    stub_request(:get, 'http://example.com')
+      .to_return(body:    sample_feed_content,
+                 headers: {'Content-Type' => 'application/rss+xml'})
+
+    store = WebFeedStore.new
+
+    expect(store.fetch(url: 'http://example.com')).to be_an Hootenanny::Feed::RSSFeed
+  end
+
+  it 'can create a feed from the retrieved JSON content', :integration do
+    sample_feed         = File.expand_path('./spec/fixtures/feeds/json/sample_feed.json')
+    sample_feed_content = File.read(sample_feed)
+
+    stub_request(:get, 'http://example.com')
+      .to_return(body:    sample_feed_content,
+                 headers: {'Content-Type' => 'application/json'})
+
+    store = WebFeedStore.new
+
+    expect(store.fetch(url: 'http://example.com')).to be_an Hootenanny::Feed::JSONFeed
+  end
+
+  it 'can create a feed from the retrieved Atom content', :integration do
+    sample_feed         = File.expand_path('./spec/fixtures/feeds/atom/sample_feed.atom')
+    sample_feed_content = File.read(sample_feed)
+
+    stub_request(:get, 'http://example.com')
+      .to_return(body:    sample_feed_content,
+                 headers: {'Content-Type' => 'application/atom+xml'})
+
+    store = WebFeedStore.new
+
+    expect(store.fetch(url: 'http://example.com')).to be_an Hootenanny::Feed::AtomFeed
+  end
+end
+end
+end

data/spec/lib/hootenanny/feed_store_spec.rb

@@ -0,0 +1,27 @@
+require 'rspectacular'
+require 'hootenanny/feed_store'
+
+module    Hootenanny
+describe  FeedStore do
+  it 'can create the proper feed store based on the type requested' do
+    allow(Hootenanny::FeedStore::WebFeedStore).to receive(:new)
+                                                 .and_return('feed store')
+
+    expect(FeedStore.infer(type: :web))
+      .to eql 'feed store'
+    expect(Hootenanny::FeedStore::WebFeedStore)
+      .to have_received(:new)
+         .with(type: :web)
+  end
+
+  it 'throws an error if the type is not supplied' do
+    expect { FeedStore.infer }
+      .to raise_error(Hootenanny::FeedStore::InferenceError)
+  end
+
+  it 'throws an error if the type is not valid' do
+    expect { FeedStore.infer(type: :unknown) }
+      .to raise_error(Hootenanny::FeedStore::UnknownStorageTypeError)
+  end
+end
+end