routemaster-drain 2.3.0 → 2.4.0

data/spec/routemaster/drain/caching_spec.rb

@@ -34,8 +34,10 @@ describe Routemaster::Drain::Caching do
     perform
   end
 
-  it 'busts the cache' do
-    expect_any_instance_of(Routemaster::Cache).to receive(:bust).exactly(3).times
+  it 'increments the event index' do
+    ei_double = double(increment: 1)
+    allow(Routemaster::EventIndex).to receive(:new).and_return(ei_double)
+    expect(ei_double).to receive(:increment).exactly(3).times
     perform
   end
 
@@ -44,4 +46,3 @@ describe Routemaster::Drain::Caching do
     perform
   end
 end
-

data/spec/routemaster/integration/api_client_spec.rb

@@ -1,24 +1,25 @@
 require 'spec_helper'
 require 'spec/support/uses_redis'
 require 'spec/support/uses_dotenv'
+require 'spec/support/uses_webmock'
+require 'spec/support/server'
+require 'spec/support/breakpoint_class'
 require 'routemaster/api_client'
-require 'webrick'
+require 'routemaster/cache'
+require 'dogstatsd'
 
-RSpec.describe 'Api client integration specs' do
-  module WEBrick
-    module HTTPServlet
-      class ProcHandler
-        alias do_PATCH do_GET
-      end
-    end
+describe Routemaster::APIClient do
+  def now
+    (Time.now.to_f * 1e6).to_i
   end
 
   uses_dotenv
   uses_redis
+  uses_webmock
 
-  let!(:log) { WEBrick::Log.new '/dev/null' }
+  let(:port) { 8000 }
   let(:service) do
-    WEBrick::HTTPServer.new(Port: 8000, DocumentRoot: Dir.pwd, Logger: log).tap do |server|
+    TestServer.new(port) do |server|
       [400, 401, 403, 404, 409, 412, 413, 429, 500].each do |status_code|
         server.mount_proc "/#{status_code}" do |req, res|
           res.status = status_code
@@ -30,127 +31,285 @@ RSpec.describe 'Api client integration specs' do
         res.status = 200
         res.body = { field: 'test' }.to_json
       end
-    end
-  end
 
-  before do
-    @pid = fork do
-      trap 'INT' do service.shutdown end
-      service.start
+      server.mount_proc "/resources/1" do |req, res|
+        res['Content-Type'] = 'application/json'
+        res.status = 200
+        res.body = { attribute: 'value', updated_at: now }.to_json
+      end
+
+      server.mount_proc "/discover" do |req, res|
+        res['Content-Type'] = 'application/json'
+        res.status = 200
+        res.body = { _links: { resources: { href: "http://localhost:#{port}/resources" } } }.to_json
+      end
+
+      server.mount_proc "/resources" do |req, res|
+        res['Content-Type'] = 'application/json'
+        res.status = 200
+        case req.query_string
+        when "first_name=roo"
+          res.body = {
+            _links: {
+              self: {
+                href: "http://localhost:#{port}/resourcess?first_name=roo&page=1&per_page=2"
+              },
+              first: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=1&per_page=2"
+              },
+              last: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=3&per_page=2"
+              },
+              next: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=2&per_page=2"
+              },
+              resources: [
+                { href: "http://localhost:#{port}/resources/1" },
+                { href: "http://localhost:#{port}/resources/1" }
+              ]
+            }
+          }.to_json
+        when "first_name=roo&page=2&per_page=2"
+          res.body = {
+            _links: {
+              self: {
+                href: "http://localhost:#{port}/resourcess?first_name=roo&page=2&per_page=2"
+              },
+              first: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=1&per_page=2"
+              },
+              last: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=3&per_page=2"
+              },
+              next: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=3&per_page=2"
+              },
+              resources: [
+                { href: "http://localhost:#{port}/resources/1" },
+                { href: "http://localhost:#{port}/resources/1" }
+              ]
+            }
+          }.to_json
+        when "first_name=roo&page=3&per_page=2"
+          res.body = {
+            _links: {
+              self: {
+                href: "http://localhost:#{port}/resourcess?first_name=roo&page=3&per_page=2"
+              },
+              first: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=1&per_page=2"
+              },
+              last: {
+                href: "http://localhost:#{port}/resources?first_name=roo&page=3&per_page=2"
+              },
+              resources: [
+                { href: "http://localhost:#{port}/resources/1" }
+              ]
+            }
+          }.to_json
+        end
+      end
     end
