hootenanny 0.0.1 → 0.1.0

data/spec/lib/hootenanny/hub_spec.rb

@@ -0,0 +1,73 @@
+require 'rspectacular/spec_helpers/active_record_basic'
+require 'hootenanny/hub'
+
+module    Hootenanny
+describe  Hub do
+  it 'can apply the request' do
+    my_request = double
+
+    allow(my_request).to receive(:apply)
+
+    Hub.subscribe(my_request)
+
+    expect(my_request).to(have_received(:apply))
+  end
+
+  it 'can generate a request' do
+    allow(Request).to receive(:build)
+
+    Hub.request(:my_attrs => :my_value)
+
+    expect(Request).to have_received(:build)
+                      .with(:my_attrs => :my_value)
+  end
+
+  it 'can broadcast all notifications' do
+    create(:publish_notification, :unprocessed,
+                                  :topic => 'http://topic1.com')
+    create(:publish_notification, :unprocessed,
+                                  :topic => 'http://topic2.com')
+
+    allow(Hootenanny::Correspondent).to receive(:broadcast).
+                                        and_return true
+
+    Hub.broadcast
+
+    expect(Hootenanny::Correspondent).to have_received(:broadcast).
+                                         with('http://topic1.com')
+
+    expect(Hootenanny::Correspondent).to have_received(:broadcast).
+                                         with('http://topic2.com')
+  end
+
+  it 'removes the notification if it has been broadcast successfully' do
+    notification_the_first  = create(:publish_notification, :unprocessed,
+                                                            :topic => 'http://topic1.com')
+    notification_the_second = create(:publish_notification, :unprocessed,
+                                                            :topic => 'http://topic2.com')
+
+    allow(Hootenanny::Correspondent).to receive(:broadcast).
+                                        and_return true
+
+    Hub.broadcast
+
+    expect(notification_the_first.reload).to  be_processed
+    expect(notification_the_second.reload).to be_processed
+  end
+
+  it 'does not remove the notification if it has not been broadcast successfully' do
+    notification_the_first  = create(:publish_notification, :unprocessed,
+                                                            :topic => 'http://topic1.com')
+    notification_the_second = create(:publish_notification, :unprocessed,
+                                                            :topic => 'http://topic2.com')
+
+    allow(Hootenanny::Correspondent).to receive(:broadcast).
+                                        and_return true
+
+    Hub.broadcast
+
+    expect { notification_the_first.reload }.to  be_true
+    expect { notification_the_second.reload }.to be_true
+  end
+end
+end

data/spec/lib/hootenanny/publish_notification_expiration_policy_spec.rb

@@ -0,0 +1,35 @@
+require 'rspectacular'
+require 'hootenanny/publish_notification_expiration_policy'
+
+module    Hootenanny
+describe  PublishNotificationExpirationPolicy, :time_mock do
+  let(:one_day_ago) { Time.now - 86_400 }
+
+  it 'will expire the item if it has been at least a day since it has been updated' do
+    notification = double(:updated_at => (one_day_ago - 1),
+                          :expire     => true)
+
+    PublishNotificationExpirationPolicy.apply(notification)
+
+    expect(notification).to have_received(:expire)
+  end
+
+  it 'will not expire the item if it has been exactly a day since it has been updated' do
+    notification = double(:updated_at => one_day_ago,
+                          :expire     => true)
+
+    PublishNotificationExpirationPolicy.apply(notification)
+
+    expect(notification).not_to have_received(:expire)
+  end
+
+  it 'will not expire the item if it has been less than a day since it has been updated' do
+    notification = double(:updated_at => (one_day_ago + 1),
+                          :expire     => true)
+
+    PublishNotificationExpirationPolicy.apply(notification)
+
+    expect(notification).not_to have_received(:expire)
+  end
+end
+end

data/spec/lib/hootenanny/request/publish_notification_spec.rb

