alephant-broker 0.1.6 → 1.0.0

data/lib/alephant/broker/models/request_factory.rb

@@ -1,26 +0,0 @@
-require 'alephant/broker/models/request/error_request.rb'
-require 'alephant/broker/models/request/get_request.rb'
-require 'alephant/broker/models/request/notfound_request.rb'
-require 'alephant/broker/models/request/post_request.rb'
-require 'alephant/broker/models/request/status_request.rb'
-
-module Alephant
-  module Broker
-    class RequestFactory
-      def self.process(type)
-        case type
-        when :component
-          GetRequest.new
-        when :components_batch
-          PostRequest.new
-        when :status
-          StatusRequest.new
-        when :notfound
-          NotFoundRequest.new
-        when :error
-          ErrorRequest.new
-        end
-      end
-    end
-  end
-end

data/lib/alephant/broker/models/request_handler.rb

@@ -1,50 +0,0 @@
-require 'alephant/broker/models/request_factory'
-require 'alephant/broker/models/response_factory'
-
-module Alephant
-  module Broker
-    class RequestHandler
-      include Logger
-
-      def initialize(config)
-        @config = config
-      end
-
-      def process
-        begin
-          response_factory.response_from(request)
-        rescue Exception => e
-          logger.info("Broker.requestHandler.process: Exception raised (#{e.message})")
-          response_factory.response(500)
-        end
-      end
-
-      private
-
-      def request
-        @request ||= RequestFactory.process(request_type)
-      end
-
-      def response_factory
-        @response_factory ||= ResponseFactory.new(@config)
-      end
-
-      def request_type
-        case env.request_type
-        when 'components'
-          :components_batch
-        when 'component'
-          :component
-        when 'status'
-          :status
-        else
-          :notfound
-        end
-      end
-
-      def env
-        @env ||= RequestStore.store[:env]
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Alephant
-  module Broker
-    class Response
-      attr_accessor :content, :content_type
-      attr_reader :status
-
-      STATUS_CODE_MAPPING = {
-        200 => 'ok',
-        404 => 'Not found',
-        500 => 'Error retrieving content'
-      }
-
-      def initialize(status = 200)
-        @content_type = "text/html"
-        self.status = status
-        setup
-      end
-
-      def status=(code)
-        @status = code
-        @content = STATUS_CODE_MAPPING[code]
-      end
-
-      def setup; end
-    end
-  end
-end

data/lib/alephant/broker/models/response/asset_response.rb

@@ -1,90 +0,0 @@
-require 'crimp'
-require 'alephant/cache'
-require 'alephant/lookup'
-require 'alephant/broker/errors/invalid_cache_key'
-require 'alephant/sequencer'
-
-module Alephant
-  module Broker
-    class AssetResponse < Response
-      include Logger
-
-      attr_reader :request
-
-      def initialize(request, config)
-        @request = request
-        @config  = config
-        super()
-      end
-
-      def setup
-        begin
-          self.content_type = request.content_type
-          self.content = cache.get(s3_path)
-        rescue AWS::S3::Errors::NoSuchKey, InvalidCacheKey => e
-          set_error_for(e, 404)
-        rescue Exception => e
-          set_error_for(e, 500)
-        end
-      end
-
-      private
-
-      def cache
-        @cache ||= Alephant::Cache.new(config[:s3_bucket_id], config[:s3_object_path])
-      end
-
-      def set_error_for(exception, status)
-        logger.info("Broker.assetResponse.set_error_for: #{status} exception raised (#{exception.message})")
-        self.status = status
-        self.content = exception.message
-      end
-
-      def s3_path
-        lookup.read(component_id, request.options, version).tap do |lookup_object|
-          raise InvalidCacheKey if lookup_object.location.nil?
-        end.location unless version.nil?
-      end
-
-      def lookup
-        @lookup ||= Alephant::Lookup.create(config[:lookup_table_name])
-      end
-
-      def key
-        request.type == :batch ? renderer_key : component_key
-      end
-
-      def component_key
-        "#{component_id}/#{opts_hash}"
-      end
-
-      def renderer_key
-        "#{renderer_id}/#{opts_hash}"
-      end
-
-      def component_id
-        request.component_id
-      end
-
-      def renderer_id
-        request.renderer_id
-      end
-
-      def opts_hash
-        @opts_hash ||= Crimp.signature(request.options)
-      end
-
-      def version
-        @version ||= sequencer.get_last_seen
-      end
-
-      def sequencer
-        @sequencer ||= Alephant::Sequencer.create(config[:sequencer_table_name], key)
-      end
-
-      def config
-        @config
-      end
-    end
-  end
-end

data/lib/alephant/broker/models/response/batch_response.rb

@@ -1,61 +0,0 @@
-require 'alephant/logger'
-require 'peach'
-
-module Alephant
-  module Broker
-    class BatchResponse
-      include Logger
-      attr_reader :status, :content_type, :content
-
-      def initialize(request, config)
-        @request      = request
-        @config       = config
-        @status       = 200
-        @content_type = request.content_type
-      end
-
-      def process
-        @content = JSON.generate({ "batch_id" => batch_id, "components" => json })
-        self
-      end
-
-      private
-
-      def json
-        get_components.peach do |component|
-          thread_local_request = @request.clone
-
-          id      = component['component']
-          options = set_keys_to_symbols component.fetch('options', {})
-
-          thread_local_request.set_component(id, options)
-
-          asset = AssetResponse.new(thread_local_request, @config)
-          component.store('status', asset.status)
-          component.store('body', asset.content) if valid_status_for asset
-        end
-      end
-
-      def set_keys_to_symbols(hash)
-        Hash[hash.map { |k,v| [k.to_sym, v] }]
-      end
-
-      def batch_id
-        @request.components.fetch(:batch_id)
-      end
-
-      def get_components
-        @request.components.fetch(:components) do |key|
-          logger.info("Broker::BatchResponse.process: Received request object but no valid key was found")
-          []
-        end
-      end
-
-      def valid_status_for(asset)
-        asset.status == 200
-      end
-    end
-  end
-end
-
-

