alephant-broker 1.2.1 → 1.3.1

data/lib/alephant/broker/request/batch.rb

@@ -1,18 +1,18 @@
 require 'alephant/logger'
 require 'alephant/broker/component'
 
-
 module Alephant
   module Broker
     module Request
       class Batch
         include Logger
 
-        attr_reader :batch_id, :components
+        attr_reader :batch_id, :components, :load_strategy
 
-        def initialize(env)
+        def initialize(component_factory, env)
           logger.debug("Request::Batch#initialize(#{env.settings})")
 
+          @component_factory = component_factory
           @batch_id   = env.data['batch_id']
           @components = components_for env
 
@@ -23,14 +23,13 @@ module Alephant
 
         def components_for(env)
           env.data['components'].map do |c|
-            Component.new(
+            @component_factory.create(
               c['component'],
               batch_id,
               c['options']
             )
           end
         end
-
       end
     end
   end

data/lib/alephant/broker/request/factory.rb

@@ -1,26 +1,31 @@
 require 'alephant/broker/request'
+require 'alephant/broker/component_factory'
 
-module Alephant::Broker::Request
-  class Factory
+module Alephant
+  module Broker
+    module Request
+      class Factory
+        def self.request_type_from(env)
+          env.path.split('/')[1]
+        end
 
-    def self.request_type_from(env)
-      env.path.split('/')[1]
-    end
+        def self.request_for(load_strategy, env)
+          component_factory = ComponentFactory.new load_strategy
 
-    def self.request_for(env)
-      case request_type_from(env)
-      when 'multi'
-        Multi.new(env)
-      when 'component'
-        Asset.new(env)
-      when 'components'
-        Batch.new(env)
-      when 'status'
-        Status.new
-      else
-        NotFound.new
+          case request_type_from(env)
+          when 'multi'
+            Multi.new(env)
+          when 'component'
+            Asset.new(component_factory, env)
+          when 'components'
+            Batch.new(component_factory, env)
+          when 'status'
+            Status.new
+          else
+            NotFound.new
+          end
+        end
       end
     end
   end
 end
-

data/lib/alephant/broker/request/handler.rb

@@ -4,6 +4,7 @@ require 'alephant/broker/request'
 require 'alephant/broker/response'
 require 'alephant/broker/request/factory'
 require 'alephant/broker/response/factory'
+require 'alephant/broker/errors/content_not_found'
 
 module Alephant
   module Broker
@@ -11,23 +12,17 @@ module Alephant
       class Handler
         extend Logger
 
-        def self.request_for(env)
-          Request::Factory.request_for env
+        def self.request_for(load_strategy, env)
+          Request::Factory.request_for(load_strategy, env)
         end
 
         def self.response_for(request)
           Response::Factory.response_for request
         end
 
-        def self.process(env)
-          begin
-            response_for request_for(env)
-          rescue Exception => e
-            logger.warn("Broker.requestHandler.process: Exception raised (#{e.message}, #{e.backtrace.join('\n')})")
-            Response::Factory.error
-          end
+        def self.process(load_strategy, env)
+          response_for request_for(load_strategy, env)
         end
-
       end
     end
   end

data/lib/alephant/broker/response/asset.rb

@@ -1,4 +1,3 @@
-require 'alephant/broker/errors/invalid_cache_key'
 require 'alephant/logger'
 
 module Alephant
@@ -7,23 +6,31 @@ module Alephant
       class Asset < Base
         include Logger
 
-        attr_reader :component
-
         def initialize(component)
           @component = component
-          super()
+          super component.status
         end
 
         def setup
-          loaded_content = load(component)
+          @headers  = @component.headers
+          @content  = @component.content
+          log if @component.is_a? Component
+        end
+
+        private
 
-          @content      = loaded_content[:body]
-          @content_type = loaded_content[:content_type]
-          @status       = loaded_content[:status]
-          @sequence     = component.version.nil? ? 'not available' : component.version
-          @cached       = component.cached
+        def batched
+          @component.batch_id.nil? ? '' : 'batched'
         end
 
+        def details
+          c = @component
+          "#{c.id}/#{c.opts_hash}/#{c.headers} #{batched} #{c.options}"
+        end
+
+        def log
+          logger.info "Broker: Component loaded! #{details} (200)"
+        end
       end
     end
   end

data/lib/alephant/broker/response/base.rb

@@ -1,3 +1,4 @@
+require 'alephant/broker/errors/invalid_cache_key'
 require 'aws-sdk'
 require 'ostruct'
 
@@ -5,8 +6,7 @@ module Alephant
   module Broker
     module Response
       class Base
-        attr_reader :headers
-        attr_accessor :status, :content, :content_type, :version, :sequence, :cached
+        attr_reader :content, :headers, :status
 
         STATUS_CODE_MAPPING = {
           200 => 'ok',
@@ -15,64 +15,16 @@ module Alephant
         }
 
         def initialize(status = 200, content_type = "text/html")
-          @headers      = {}
-          @sequence     = 'not available'
-          @version      = Broker.config.fetch('elasticache_cache_version', 'not available').to_s
-          @cached       = false
-          @content_type = content_type
-          @status       = status
-          @content      = STATUS_CODE_MAPPING[status]
+          @content = STATUS_CODE_MAPPING[status]
+          @headers = { "Content-Type" => content_type }
+          @status  = status
 
           setup
         end
 
-        def to_h
-          {
-            :status       => @status,
-            :content      => @content,
-            :content_type => @content_type,
-            :version      => @version,
-            :sequence     => @sequence,
-            :cached       => @cached
-          }
-        end
-
         protected
 
         def setup; end
-
-        def load(component)
-          begin
-
-            data = OpenStruct.new(:status => 200, :content_type => content_type)
-            component.load
-
-            data.content_type = component.content_type
-            data.body         = component.content.force_encoding('UTF-8')
-          rescue AWS::S3::Errors::NoSuchKey, InvalidCacheKey => e
-            data.body   = "Not found"
-            data.status = 404
-          rescue StandardError => e
-            data.body   = "#{error_for(e)}"
-            data.status = 500
-          end
-
-          log(component, data.status, e)
-          data.marshal_dump
-        end
-
-        def log(c, status, e = nil)
-          logger.info("Broker: Component loaded: #{details_for(c)} (#{status}) #{error_for(e)}")
-        end
-
-        def details_for(c)
-          "#{c.id}/#{c.opts_hash}/#{c.version} #{c.batch_id.nil? ? '' : "batched"} (#{c.options})"
-        end
-
-        def error_for(e)
-          e.nil? ? nil : "#{e.message}\n#{e.backtrace.join('\n')}"
-        end
-
       end
     end
   end

data/lib/alephant/broker/response/batch.rb

@@ -1,5 +1,5 @@
 require 'alephant/logger'
-require 'peach'
+require 'pmap'
 
 module Alephant
   module Broker
@@ -18,22 +18,25 @@ module Alephant
 
         def setup
           @content = JSON.generate({
-            "batch_id" => batch_id,
-            "components" => json
+            'batch_id' => batch_id,
+            'components' => json
           })
         end
 
         private
 
         def json
-          logger.info("Broker: Batch load started (#{batch_id})")
-          result = components.pmap do | component |
+          logger.info "Broker: Batch load started (#{batch_id})"
+          result = components.pmap do |component|
             {
-              'component' => component.id,
-              'options'   => component.options
-            }.merge load(component)
+              'component'    => component.id,
+              'options'      => component.options,
+              'status'       => component.status,
+              'content_type' => component.content_type,
+              'body'         => component.content
+            }
           end