@@ -0,0 +1,43 @@
+require 'rspectacular/spec_helpers/active_record_basic'
+require 'hootenanny/request/publish_notification'
+
+module    Hootenanny
+describe  Request::PublishNotification do
+  it 'can properly build itself given valid attributes' do
+    my_request = Request::PublishNotification.build(topics: %w{mytopic myothertopic})
+
+    expect(my_request.topics).to eql %w{mytopic myothertopic}
+  end
+
+  it 'requires at least one topic to be buillt' do
+    expect { Request::PublishNotification.build }
+      .to raise_error ::Hootenanny::Request::BuildError
+  end
+
+  it 'generates a Publish Notification for a topic' do
+    allow(PublishNotification).to receive(:notify)
+                                 .and_return(:publish_notification)
+
+    my_request = build( :publish_notification_request,
+                          :topics => 'mytopic')
+
+    expect(my_request.apply).to     have(1).items
+    expect(PublishNotification).to  have_received(:notify)
+                                   .with('mytopic')
+  end
+
+  it 'generates a Publish Notification for each of the topics' do
+    allow(PublishNotification).to receive(:notify)
+                                 .and_return(:publish_notification)
+
+    my_request = build( :publish_notification_request,
+                          :topics => %w{mytopic myothertopic})
+
+    expect(my_request.apply).to     have(2).items
+    expect(PublishNotification).to  have_received(:notify)
+                                   .with('mytopic')
+    expect(PublishNotification).to  have_received(:notify)
+                                   .with('myothertopic')
+  end
+end
+end

data/spec/lib/hootenanny/request/subscription_spec.rb

@@ -0,0 +1,89 @@
+require 'rspectacular/spec_helpers/active_record_basic'
+require 'hootenanny/request/subscription'
+
+module    Hootenanny
+describe  Request::Subscription do
+  let(:verification_class) { double }
+
+  it 'can properly build itself given valid attributes' do
+    my_request = Request::Subscription.build(callback: 'http://mycallback',
+                                             topic:    'http://mytopic',)
+
+    expect(my_request.subscriber).to eql 'http://mycallback'
+    expect(my_request.topic).to      eql 'http://mytopic'
+  end
+
+  it 'requires a callback to be buillt' do
+    expect { Request::Subscription.build(topic: 'http://mytopic') }
+      .to raise_error ::Hootenanny::Request::BuildError
+  end
+
+  it 'requires a topic to be buillt' do
+    expect { Request::Subscription.build(callback: 'http://mycallback') }
+      .to raise_error ::Hootenanny::Request::BuildError
+  end
+
+  it 'generates a Subscription when the request is verified' do
+    allow(Subscription).to receive(:subscribe)
+                          .and_return(:subscription)
+
+    my_request = build( :subscription_request,
+                          :verified,
+                          :subscriber     => 'http://mycallback',
+                          :topic          => 'http://mytopic',
+                          :digest_secret  => 'secret',
+                          :lease_duration => 600)
+
+    expect(my_request.apply).to eql :subscription
+    expect(Subscription).to(    have_received(:subscribe)
+                               .with(         :subscriber     => 'http://mycallback',
+                                              :to             => 'http://mytopic',
+                                              :lease_duration => 600,
+                                              :digest_secret  => 'secret'))
+  end
+
+  it 'defaults the lease duration to 1 hour if none is specified' do
+    allow(Subscription).to receive(:subscribe)
+                          .and_return(:subscription)
+
+    my_request = build( :subscription_request,
+                          :verified,
+                          :subscriber     => 'http://mycallback',
+                          :topic          => 'http://mytopic',
+                          :digest_secret  => 'my big secret')
+
+    expect(my_request.apply).to eql :subscription
+    expect(Subscription).to(    have_received(:subscribe)
+                               .with(         :subscriber     => 'http://mycallback',
+                                              :to             => 'http://mytopic',
+                                              :digest_secret  => 'my big secret',
+                                              :lease_duration => 1_577_880_000))
+  end
+
+  it 'can create a verification with the proper information' do
+    allow(verification_class).to receive(:new)
+                                .and_return(double :verified? => true)
+
+    my_request = build( :subscription_request,
+                          subscriber:         'http://mycallback',
+                          topic:              'http://mytopic',
+                          requester_token:    '12345',
+                          verification_class: verification_class)
+
+    my_request.apply
+
+    expect(verification_class).to have_received(:new)
+                                 .with(
+                                   url:             'http://mycallback',
+                                   mode:            :subscribe,
+                                   topic:           'http://mytopic',
+                                   requester_token: '12345')
+  end
+
+  it 'does not generate a Subscription when the request is unverified' do
+    my_request = build(:subscription_request, :unverified)
+
+    expect { my_request.apply }.to raise_error(Hootenanny::SubscriptionError, 'Request could not be verified.')
+  end
+end
+end