-    sleep(0.5) # leave sometime for the previous webrick to teardown
   end
 
-  after do
-    Process.kill('KILL', @pid)
-    Process.wait(@pid)
-  end
+  before { service.start }
+  after { service.stop }
 
-  subject { Routemaster::APIClient.new }
-  let(:host) { 'http://localhost:8000' }
+  before { WebMock.disable_net_connect!(allow_localhost: true) }
+
+  let(:host) { "http://localhost:#{port}" }
 
   describe 'error handling' do
-    it 'raises an ResourceNotFound on 404' do
-      expect { subject.get(host + '/404') }.to raise_error(Routemaster::Errors::ResourceNotFound)
-    end
 
-    it 'raises an InvalidResource on 400' do
-      expect { subject.get(host + '/400') }.to raise_error(Routemaster::Errors::InvalidResource)
+    shared_examples 'exception raiser' do
+      it 'raises an ResourceNotFound on 404' do
+        expect { perform.(host + '/404') }.to raise_error(Routemaster::Errors::ResourceNotFound)
+      end
+
+      it 'raises an InvalidResource on 400' do
+        expect { perform.(host + '/400') }.to raise_error(Routemaster::Errors::InvalidResource)
+      end
+
+      it 'raises an UnauthorizedResourceAccess on 401' do
+        expect { perform.(host + '/401') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccess)
+      end
+
+      it 'raises an UnauthorizedResourceAccess on 403' do
+        expect { perform.(host + '/403') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccess)
+      end
+
+      it 'raises an ConflictResource on 409' do
+        expect { perform.(host + '/409') }.to raise_error(Routemaster::Errors::ConflictResource)
+      end
+
+      it 'raises an IncompatibleVersion on 412' do
+        expect { perform.(host + '/412') }.to raise_error(Routemaster::Errors::IncompatibleVersion)
+      end
+
+      it 'raises an InvalidResource on 413' do
+        expect { perform.(host + '/413') }.to raise_error(Routemaster::Errors::InvalidResource)
+      end
+
+      it 'raises an ResourceThrottling on 429' do
+        expect { perform.(host + '/429') }.to raise_error(Routemaster::Errors::ResourceThrottling)
+      end
+
+      it 'raises an FatalResource on 500' do
+        expect { perform.(host + '/500') }.to raise_error(Routemaster::Errors::FatalResource)
+      end
+    end
+  
+    describe '#get' do
+      let(:perform) { ->(uri) { subject.get(uri) } }
+      include_examples 'exception raiser'
     end
 
-    it 'raises an UnauthorizedResourceAccess on 401' do
-      expect { subject.get(host + '/401') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccess)
+    describe '#fget' do
+      let(:perform) { ->(uri) { subject.fget(uri).value } }
+      include_examples 'exception raiser'
     end
+  end
+
+
+
+  describe 'caching behaviour' do
+    let(:url) { "#{host}/resources/1" }
+    def timestamp ; subject.get(url).body.updated_at ; end
+
+    describe 'GET requests' do
+      context 'when the resource was fetched' do
+        let!(:cached_stamp) { timestamp }
+        let(:fetched_stamp) { timestamp }
+
+        it 'returns the cached response' do
+          expect(fetched_stamp).to eq(cached_stamp)
+        end
 
