routemaster-drain 1.0.0

data/spec/routemaster/dirty/filter_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'spec/support/uses_redis'
+require 'routemaster/dirty/filter'
+
+describe Routemaster::Dirty::Filter do
+  uses_redis
+
+  def make_url(idx) ; "https://example.com/#{idx}" ; end
+
+  describe '#initialize' do
+    it 'passes without options' do
+      expect { described_class.new }.not_to raise_error
+    end
+
+    it 'accepts :redis' do
+      expect { described_class.new(redis: double) }.not_to raise_error
+    end
+  end
+
+  describe '#run' do
+    let(:options) {{ redis:  redis }}
+    subject { described_class.new(options) }
+
+    let(:result) { subject.run(payload) }
+    let(:payload) { [] }
+
+    context 'blank slate' do
+      %w(create delete update).each do |event|
+        let(:url) { make_url(1) }
+
+        it "keeps a '#{event}' event" do
+          event = { 'topic' => 'stuff', 'type' => event, 'url' => url, 't' => 1234 }
+          payload.push event
+          expect(result).to include(event)
+        end
+      end
+    end
+
+    context 'with a prior event' do
+      let(:url) { make_url(1) }
+      let(:prior_event) {{ 'topic' => 'stuff', 'type' => 'update', 'url' => url, 't' => 1234 }}
+
+      before { payload.push prior_event }
+
+      it "keeps a newer event" do
+        newer_event = { 'topic' => 'stuff', 'type' => 'update', 'url' => url, 't' => 1235 }
+        payload.push newer_event
+        expect(result).to eq([newer_event])
+      end
+
+      it "does keep an older event" do
+        older_event = { 'topic' => 'stuff', 'type' => 'update', 'url' => url, 't' => 1233 }
+        payload.push older_event
+        expect(result).to eq([prior_event])
+      end
+    end
+
+    context 'with a prior state' do
+      let(:url) { make_url(1) }
+      let(:prior_event) {{ 'topic' => 'stuff', 'type' => 'update', 'url' => url, 't' => 1234 }}
+
+      before { subject.run([prior_event]) }
+
+      it "keeps a newer event" do
+        newer_event = { 'topic' => 'stuff', 'type' => 'update', 'url' => url, 't' => 1235 }
+        payload.push newer_event
+        expect(result).to eq([newer_event])
+      end
+
+      it "does not keep an older event" do
+        older_event = { 'topic' => 'stuff', 'type' => 'update', 'url' => url, 't' => 1233 }
+        payload.push older_event
+        expect(result).to be_empty
+      end
+    end
+  end
+end

data/spec/routemaster/dirty/map_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'spec/support/uses_redis'
+require 'routemaster/dirty/map'
+
+describe Routemaster::Dirty::Map do
+  uses_redis
+
+  subject { described_class.new(redis: redis) }
+
+  def url(idx) ; "https://example.com/#{idx}" ; end
+
+  def mark_urls(count)
+    1.upto(count) do |idx|
+      subject.mark(url(idx))
+    end
+  end
+
+  describe '#mark' do
+    it 'passes' do
+      expect { subject.mark(url(1)) }.not_to raise_error
+    end
+
+    it 'returns true if marking for the first time' do
+      expect(subject.mark(url(1))).to eq(true)
+    end
+
+    it 'returns false if re-marking' do
+      subject.mark(url(1))
+      expect(subject.mark(url(1))).to eq(false)
+    end
+  
+    context 'with a listener' do
+      let(:handler) { double }
+      before { subject.subscribe(handler, prefix: true) }
+
+      
+      it 'broadcasts :dirty_entity on new mark' do
+        expect(handler).to receive(:on_dirty_entity).exactly(10).times
+        mark_urls(10)
+      end
+
+      it 'does not broadcast on re-marks' do
+        mark_urls(5)
+        expect(handler).to receive(:on_dirty_entity).exactly(5).times
+        mark_urls(10)
+      end
+    end
+  end
+  
+  describe '#sweep' do
+    it 'does not yield with no marks' do
+      expect { |b| subject.sweep(&b) }.not_to yield_control
+    end
+
+    it 'yields marked URLs' do
+      mark_urls(3)
+      expect { |b| subject.sweep(&b) }.to yield_control.exactly(3).times
+    end
+
+    it 'does not yield if called again' do
+      mark_urls(3)
+      subject.sweep { |url| true }
+      expect { |b| subject.sweep(&b) }.not_to yield_control
+    end
+
+    it 'honours "next"' do
+      mark_urls(10)
+      subject.sweep { |url| next if url =~ /3/ ; true }
+      expect { |b| subject.sweep(&b) }.to yield_control.exactly(1).times
+    end
+
+    it 'yields the same URL again if the block returns falsy' do
+      mark_urls(10)
+      subject.sweep { |url| url =~ /7/ ? false : true }
+      expect { |b| subject.sweep(&b) }.to yield_with_args(/7/)
+    end
+
+    it 'yields again if the block fails' do
+      mark_urls(1)
+      expect {
+        subject.sweep { |url| raise }
+      }.to raise_error(RuntimeError)
+      expect { |b| subject.sweep(&b) }.to yield_control.exactly(1).times
+    end
+  end
+
+  describe '#sweep_one' do
+    it 'takes one URL' do
+      mark_urls(3)
+      expect { |b| subject.sweep_one(url(1), &b) }.to yield_control.exactly(:once)
+    end
+
+    it 'processes exactly one URL' do
+      mark_urls(3)
+      subject.sweep_one(url(1)) { true }
+      expect(subject.count).to eq(2)
+    end
+
+    it 'does not sweep if block returns falsy' do
+      mark_urls(3)
+      subject.sweep_one(url(1)) { nil }
+      expect(subject.count).to eq(3)
+    end
+  end
+
+  describe '#count' do
+    it 'is 0 by default' do
+      expect(subject.count).to eq(0)
+    end
+
+    it 'increases when marking' do
+      expect { mark_urls(10) }.to change { subject.count }.by(10)
+    end
+
+    it 'decreases when sweeping' do
+      mark_urls(10)
+      limit = 4
+      subject.sweep { |url| (limit -= 1) < 0 ? false : true }
+      expect(subject.count).to eq(6)
+    end
+  end
+end