data/spec/lib/hootenanny/request_spec.rb

@@ -0,0 +1,21 @@
+require 'rspectacular'
+require 'hootenanny/request'
+
+module    Hootenanny
+describe  Request do
+  it 'can build the proper request based on the options passed in' do
+    allow(Request::Subscription).to(receive(:build))
+
+    Request.build(type:       :subscription,
+                  other_attr: true)
+
+    expect(Request::Subscription).to(have_received(:build)
+                                    .with(         type:        :subscription,
+                                                   other_attr:  true))
+  end
+
+  it 'raises a wrapped exception whenever no type is passed in' do
+    expect { Request.build({}) }.to raise_error(Request::BuildError, 'key not found: :type')
+  end
+end
+end

data/spec/lib/hootenanny/subscription_delivery_spec.rb

@@ -0,0 +1,54 @@
+require 'rspectacular'
+require 'hootenanny/subscription_delivery'
+
+module    Hootenanny
+describe  SubscriptionDelivery do
+  it 'can deliver a feed to a subscriber' do
+    feed = double(to_s:         'my_feed_content',
+                  content_type: 'application/whatever')
+
+    subscription_stub = stub_request(:post, 'http://example.com').
+      with(:headers => {'Content-Type' => 'application/whatever'}).
+      to_return(:status => 200)
+
+    SubscriptionDelivery.deliver(subscriber:  'http://example.com',
+                                 feed:        feed)
+
+    expect(subscription_stub).to have_been_requested
+  end
+
+  it 'will add a verification digest along with the content if a secret was specified' do
+    feed = double(to_s:         'my_feed_content',
+                  content_type: 'application/whatever')
+
+    subscription_stub = stub_request(:post, 'http://example.com').
+      with(:headers => {'Content-Type'    => 'application/whatever',
+                        'X-Hub-Signature' => 'sha1=dde90de8a0b89aff446c53ff63ec68b4087b0d3b'}).
+      to_return(:status => 200)
+
+    SubscriptionDelivery.deliver(subscriber:  'http://example.com',
+                                 digest_secret: 'secret',
+                                 feed:        feed)
+
+    expect(subscription_stub).to have_been_requested
+  end
+
+  it 'is true if successful' do
+    stub_request(:post, 'http://example.com').
+      to_return(:status => 200)
+
+    expect(SubscriptionDelivery.deliver(subscriber:  'http://example.com',
+                                        feed:        double.as_null_object)).to \
+      be_true
+  end
+
+  it 'is false if unsuccessful' do
+    stub_request(:post, 'http://example.com').
+      to_return(:status => 300)
+
+    expect(SubscriptionDelivery.deliver(subscriber:  'http://example.com',
+                                        feed:        double.as_null_object)).to \
+      be_false
+  end
+end
+end

data/spec/lib/hootenanny/topic_spec.rb

@@ -0,0 +1,15 @@
+require 'rspectacular'
+require 'hootenanny/topic'
+
+module    Hootenanny
+describe  Topic do
+  it 'can create itself from a topic' do
+    expect(Topic.from_url('http://example.com')).to be_a Topic
+  end
+
+  it 'cannot create itself if the URI is invalid' do
+    expect {Topic.from_url('http://#^&@*.com')}.
+    to      raise_error Hootenanny::URI::InvalidError
+  end
+end
+end

data/spec/lib/hootenanny/topic_synchronizer_spec.rb