data/lib/alephant/broker/models/response_factory.rb

@@ -1,39 +0,0 @@
-require 'alephant/broker/models/response'
-require 'alephant/broker/models/response/asset_response'
-require 'alephant/broker/models/response/batch_response'
-
-module Alephant
-  module Broker
-    class ResponseFactory
-
-      def initialize(config = nil)
-        @config = config
-      end
-
-      def response_from(request)
-          case request.type
-          when :asset
-            AssetResponse.new(request, config)
-          when :batch
-            BatchResponse.new(request, config).process
-          when :status
-            response(200)
-          when :notfound
-            response(404)
-          when :error
-            response(500)
-          end
-      end
-
-      def response(status)
-        Response.new(status)
-      end
-
-      private
-
-      def config
-        @config
-      end
-    end
-  end
-end

data/spec/asset_response_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe Alephant::Broker::AssetResponse do
-  subject { Alephant::Broker::AssetResponse }
-
-  describe "#initialize(request, config)" do
-    let(:location) { 'test_location' }
-
-    let(:config) {{
-      :lookup_table_name => 'test_table',
-      :bucket_id => 'test_bucket',
-      :path => 'test_path'
-    }}
-
-    let(:request) { double(
-                      "Alephant::Broker::Request",
-                      :component_id => 'test',
-                      :content_type => 'text/html',
-                      :type         => :asset,
-                      :options      => { :variant => 'test_variant' }
-                    )
-                  }
-
-    before do
-      subject
-        .any_instance
-        .stub(:s3_path)
-        .and_return(:foo)
-    end
-
-    context "successful" do
-      before(:each) do
-        subject
-          .any_instance
-          .stub(:cache)
-          .and_return(double(:get => 'Test'))
-      end
-
-      it "Should return the content from a successful cache lookup" do
-        instance = subject.new(request, config)
-
-        expect(instance.content).to eq('Test')
-        expect(instance.status).to eq(200)
-      end
-    end
-
-    context "client failure" do
-      before(:each) do
-        subject
-          .any_instance
-          .stub(:cache)
-          .and_raise(Alephant::Broker::InvalidCacheKey)
-      end
-
-      it "should return a 404 if lookup can't find a valid location" do
-        instance = subject.new(request, config)
-        expect(instance.status).to eq(404)
-      end
-    end
-
-    context "server failure" do
-      before(:each) do
-        subject
-          .any_instance
-          .stub(:cache)
-          .and_raise(Exception)
-      end
-
-      it "should return a 500 for any other exceptions" do
-        instance = subject.new(request, config)
-        expect(instance.status).to eq(500)
-      end
-    end
-  end
-end
-
-
-

data/spec/batch_response_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Alephant::Broker::BatchResponse do
-  subject { Alephant::Broker::BatchResponse }
-
-  let (:config) {{
-    :lookup_table_name => 'test_table',
-    :bucket_id => 'test_bucket',
-    :path => 'test_path'
-  }}
-
-  let (:post_request) {
-    double(
-      'Alephant::Broker::PostRequest',
-      :options       => {},
-      :type          => :batch,
-      :content_type  => 'application/json',
-      :set_component => nil,
-      :component_id  => nil,
-      :renderer_id   => nil,
-      :components    => {
-        :batch_id   => :baz,
-        :components => [
-          { 'component' => 'foo1', 'options' => { 'variant' => 'bar1' } },
-          { 'component' => 'foo2', 'options' => { 'variant' => 'bar2' } }
-        ]}
-    ).as_null_object
-  }
-
-  before do
-    Alephant::Broker::AssetResponse
-      .any_instance
-      .stub(:initialize)
-  end
-
-  describe "#process" do
-    context "if a component is unrecognised" do
-      before(:each) do
-        Alephant::Broker::AssetResponse
-          .any_instance
-          .stub(:status)
-          .and_return(404)
-
-        instance       = subject.new(post_request, config)
-        json           = JSON.parse(instance.process.content)
-        @bad_component = json.fetch('components')[1]
-      end
-
-      it "set status to 404" do
-        expect(@bad_component['status']).to eq(404)
-      end
-
-      it "remove 'body' key" do
-        expect(@bad_component['body']).to eq(nil)
-      end
-    end
-
-    context "if a component is recognised" do
-      before(:each) do
-        Alephant::Broker::AssetResponse
-          .any_instance
-          .stub(:status)
-          .and_return(200)
-
-        Alephant::Broker::AssetResponse
-          .any_instance
-          .stub(:content)
-          .and_return('Test')
-
-        @instance = subject.new(post_request, config)
-        @content  = @instance.process.content
-        @json     = JSON.parse(@content)
-      end
-
-      it "set status to 200" do
-        @json.fetch('components').each do |component|
-          expect(component['status']).to eq(200)
-        end
-      end
-
-      it "set @content to be JSON string containing retrieved components" do
-        compiled_json = '{"batch_id":"baz","components":[{"component":"foo1","options":{"variant":"bar1"},"status":200,"body":"Test"},{"component":"foo2","options":{"variant":"bar2"},"status":200,"body":"Test"}]}'
-        expect(@content).to eq(compiled_json)
-      end
-    end
-  end
-end