-          logger.info("Broker: Batch load done (#{batch_id})")
+          logger.info "Broker: Batch load done (#{batch_id})"
 
           result
         end

data/lib/alephant/broker/response/factory.rb

@@ -22,6 +22,10 @@ module Alephant
         def self.error
           ServerError.new
         end
+
+        def self.not_found
+          NotFound.new
+        end
       end
     end
   end

data/lib/alephant/broker/version.rb

@@ -1,5 +1,5 @@
 module Alephant
   module Broker
-    VERSION = "1.2.1"
+    VERSION = "1.3.1"
   end
 end

data/spec/fixtures/json/batch.json

@@ -0,0 +1 @@
+{"batch_id":"baz","components":[{"component":"ni_council_results_table"},{"component":"ni_council_results_table"}]}

data/spec/fixtures/json/batch_compiled.json

@@ -0,0 +1 @@
+{"batch_id":"baz","components":[{"component":"ni_council_results_table","options":{},"status":200,"content_type":"foo/bar","body":"Test"},{"component":"ni_council_results_table","options":{},"status":200,"content_type":"foo/bar","body":"Test"}]}

data/spec/integration/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/rack_spec.rb

@@ -1,23 +1,37 @@
-ENV['RACK_ENV'] = 'test'
-
 require 'spec_helper'