-    it 'raises an UnauthorizedResourceAccess on 403' do
-      expect { subject.get(host + '/403') }.to raise_error(Routemaster::Errors::UnauthorizedResourceAccess)
+        context 'when the cache gets busted' do
+          before { Routemaster::Cache.new.bust(url) }
+
+          it 'returns a fresh response' do
+            expect(fetched_stamp).to be > cached_stamp
+          end
+        end
+
+        context 'when the cache gets invalidated' do
+          before { Routemaster::Cache.new.invalidate(url) }
+
+          it 'returns a fresh response' do
+            expect(fetched_stamp).to be > cached_stamp
+          end
+        end
+      end
     end
 
-    it 'raises an ConflictResource on 409' do
-      expect { subject.get(host + '/409') }.to raise_error(Routemaster::Errors::ConflictResource)
+    describe 'PATCH request' do
+      context 'when the resource was fetched' do
+        let!(:cached_stamp) { timestamp }
+        let(:fetched_stamp) { timestamp }
+
+        it 'invalidates the cache on update' do
+          subject.patch(url, body: {})
+          expect(fetched_stamp).to be > cached_stamp
+        end
+      end
     end
 
-    it 'raises an IncompatibleVersion on 412' do
-      expect { subject.get(host + '/412') }.to raise_error(Routemaster::Errors::IncompatibleVersion)
+    describe 'DELETE request' do
+      context 'when the resource was fetched' do
+        let!(:cached_stamp) { timestamp }
+        let(:fetched_stamp) { timestamp }
+
+        it 'invalidates the cache on destroy' do
+          subject.delete(url)
+          expect(fetched_stamp).to be > cached_stamp
+        end
+      end
     end
+  end
 
-    it 'raises an InvalidResource on 413' do
-      expect { subject.get(host + '/413') }.to raise_error(Routemaster::Errors::InvalidResource)
+  describe 'interleaved requests' do
+    let(:url) { "#{host}/resources/1" }
+
+    let(:processes) do
+      Array.new(2) do
+        ForkBreak::Process.new do
+          breakpoint_class(Routemaster::Middleware::ResponseCaching, :fetch_from_service)
+          Routemaster::Cache.new.send(cache_method, url)
+          subject.get(url).body
+        end
+      end
     end
 
-    it 'raises an ResourceThrottling on 429' do
-      expect { subject.get(host + '/429') }.to raise_error(Routemaster::Errors::ResourceThrottling)
+    let(:first_timestamp) do
+      processes[0].return_value.updated_at
     end
 
-    it 'raises an FatalResource on 500' do
-      expect { subject.get(host + '/500') }.to raise_error(Routemaster::Errors::FatalResource)
+    let(:second_timestamp) do
+      processes[1].return_value.updated_at
     end
-  end
 
-  describe 'Future GET request' do
-    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
-    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
-    let(:url) { "#{host}/success" }
+    let(:fresh_timestamp) do
+      subject.get(url).body.updated_at
+    end
 
-    context 'when there is a previous cached resource' do
-      let(:cache) { Routemaster::Config.cache_redis }
+    before do
+      processes.first.run_until(:before_fetch_from_service).wait
+      processes.last.finish.wait
+      processes.first.finish.wait
+    end
 
-      it 'returns the response from within the future' do
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be_nil
+    context 'the cache is busted between requests' do
+      let(:cache_method) { :bust }
 
-        future = subject.fget(url)
-        expect(future).to be_an_instance_of(Routemaster::Responses::FutureResponse)
+      it 'should return the first_timestamp' do
+        expect(first_timestamp).to eq fresh_timestamp
+      end
 
-        future.value
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+      it 'returns a second timestamp older than the first' do
+        expect(second_timestamp).to be < first_timestamp
       end
     end
-  end
 
-  describe 'PATCH request' do
-    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
-    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
-    let(:url) { "#{host}/success" }
+    context 'the cache is invalidated between requests' do
+      let(:cache_method) { :invalidate }
 
-    context 'when there is a previous cached resource' do
-      before { subject.get(url) }
-      let(:cache) { Routemaster::Config.cache_redis }
-
-      it 'invalidates the cache on update' do
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
-        subject.patch(url, body: {})
+      it 'returns a second timestamp older than the first' do
+        expect(second_timestamp).to be < first_timestamp
+      end
 
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be_nil
+      it 'returns an invalid first request' do
+        expect(first_timestamp).to be < fresh_timestamp
+      end
 