data/spec/routemaster/dirty/state_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'spec/support/uses_redis'
+require 'routemaster/dirty/state'
+
+describe Routemaster::Dirty::State do
+  uses_redis
+  
+  let(:argv) {[ 'https://example.com/1', 1234 ]}
+  subject { described_class.new(*argv) }
+
+  describe '#initialize' do
+    it 'accepts url, exists flag, timestamp in order' do
+      expect(subject.url).to eq('https://example.com/1')
+      expect(subject.t).to eq(1234)
+    end
+  end
+
+  describe '.get' do
+    it 'uses different keys for different URLs' do
+      keys = Set.new
+      allow(redis).to receive(:get) { |key| keys.add(key) ; nil }
+      described_class.get(redis, 'https://example.com/1')
+      described_class.get(redis, 'https://example.com/2')
+      expect(keys.size).to eq(2)
+    end
+
+    it 'return a null state when cache is empty' do
+      state = described_class.get(redis, 'https://example.com/1')
+      expect(state.url).to eq('https://example.com/1')
+      expect(state.t).to eq(0)
+    end
+  end
+
+  describe '#save' do
+    it 'saves data that can be .get' do
+      subject.save(redis, 1)
+      loaded = described_class.get(redis, subject.url)
+      expect(loaded).to eq(subject)
+    end
+  end
+end

data/spec/routemaster/drain/basic_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'spec/support/rack_test'
+require 'spec/support/uses_redis'
+require 'spec/support/uses_dotenv'
+require 'spec/support/events'
+require 'routemaster/drain/basic'
+require 'json'
+
+describe Routemaster::Drain::Basic do
+  uses_dotenv
+  uses_redis
+
+  let(:app) { described_class.new }
+  let(:listener) { double 'listener' }
+  
+  before { app.subscribe(listener, prefix: true) }
+
+  let(:path)    { '/' }
+  let(:payload) { [1,2,3,1].map { |idx| make_event(idx) }.to_json }
+  let(:environment) {{ 'CONTENT_TYPE' => 'application/json' }}
+  let(:perform) { post path, payload, environment }
+
+  before { authorize 'd3m0', 'x' }
+
+  it 'succeeds' do
+    perform
+    expect(last_response.status).to eq(204)
+  end
+
+  it 'emits events' do
+    expect(listener).to receive(:on_events_received) do |payload|
+      expect(payload.size).to eq(4)
+    end
+    perform
+  end
+end
+

data/spec/routemaster/drain/caching_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'spec/support/rack_test'
+require 'spec/support/uses_redis'
+require 'spec/support/uses_dotenv'
+require 'spec/support/events'
+require 'routemaster/drain/caching'
+require 'json'
+
+describe Routemaster::Drain::Caching do
+  uses_dotenv
+  uses_redis
+
+  let(:app) { described_class.new }
+  let(:listener) { double 'listener' }
+  
+  before { app.subscribe(listener, prefix: true) }
+
+  let(:path)    { '/' }
+  let(:payload) { [1,2,3,1].map { |idx| make_event(idx) }.to_json }
+  let(:environment) {{ 'CONTENT_TYPE' => 'application/json' }}
+  let(:perform) { post path, payload, environment }
+
+  before { authorize 'd3m0', 'x' }
+
+  it 'succeeds' do
+    perform
+    expect(last_response.status).to eq(204)
+  end
+
+  it 'emits events' do
+    expect(listener).to receive(:on_events_received) do |payload|
+      expect(payload.size).to eq(3)
+    end
+    perform
+  end
+
+  it 'busts the cache' do
+    expect_any_instance_of(Routemaster::Cache).to receive(:bust).exactly(3).times
+    perform
+  end
+
+  it 'schedules caching jobs' do
+    expect(Resque).to receive(:enqueue_to).exactly(3).times
+    perform
+  end
+end
+