@@ -0,0 +1,98 @@
+require 'rspectacular'
+require 'hootenanny/topic_synchronizer'
+require 'hootenanny/errors'
+require 'hootenanny/feed_store/file_feed_store'
+
+module    Hootenanny
+describe  TopicSynchronizer do
+  let(:subscription_delivery) { double }
+  let(:subscriber_url)        { 'http://subscriber.com' }
+  let(:topic_url)             { 'http://topic.com' }
+  let(:local_feed_store)      { FeedStore::FileFeedStore.new(
+                                  location:              local_feed_file_path) }
+  let(:remote_feed_store)     { FeedStore::FileFeedStore.new(
+                                  location:              remote_feed_file_path) }
+
+  let(:topic_synchronizer)    { TopicSynchronizer.new(
+                                  subscriber:            subscriber_url,
+                                  topic:                 topic_url,
+                                  local_feed_store:      local_feed_store,
+                                  remote_feed_store:     remote_feed_store,
+                                  subscription_delivery: subscription_delivery) }
+
+  before { allow(subscription_delivery).to receive(:deliver) }
+
+  context 'if there are no new items to deliver' do
+    let(:local_feed_file_path)  { './spec/fixtures/feeds/digest/complete_broadcasted_items' }
+    let(:remote_feed_file_path) { './spec/fixtures/feeds/rss' }
+
+    it 'does not try to deliver anything' do
+      expect(topic_synchronizer.sync).to   be_true
+      expect(subscription_delivery).not_to have_received(:deliver)
+    end
+  end
+
+  context 'if there are items to deliver' do
+    let(:local_feed_file_path)  { './spec/fixtures/feeds/digest/incomplete_broadcasted_items' }
+    let(:remote_feed_file_path) { './spec/fixtures/feeds/rss' }
+
+    context 'and the unsynchronized items were delivered successfully' do
+      before { allow(subscription_delivery).to  receive(:deliver).
+                                                and_return true }
+
+      it 'stores the freshly synchronized feed items' do
+        allow(local_feed_store).to receive(:store)
+
+        topic_synchronizer.sync
+
+        expect(local_feed_store).to have_received(:store)
+      end
+    end
+
+    context 'and the unsynchronized items were not delivered successfully' do
+      before {  allow(subscription_delivery).to receive(:deliver).
+                                                and_return false }
+
+      it 'returns false' do
+        expect(topic_synchronizer.sync).to be_a FalseClass
+      end
+    end
+  end
+
+  it 'retrieves the local feed store from the global configuration if none is passed in' do
+    allow(Hootenanny::Configuration.instance).to receive(:default_local_feed_store)
+
+    TopicSynchronizer.new(subscriber: 'http://subscriber.com',
+                          topic:      'http://topic.com')
+
+    expect(Hootenanny::Configuration.instance).to have_received(:default_local_feed_store)
+  end
+
+  it 'retrieves the remote feed store from the global configuration if none is passed in' do
+    allow(Hootenanny::Configuration.instance).to receive(:default_remote_feed_store)
+
+    TopicSynchronizer.new(subscriber: 'http://subscriber.com',
+                          topic:      'http://topic.com')
+
+    expect(Hootenanny::Configuration.instance).to have_received(:default_remote_feed_store)
+  end
+
+  it 'retrieves the remote feed store from the global configuration if none is passed in' do
+    allow(Hootenanny::Configuration.instance).to receive(:default_remote_feed_store)
+
+    TopicSynchronizer.new(subscriber: 'http://subscriber.com',
+                          topic:      'http://topic.com')
+
+    expect(Hootenanny::Configuration.instance).to have_received(:default_remote_feed_store)
+  end
+
+  it 'retrieves the subscription delivery from the global configuration if none is passed in' do
+    allow(Hootenanny::Configuration.instance).to receive(:default_subscription_delivery)
+
+    TopicSynchronizer.new(subscriber: 'http://subscriber.com',
+                          topic:      'http://topic.com')
+
+    expect(Hootenanny::Configuration.instance).to have_received(:default_subscription_delivery)
+  end
+end
+end

data/spec/lib/hootenanny/uri_spec.rb

@@ -0,0 +1,32 @@
+require 'rspectacular'
+require 'hootenanny/uri'
+
+module    Hootenanny
+describe  URI do
+  it 'removes the anchor portion when parsing a URI' do
+    uri = URI.parse('http://example.com#anchor')
+
+    expect(uri.to_s).to eql 'http://example.com'
+  end
+
+  it 'properly handles the error when the URI is invalid' do
+    expect { URI.parse('http://example.com!!!!!!!!') }.to raise_error Hootenanny::URI::InvalidError
+  end
+
+  it 'allows HTTP URIs' do
+    uri = URI.parse('http://example.com')
+
+    expect(uri.to_s).to eql 'http://example.com'
+  end
+
+  it 'allows HTTPS URIs' do
+    uri = URI.parse('https://example.com')
+
+    expect(uri.to_s).to eql 'https://example.com'
+  end
+
+  it 'does not allow URIs other than HTTP or HTTPS' do
+    expect { URI.parse('ftp://example.com') }.to raise_error Hootenanny::URI::InvalidSchemeError
+  end
+end
+end