-        subject.get(url)
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
+      it 'returns an invalid second request' do
+        expect(second_timestamp).to be < fresh_timestamp
       end
     end
   end
 
-  describe 'DELETE request' do
-    let(:body_cache_keys) { ["cache:#{url}", "v:,l:,body"] }
-    let(:headers_cache_keys) { ["cache:#{url}", "v:,l:,headers"] }
-    let(:url) { "#{host}/success" }
+  describe 'INDEX request' do
+    let(:url) { "http://localhost:#{port}/discover" }
 
-    context 'when there is a previous cached resource' do
-      before { subject.get(url) }
-      let(:cache) { Routemaster::Config.cache_redis }
+    subject do
+      Routemaster::APIClient.new(response_class: Routemaster::Responses::HateoasResponse)
+    end
 
-      it 'invalidates the cache on destroy' do
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
-        subject.delete(url)
+    it 'traverses through pagination next all links that match the request params' do
+      res = subject.discover(url)
+      expect(res.resources.index(filters: { first_name: 'roo' }).count).to eq(5)
+    end
 
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be_nil
+    it 'does not make any http requests to fetch resources any if just the index method is called' do
+      resources = subject.discover(url).resources
 
-        subject.get(url)
-        expect(cache.hget("cache:#{url}", "v:,l:,body")).to be
-      end
+      expect(subject).to receive(:get).with("http://localhost:#{port}/resources", anything).once
+      resources.index
     end
   end
 
-  describe 'Telemetry' do
-    let(:metrics_client) { double('MetricsClient') }
+  describe 'telemetry' do
+    let(:metrics_client) { Dogstatsd.new }
     let(:source_peer) { 'test_service' }
     let(:url) { "#{host}/success" }
 
@@ -159,34 +318,39 @@ RSpec.describe 'Api client integration specs' do
                                  source_peer: source_peer)
     end
 
+    before do
+      allow(metrics_client).to receive(:increment).and_call_original
+      allow(metrics_client).to receive(:time).and_call_original
+    end
+
     context 'when metrics source peer is absent' do
-      subject { Routemaster::APIClient.new(metrics_client: metrics_client) }
+      let(:source_peer) { nil }
 
       it 'does not send metrics' do
-        expect(metrics_client).to receive(:increment).never
         subject.get(url)
+        expect(metrics_client).not_to have_received(:increment)
       end
     end
 
-    it 'does send request metrics' do
-      allow(metrics_client).to receive(:time).and_yield
-      allow(metrics_client).to receive(:increment)
-      expected_req_count_tags = ["source:test_service", "destination:localhost", "verb:get"]
-
-      expect(metrics_client).to receive(:increment).with('api_client.request.count', tags: expected_req_count_tags)
-
+    it 'sends request metrics' do
       subject.get(url)
+      expect(metrics_client).to have_received(:increment).with(
+        'api_client.request.count', tags: %w[source:test_service destination:localhost verb:get]
+      )
     end
 
-    it 'does send response metrics' do
-      allow(metrics_client).to receive(:increment)
-      expected_res_count_tags = ["source:test_service", "destination:localhost", "status:200"]
-      expected_latency_tags = ["source:test_service", "destination:localhost", "verb:get"]
-
-      expect(metrics_client).to receive(:increment).with('api_client.response.count', tags: expected_res_count_tags)
-      expect(metrics_client).to receive(:time).with('api_client.latency', tags: expected_latency_tags).and_yield
+    it 'sends response metrics' do
+      subject.get(url)
+      expect(metrics_client).to have_received(:increment).with(
+        'api_client.response.count', tags: %w[source:test_service destination:localhost status:200]
+      )
+    end
 
+    it 'sends timing metrics' do
       subject.get(url)
+      expect(metrics_client).to have_received(:time).with(
+        'api_client.latency', tags: %w[source:test_service destination:localhost verb:get]
+      )
     end
   end
 end