routemaster-drain 2.3.0 → 2.4.0

data/spec/routemaster/integration/cache_spec.rb

@@ -1,73 +1,86 @@
 require 'spec_helper'
 require 'spec/support/uses_redis'
 require 'spec/support/uses_dotenv'
+require 'spec/support/uses_webmock'
+require 'spec/support/server'
 require 'routemaster/cache'
 require 'webrick'
 
-RSpec.describe 'Requests with caching' do
+describe Routemaster::Cache do
   uses_dotenv
   uses_redis
+  uses_webmock
+
+  def time_us
+    Integer(Time.now.to_f * 1e6)
+  end
 
-  let!(:log) { WEBrick::Log.new '/dev/null' }
   let(:service) do
-    WEBrick::HTTPServer.new(Port: 8000, DocumentRoot: Dir.pwd, Logger: log).tap do |server|
+    TestServer.new(8000) do |server|
       server.mount_proc '/test' do |req, res|
-        res.body = { field: 'test' }.to_json
+        res['content-type'] = 'application/json'
+        res['x-timestamp'] = time_us.to_s
+        res.body = { value: time_us }.to_json
       end
     end
   end
 
-  before do
-    @pid = fork do
-      trap 'INT' do service.shutdown end
-      service.start
-    end
-    sleep(0.5) # leave sometime for the previous webrick to teardown
-  end
+  before { service.start }
+  after { service.stop }
 
-  after do
-    Process.kill('KILL', @pid)
-    Process.wait(@pid)
-  end
-
-  subject { Routemaster::Cache.new }
+  before { WebMock.disable_net_connect!(allow_localhost: true) }
 
-  describe 'GET request' do
-    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
-    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
+  shared_examples 'a cached GET' do
     let(:url) { 'http://localhost:8000/test' }
 
+    let(:response) { perform.call }
+
     context 'when there is no previous cached response' do
-      it 'makes an http call' do
-        response = subject.get(url)
-        expect(response.headers['server']).to be
+      it 'makes a HTTP request' do
+        perform.call
+        expect(WebMock).to have_requested(:get, url) 
       end
 
-      it 'sets the new response onto the cache' do
-        expect { subject.get(url) }
-          .to change { Routemaster::Config.cache_redis.hget(*body_cache_keys)}
-          .from(nil)
-          .to({ field: 'test'}.to_json)
+      it 'returns fresh headers' do
+        time_before = time_us()
+        expect(response.headers['x-timestamp'].to_i).to be > time_before
       end
 
-      it 'sets the response headers onto the cache' do
-        expect { subject.get(url) }
-          .to change { Routemaster::Config.cache_redis.hget(*headers_cache_keys)}
-          .from(nil)
+      it 'returns a fresh body' do
+        time_before = time_us()
+        expect(response.body.value).to be > time_before
       end
     end
 
-    context 'when there is a previous cached response' do
-      before { subject.get(url) }
+    context 'when there is a cached response' do
+      before { perform.call }
 
-      it 'fetches the cached response' do
-        expect(subject.get(url).body).to eq({ field: 'test' }.to_json)
+      it 'returns cached headers' do
+        time_before = time_us()
+        expect(response.headers['x-timestamp'].to_i).to be < time_before
       end
 