data/spec/routemaster/drain/mapping_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'spec/support/rack_test'
+require 'spec/support/uses_redis'
+require 'spec/support/uses_dotenv'
+require 'spec/support/events'
+require 'routemaster/drain/mapping'
+require 'json'
+
+describe Routemaster::Drain::Mapping do
+  uses_dotenv
+  uses_redis
+
+  let(:app) { described_class.new }
+  let(:listener) { double 'listener' }
+  
+  before { app.subscribe(listener, prefix: true) }
+
+  let(:path)    { '/' }
+  let(:payload) { [1,2,3,1].map { |idx| make_event(idx) }.to_json }
+  let(:environment) {{ 'CONTENT_TYPE' => 'application/json' }}
+  let(:perform) { post path, payload, environment }
+
+  before { authorize 'd3m0', 'x' }
+
+  it 'succeeds' do
+    perform
+    expect(last_response.status).to eq(204)
+  end
+
+  it 'filters events' do
+    expect(listener).to receive(:on_events_received) do |payload|
+      expect(payload.size).to eq(3) # the second 1 is filtered
+    end
+    perform
+  end
+
+  let(:map) { Routemaster::Dirty::Map.new }
+  
+  it 'uses dirty map' do
+    payload1 = [1,2,3,1].map { |idx| make_event(idx) }.to_json
+    payload2 = [1,4,5,2].map { |idx| make_event(idx) }.to_json
+    
+    post path, payload1, environment
+    expect(map.count).to eq(3)
+    map.sweep_one("https://example.com/stuff/1") { true }
+
+    post path, payload2, environment
+    expect(map.count).to eq(4) # 2, 3, 4, 5 (1 is a repeat event, filtered out)
+  end
+end
+

data/spec/routemaster/drain/terminator_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'spec/support/rack_test'
+require 'spec/support/events'
+require 'routemaster/drain/terminator'
+
+describe Routemaster::Drain::Terminator do
+  let(:app) { described_class.new }
+  let(:listener) { double }
+
+  let(:perform) do
+    post '/whatever', '', 'routemaster.payload' => payload
+  end
+
+  before do
+    app.subscribe(listener, prefix: true)
+  end
+  
+
+  context 'when a payload is present' do
+    let(:payload) { [double('event')] } 
+
+    it 'responds 204' do
+      perform
+      expect(last_response.status).to eq(204)
+    end
+
+    it 'broadcasts :events_received' do
+      expect(listener).to receive(:on_events_received).with(payload)
+      perform
+    end
+  end
+
+  context 'when a payload is present but empty' do
+    let(:payload) { [] } 
+
+    it 'responds 204' do
+      perform
+      expect(last_response.status).to eq(204)
+    end
+
+    it 'does not broadcast :events_received' do
+      expect(listener).not_to receive(:on_events_received)
+      perform
+    end
+  end
+
+  context 'when there is no payload' do
+    let(:payload) { nil } 
+
+    it 'responds 400' do
+      perform
+      expect(last_response.status).to eq(400)
+    end
+
+    it 'does not broadcast' do
+      expect(listener).not_to receive(:on_events_received)
+      perform
+    end
+  end
+end
+

data/spec/routemaster/fetcher_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'spec/support/uses_dotenv'
+require 'spec/support/uses_webmock'
+require 'routemaster/fetcher'
+require 'json'
+
+describe Routemaster::Fetcher do
+  uses_dotenv
+  uses_webmock
+
+  describe '.get' do
+    let(:url) { 'https://example.com/widgets/132' }
+    let(:headers) {{}}
+    subject { described_class.get(url, headers: headers) }
+
+    before do
+      @req = stub_request(:get, /example\.com/).to_return(
+        status:   200,
+        body:     { id: 132, type: 'widget' }.to_json,
+        headers:  {
+          'content-type' => 'application/json;v=1'
+        }
+      )
+    end
+
+    it 'GETs from the URL' do
+      subject
+      expect(@req).to have_been_requested
+    end
+
+    it 'has :status, :headers, :body' do
+      expect(subject.status).to eq(200)
+      expect(subject.headers).to have_key('content-type')
+      expect(subject.body).not_to be_nil
+    end
+
+    it 'mashifies body' do
+      expect(subject.body.id).to eq(132)
+    end
+
+    it 'uses auth' do
+      subject
+      assert_requested(:get, /example/) do |req|
+        expect(req.uri.userinfo).to eq('username:s3cr3t')
+      end
+    end
+
+    it 'passes headers' do
+      headers['x-custom-header'] = 'why do you even'
+      subject
+      assert_requested(:get, /example/) do |req|
+        expect(req.headers).to include('X-Custom-Header')
+      end
+    end
+  end
+end