-require 'rack/test'
-require 'alephant/broker'
-
-RSpec.configure do |conf|
-  conf.include Rack::Test::Methods
-end
 
-describe 'Broker Rack Application' do
-  before do
-    cache_hash = {
+describe Alephant::Broker::Application do
+  include Rack::Test::Methods
+
+  let(:app) do
+    described_class.new(
+      Alephant::Broker::LoadStrategy::S3.new,
+      {
+        :lookup_table_name => 'test_table',
+        :bucket_id         => 'test_bucket',
+        :path              => 'bucket_path'
+      }
+    )
+  end
+  let(:cache_hash) do
+    {
       :content_type => 'test/content',
       :content      => 'Test'
     }
+  end
+  let(:sequencer_double) do
+    instance_double(
+      'Alephant::Sequencer::Sequencer',
+      :get_last_seen => '111'
+    )
+  end
+
+  before do
+    allow_any_instance_of(Logger).to receive(:info)
+    allow_any_instance_of(Logger).to receive(:debug)
 
     allow_any_instance_of(Alephant::Broker::Cache::Client)
-      .to receive(:get)
-      .and_return(cache_hash)
+      .to receive(:get).and_return(cache_hash)
 
     allow_any_instance_of(Alephant::Broker::Component)
       .to receive_messages(
@@ -27,97 +41,84 @@ describe 'Broker Rack Application' do
       )
 
     allow_any_instance_of(Alephant::Broker::Response::Asset)
-      .to receive(:status)
-      .and_return(200)
-  end
-
-  def app
-    Alephant::Broker::Application.new({
-      :lookup_table_name  => 'test_table',
-      :bucket_id          => 'test_bucket',
-      :path               => 'bucket_path'
-    })
-  end
-
-  it 'Tests status page' do
-    get '/status'
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq('ok')
-  end
-
-  it "Tests not found page" do
-    get '/some/non-existent-page'
-    expect(last_response.status).to eq(404)
-    expect(last_response.body).to eq('Not found')
-  end
-
-  it "Test asset data is returned" do
-    get '/component/test_component'
-
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq('Test')
-  end
+      .to receive(:status).and_return(200)
 
-  it "Tests query string parameters are passed correctly to lookup" do
-    get '/component/test_component?variant=test_variant'
-
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq('Test')
+    allow(Alephant::Sequencer).to receive(:create) { sequencer_double }
   end
 
-  it "Tests 404 when lookup doesn't return a valid location" do
-    allow_any_instance_of(Alephant::Broker::Response::Asset)
-      .to receive(:status)
-      .and_return(404)
-
-    get '/component/test_component'
-
-    expect(last_response.status).to eq(404)
+  describe 'Status endpoint `/status`' do
+    before { get '/status' }
+    specify { expect(last_response.status).to eql 200 }
+    specify { expect(last_response.body).to eql 'ok' }
   end
 
-  it "Tests 500 when exception is raised in application" do
-    allow_any_instance_of(Alephant::Broker::Response::Asset)
-      .to receive(:status)
-      .and_return(500)
-
-    get '/component/test_component'
-
-    expect(last_response.status).to eq(500)
+  describe '404 endpoint `/banana`' do 
+    before { get '/banana' }
+    specify { expect(last_response.status).to eql 404 }
+    specify { expect(last_response.body).to eq 'Not found' }
   end
 
-  it "Test batch asset data is returned" do
-    json          = '{"batch_id":"baz","components":[{"component":"ni_council_results_table"},{"component":"ni_council_results_table"}]}'
-    compiled_json = '{"batch_id":"baz","components":[{"component":"ni_council_results_table","options":{},"status":200,"content_type":"foo/bar","body":"Test"},{"component":"ni_council_results_table","options":{},"status":200,"content_type":"foo/bar","body":"Test"}]}'
-
-    post '/components/batch', json, "CONTENT_TYPE" => "application/json"
-
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq(compiled_json)
+  describe 'Component endpoint `/component/...`' do
+    let(:batch_json) do
+      IO.read("#{File.dirname(__FILE__)}/fixtures/json/batch.json").strip
+    end
+    let(:batch_compiled_json) do
+      IO.read("#{File.dirname(__FILE__)}/fixtures/json/batch_compiled.json").strip
+    end
+
+    context 'for a valid component ID' do
+      before { get '/component/test_component' }
+      specify { expect(last_response.status).to eql 200 }
+      specify { expect(last_response.body).to eql 'Test' }
+    end
+
+    context 'for valid URL parameters in request' do
+      before { get '/component/test_component?variant=test_variant' }
+      specify { expect(last_response.status).to eq 200 }
+      specify { expect(last_response.body).to eq 'Test' }
+    end
+   
+    context 'when using valid batch asset data' do
+      before { post '/components/batch', batch_json, 'CONTENT_TYPE' => 'application/json' }
+      specify { expect(last_response.status).to eql 200 }
+      specify { expect(JSON.parse last_response.body).to eq JSON.parse(batch_compiled_json) }
+    end
   end
 
-  it "Should handle old cache data gracefully" do
-    lookup_location_double = double('Alephant::Lookup::Location', :location => 'test/location')
-    lookup_helper_double   = double('Alephant::Lookup::LookupHelper', :read => lookup_location_double)
-
-    cache_double           = double('Alephant::Broker::Cache::Client', :set => { :content_type => 'test/html', :content => '<p>Some data</p>' }, :get => '<p>Some data</p>')
-    s3_cache_double        = double('Alephant::Cache', :get => 'test_content')
-
-    allow(Alephant::Lookup)
-      .to receive(:create)
-      .and_return(lookup_helper_double)
-
-    allow(Alephant::Broker::Cache::Client)
-      .to receive(:new)
-      .and_return(cache_double)
-
-    allow(Alephant::Cache)
-      .to receive(:new)
-      .and_return(s3_cache_double)
-
-    expect(cache_double).to receive(:set).once
-
-    get '/component/test_component'
-
+  describe 'Cached data' do
+    let(:cache_double) do
+      instance_double(
+        'Alephant::Broker::Cache::Client',
+        :set => { 
+          :content_type => 'test/html',
+          :content => '<p>Some data</p>' 
+        }, 
+        :get => '<p>Some data</p>'
+      )
+    end
+    let(:lookup_location_double) do
+      instance_double('Alephant::Lookup::Location', location: 'test/location')
+    end
+    let(:lookup_helper_double) do
+      instance_double('Alephant::Lookup::LookupHelper', read: lookup_location_double)
+    end
+    let(:s3_cache_double) do
+      instance_double(
+        'Alephant::Cache',
+        :get => 'test_content'
+      )
+    end
+
+    context 'which is old' do
+      before do
+        allow(Alephant::Lookup).to receive(:create) { lookup_helper_double }
+        allow(Alephant::Broker::Cache::Client).to receive(:new) { cache_double }
+        allow(Alephant::Cache).to receive(:new) { s3_cache_double }
+      end
+      it 'should update the cache (call `.set`)' do
+        expect(cache_double).to receive(:set).once
+      end 
+      after { get '/component/test_component' }
+    end
   end
-
 end