-      it 'does not make an http call' do
-        response = subject.get(url)
-        expect(response.env.request).to be_empty
+      it 'returns a cached body' do
+        time_before = time_us()
+        expect(response.body.value).to be < time_before
+      end
+
+      it 'makes no HTTP requests' do
+        WebMock.reset!
+        perform.call
+        expect(WebMock).not_to have_requested(:any, //)
       end
     end
   end
+
+
+  describe '#get' do
+    let(:perform) { -> { subject.get(url) } }
+    it_behaves_like 'a cached GET'
+  end
+
+  describe '#fget' do
+    let(:perform) { -> { subject.fget(url).value } }
+    it_behaves_like 'a cached GET'
+  end
 end

data/spec/routemaster/middleware/cache_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'spec/support/rack_test'
 require 'routemaster/middleware/cache'
+require 'routemaster/event_index'
 
 RSpec.describe Routemaster::Middleware::Cache do
   # busts the cache for each dirty url
@@ -8,7 +9,7 @@ RSpec.describe Routemaster::Middleware::Cache do
   let(:terminator) { ErrorRackApp.new }
   let(:app) { described_class.new(terminator, **options) }
   let(:client) { Routemaster::Jobs::Client.new }
-  let(:cache) { instance_double(Routemaster::Cache, bust: nil) }
+  let(:cache) { instance_double(Routemaster::Cache, bust: nil, invalidate: nil) }
   let(:options) {{ cache: cache, client: client }}
 
   let(:perform) do
@@ -18,8 +19,8 @@ RSpec.describe Routemaster::Middleware::Cache do
   describe '#call' do
     let(:payload) { ['https://example.com/1'] }
 
-    it 'busts the cache' do
-      expect(cache).to receive(:bust).with(payload.first)
+    it 'increments the event_index' do
+      expect(cache).to receive(:invalidate)
       perform
     end
 
@@ -29,6 +30,3 @@ RSpec.describe Routemaster::Middleware::Cache do
     end
   end
 end
-
-
-

data/spec/routemaster/redis_broker_spec.rb

@@ -6,50 +6,50 @@ describe Routemaster::RedisBroker do
   subject { Class.new(Routemaster::RedisBroker).instance }
 
   describe "#get" do
-    let(:url)   { 'redis://localhost/12' }
+    let(:urls)   { ['redis://localhost/12'] }
 
     context "setting up a redis namespace" do
-      let(:redis)           { instance_double(Redis) }
+      let(:redis)           { instance_double(Redis, id: 1) }
       let(:redis_namespace) { instance_double(Redis::Namespace) }
 
       before do
-        allow(Redis).to receive(:new) { redis }
+        allow(Redis::Distributed).to receive(:new) { redis }
         allow(Redis::Namespace).to receive(:new) { redis_namespace }
       end
 
       it 'returns a namespaced redis connection' do
-        expect(subject.get(url)).to eq(redis_namespace)
+        expect(subject.get(:name, urls: urls)).to eq(redis_namespace)
       end
 
       it 'uses the url to initialise redis' do
-        expect(Redis).to receive(:new).with(url: url)
-        subject.get(url)
+        expect(Redis::Distributed).to receive(:new).with(urls)
+        subject.get(:name, urls: urls)
       end
 
       it 'namespaces with rm by default' do
         expect(Redis::Namespace).to receive(:new).with('rm', redis: redis)
-        subject.get(url)
+        subject.get(:name, urls: urls)
       end
 
       it 'can use a namespace based on the url' do
         expect(Redis::Namespace).to receive(:new).with('other', redis: redis)
-        subject.get('redis://localhost/12/other')
+        subject.get(:name, urls: ['redis://localhost/12/other'])
       end
     end
 
     context "when we are in the same process" do
       it 'is a single connection for each url' do
-        expect(subject.get(url)).to eql(subject.get(url))
+        expect(subject.get(:name, urls: urls)).to eql(subject.get(:name, urls: urls))
       end
     end
 
     context "when we have forked" do
-      let!(:connection) { subject.get(url) }
+      let!(:connection) { subject.get(:name, urls: urls) }
 
       it 'is a new connection for the newly forked process' do
         # this is tied to implementation, but tests a 'fork' well enough
         allow(Process).to receive(:pid) { -1 }
-        expect(subject.get(url)).to_not eql(connection)
+        expect(subject.get(:name, urls: urls)).to_not eql(connection)
       end
     end
   end

data/spec/routemaster/resources/rest_resource_spec.rb

@@ -10,6 +10,8 @@ module Routemaster
 
       subject { described_class.new(url, client: client) }
 
+      before { allow(client).to receive(:with_response).and_yield }
+
       describe '#create' do
         it 'posts to the given url' do
           expect(client).to receive(:post).with(url, body: params)
@@ -19,14 +21,14 @@ module Routemaster
 
       describe '#show' do
         it 'gets to the given url' do
-          expect(client).to receive(:get).with(url)
+          expect(client).to receive(:get).with(url, options: { enable_caching: true })
           subject.show(1)
         end
       end
 
       describe '#index' do
         it 'gets to the given url' do
-          expect(client).to receive(:get).with(url)
+          expect(client).to receive(:get).with(url, params: {}, options: { enable_caching: false })
           subject.index
         end
       end

data/spec/routemaster/responses/future_response_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'hashie/mash'
+require 'routemaster/responses/future_response'
+
+describe Routemaster::Responses::FutureResponse do
+  %i[status headers body].each do |method|
+    it "passes through '#{method}'" do
+      future = described_class.new { Hashie::Mash.new(method => 'foobar') }
+      expect(future.public_send(method)).to eq('foobar')
+    end
+  end
+
+  it 're-raises exceptions' do
+    future = described_class.new { raise 'foobar' }
+
+    expect { future.status }.to raise_error(RuntimeError, 'foobar')
+  end
+end

data/spec/routemaster/responses/hateoas_enumerable_response_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'spec/support/uses_webmock'
+require 'spec/support/uses_redis'
+require 'routemaster/responses/hateoas_enumerable_response'
+
+# need to load this here to resolve circular dependency
+require 'routemaster/resources/rest_resource'
+
+describe Routemaster::Responses::HateoasEnumerableResponse do
+  uses_webmock
+  uses_redis
+
+  let(:resource_tpl) { Addressable::Template.new('https://example.com/shebangs/{id}') }
+  let(:index_tpl) { Addressable::Template.new('https://example.com/shebangs{?page,per_page}') }
+  let(:index_url) { index_tpl.expand(page: nil, per_page:nil).to_s }
+  let(:pages) { 5 }
+  let(:per_page) { 3 }
+
+  before do
+    @resource_stub = stub_request(:get, resource_tpl).to_return do |req|
+      { 
+        status: 200, 
+        headers: { 'Content-Type' => 'application/json' }, 
+        body: {
+          id: req.uri.path.split('/').last.to_i,
+          _links: {
+            self: { href: req.uri.to_s },
+          }
+        }.to_json
+      }
+    end
+
+    @index_stub = stub_request(:get, index_tpl).to_return do |req|
+      req.uri.query_values ||= { 'page' => '1' }
+      page = req.uri.query_values['page'].to_i
+      start = (page-1) * per_page + 1
+      stop  = page * per_page
+
+      data = Hashie::Mash.new(
+        _links: {
+          self: { href: index_tpl.expand(page: page, per_page: per_page).to_s },
+          shebangs: (start..stop).map { |idx|
+            { href: resource_tpl.expand(id: idx).to_s }
+          }
+        },
+        page: page,
+        per_page: per_page,
+        total: pages * per_page,
+      )
+
+      data._links.next!.href = index_tpl.expand(page: page+1, per_page: per_page).to_s if page < pages
+      data._links.prev!.href = index_tpl.expand(page: page-1, per_page: per_page).to_s if page > 1
+
+      { status: 200, headers: { 'Content-Type' => 'application/json' },  body: data.to_json }
+    end
+  end
+
+  let(:client) { Routemaster::APIClient.new }
+  subject { described_class.new(client.get(index_url)) }
+
+  # so we don't pollute future specs with pending requests:
+  after { Routemaster::Responses::FutureResponse::Pool.reset }
+
+  describe '#each' do
+    it 'is enumerable' do
+      expect(subject.count).to eq(15)
+    end
+
+    it 'lists all paginated resources' do
+      expect(subject.map(&:body).map(&:id)).to eq (1..15).to_a
+    end
+
+    it 'does not fetch eagerly' do
+      subject.first
+      expect(@index_stub).to have_been_requested.once
+    end
+  end
+end

data/spec/routemaster/responses/hateoas_response_spec.rb

@@ -1,59 +1,58 @@
 require 'spec_helper'
 require 'routemaster/responses/hateoas_response'
 
-module Routemaster
-  module Responses
-    RSpec.describe HateoasResponse do
-      let(:response) { double('Response', status: status, body: body, headers: headers) }
-      let(:status) { 200 }
-      let(:body) { {}.to_json }
-      let(:headers) { {} }
-
-      subject { described_class.new(response) }
-
-      context 'link traversal' do
-        let(:body) do
-          {
-            '_links' => {
-              'self' => { 'href' => 'self_url' },
-              'resource_a' => { 'href' => 'resource_a_url' },
-              'resource_b' => { 'href' => 'resource_b_url' }
-            }
-          }
-        end
-
-        it 'creates a method for every key in _links attribute' do
-          expect(subject.resource_a.url).to eq('resource_a_url')
-          expect(subject.resource_b.url).to eq('resource_b_url')
-        end
-
-        it 'creates a _self method if there is a link with name self' do
-          expect(subject._self.url).to eq('self_url')
-        end
-
-        it 'raise an exception when requested link does not exist' do
-          expect { subject.some_unsupported_link }.to raise_error(NoMethodError)
-        end
-
-        describe '#body_without_links' do
-          before do
-            body.merge!('foo' => 'bar')
-          end
-
-          it 'returns the body without the _links key' do
-            expect(subject.body_without_links).to eq({ 'foo' => 'bar' })
-          end
-        end
-
-        describe '#has?' do
-          it 'returns true for an existing link' do
-            expect(subject.has?(:resource_a)).to be_truthy
-          end
-
-          it 'returns false for a non existing link' do
-            expect(subject.has?(:other_resource)).to be_falsy
-          end
-        end
+# need to laod this here to resolve circular dependency
+require 'routemaster/resources/rest_resource'
+
+describe Routemaster::Responses::HateoasResponse do
+  let(:response) { double('Response', status: status, body: body, headers: headers) }
+  let(:status) { 200 }
+  let(:body) { {}.to_json }
+  let(:headers) { {} }
+
+  subject { described_class.new(response) }
+
+  context 'link traversal' do
+    let(:body) do
+      {
+        '_links' => {
+          'self' => { 'href' => 'self_url' },
+          'resource_a' => { 'href' => 'resource_a_url' },
+          'resource_b' => { 'href' => 'resource_b_url' }
+        }
+      }
+    end
+
+    it 'creates a method for every key in _links attribute' do
+      expect(subject.resource_a.url).to eq('resource_a_url')
+      expect(subject.resource_b.url).to eq('resource_b_url')
+    end
+
+    it 'creates a _self method if there is a link with name self' do
+      expect(subject._self.url).to eq('self_url')
+    end
+
+    it 'raise an exception when requested link does not exist' do
+      expect { subject.some_unsupported_link }.to raise_error(NoMethodError)
+    end
+
+    describe '#body_without_links' do
+      before do
+        body.merge!('foo' => 'bar')
+      end
+
+      it 'returns the body without the _links key' do
+        expect(subject.body_without_links).to eq({ 'foo' => 'bar' })
+      end
+    end
+
+    describe '#has?' do
+      it 'returns true for an existing link' do
+        expect(subject.has?(:resource_a)).to be_truthy
+      end
+
+      it 'returns false for a non existing link' do
+        expect(subject.has?(:other_resource)).to be_falsy
       end
     end
   end