coach 0.0.0

data/lib/coach/request_serializer.rb

@@ -0,0 +1,63 @@
+module Coach
+  class RequestSerializer
+    def self.header_rules
+      @header_rules ||= {}
+    end
+
+    # Sets global rules on how to sanitize headers. An optional block can be supplied
+    # that will determine how to transform the original header value, otherwise a default
+    # string is used.
+    def self.sanitize_header(header, &rule)
+      header_rules[header] = rule || ->(value) { '[FILTERED]' }
+    end
+
+    # Applies sanitizing rules. Expects `header` to be in 'http_header_name' form.
+    def self.apply_header_rule(header, value)
+      return value if header_rules[header].nil?
+      header_rules[header].call(value)
+    end
+
+    # Resets all header sanitizing
+    def self.clear_header_rules!
+      @header_rules = {}
+    end
+
+    def initialize(request)
+      @request = request
+    end
+
+    def serialize
+      {
+        # Identification
+        request_id: @request.uuid,
+
+        # Request details
+        method: @request.method,
+        path: request_path,
+        format: @request.format.try(:ref),
+        params: @request.filtered_parameters,  # uses config.filter_parameters
+
+        # Extra request info
+        headers: filtered_headers,
+        session_id: @request.remote_ip
+      }
+    end
+
+    private
+
+    def request_path
+      @request.fullpath
+    rescue
+      "unknown"
+    end
+
+    def filtered_headers
+      header_value_pairs = @request.filtered_env.map do |key, value|
+        next unless key =~ /^HTTP_/
+        [key.downcase, self.class.apply_header_rule(key.downcase, value)]
+      end.compact
+
+      Hash[header_value_pairs]
+    end
+  end
+end

data/lib/coach/router.rb

@@ -0,0 +1,70 @@
+require_relative "handler"
+require_relative "errors"
+
+module Coach
+  class Router
+    ACTION_TRAITS = {
+      index:   { method: :get },
+      show:    { method: :get, url: ':id' },
+      create:  { method: :post },
+      update:  { method: :put, url: ':id' },
+      destroy: { method: :delete, url: ':id' }
+    }.each_value(&:freeze).freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def draw(routes, base: nil, as: nil, constraints: nil, actions: [])
+      action_traits(actions).each do |action, traits|
+        route = routes.const_get(camel(action))
+        match(action_url(base, traits),
+              to: Handler.new(route),
+              via: traits[:method],
+              as: as,
+              constraints: constraints)
+      end
+    end
+
+    def match(url, **args)
+      @app.routes.draw do
+        match url, args
+      end
+    end
+
+    private
+
+    # Receives an array of symbols that represent actions for which the default traits
+    # should be used, and then lastly an optional trait configuration.
+    #
+    # Example is...
+    #
+    #   [ :index, :show, { refund: { url: ':id/refund', method: 'post' } } ]
+    #
+    # ...which will load the default route for `show` and `index`, while also configuring
+    # a refund route.
+    def action_traits(list_of_actions)
+      if list_of_actions.last.is_a?(Hash)
+        *list_of_actions, traits = list_of_actions
+      end
+
+      list_of_actions.reduce(traits || {}) do |memo, action|
+        trait = ACTION_TRAITS.fetch(action) do
+          raise Errors::RouterUnknownDefaultAction, action
+        end
+
+        memo.merge(action => trait)
+      end
+    end
+
+    # Applies trait url to base, removing duplicate /'s
+    def action_url(base, traits)
+      [base, traits[:url]].compact.join('/').gsub(%r{/+}, '/')
+    end
+
+    # Turns a snake_case string/symbol into a CamelCase
+    def camel(snake_case)
+      snake_case.to_s.capitalize.gsub(/_./) { |match| match[1].upcase }
+    end
+  end
+end

data/lib/coach/version.rb

@@ -0,0 +1,3 @@
+module Coach
+  VERSION = '0.0.0'
+end

data/lib/spec/coach_helper.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+require "coach/middleware"
+
+# Middleware stubbing ######################################
+
+def build_middleware(name)
+  Class.new(Coach::Middleware) do
+    # To access `name`, we need to use `define_method` instead of `def`
+    define_method(:to_s) { "<Middleware#{name}>" }
+    define_method(:name) { name }
+    define_singleton_method(:name) { name }
+
+    def call
+      config[:callback].call if config.include?(:callback)
+
+      # Build up a list of middleware called, in the order they were called
+      if next_middleware
+        [name].concat(next_middleware.call)
+      else
+        [name]
+      end
+    end
+  end
+end
+
+def null_middleware
+  double(call: nil)
+end
+
+# Response matchers ########################################
+
+RSpec::Matchers.define :respond_with_status do |expected_status|
+  match do |middleware|
+    @middleware = middleware
+    @response = middleware.call
+    @response[0] == expected_status
+  end
+
+  failure_message do |actual|
+    "expected #{@middleware.class.name} to respond with #{expected_status} but got " \
+    "#{@response[0]}"
+  end
+end
+
+RSpec::Matchers.define :respond_with_body_that_matches do |body_regex|
+  match do |middleware|
+    @response_body = middleware.call.third.join
+    @response_body.match(body_regex)
+  end
+
+  failure_message do |actual|
+    "expected that \"#{@response_body}\" would match #{body_regex}"
+  end
+end
+
+RSpec::Matchers.define :respond_with_envelope do |envelope, keys = []|
+  match do |middleware|
+    @response = JSON.parse(middleware.call.third.join)
+    expect(@response).to include(envelope.to_s)
+
+    @envelope = @response[envelope.to_s].with_indifferent_access
+    expect(@envelope).to match(hash_including(*keys))
+  end
+
+  failure_message do |actual|
+    "expected that \"#{@response}\" would have envelope \"#{envelope}\" that matches " \
+    "hash_including(#{keys})"
+  end
+end
+
+RSpec::Matchers.define :respond_with_header do |header, value_regex|
+  match do |middleware|
+    response_headers = middleware.call.second
+    @header_value = response_headers[header]
+    @header_value.match(value_regex)
+  end
+
+  failure_message do |actual|
+    "expected #{header} header in response to match #{value_regex} but found " \
+    "\"#{@header_value}\""
+  end
+end
+
+# Chain matchers ###########################################
+
+RSpec::Matchers.define :call_next_middleware do
+  match do |middleware|
+    @middleware = middleware
+    allow(middleware.next_middleware).to receive(:call)
+    middleware.call
+    begin
+      expect(middleware.next_middleware).to have_received(:call)
+      true
+    rescue RSpec::Expectations::ExpectationNotMetError
+      false
+    end
+  end
+
+  failure_message do
+    "expected that \"#{@middleware.class.name}\" would call next middleware"
+  end
+end
+
+# Provide/Require matchers #################################
+
+RSpec::Matchers.define :provide do |key|
+  match do |middleware|
+    allow(middleware).to receive(:provide)
+    expect(middleware).to receive(:provide).with(hash_including(key)).and_call_original
+    middleware.call
+    true
+  end
+end

data/spec/lib/coach/handler_spec.rb

@@ -0,0 +1,138 @@
+require "spec_helper"
+
+require "coach/handler"
+require "coach/middleware"
+require "coach/errors"
+
+describe Coach::Handler do
+  let(:middleware_a) { build_middleware("A") }
+  let(:middleware_b) { build_middleware("B") }
+  let(:middleware_c) { build_middleware("C") }
+
+  let(:terminal_middleware) { build_middleware("Terminal") }
+  let(:handler) { Coach::Handler.new(terminal_middleware) }
+
+  before { Coach::Notifications.unsubscribe! }
+
+  describe "#call" do
+    let(:a_spy) { spy('middleware a') }
+    let(:b_spy) { spy('middleware b') }
+
+    before { terminal_middleware.uses(middleware_a, callback: a_spy) }
+    before { terminal_middleware.uses(middleware_b, callback: b_spy) }
+
+    it "invokes all middleware in the chain" do
+      result = handler.call({})
+      expect(a_spy).to have_received(:call)
+      expect(b_spy).to have_received(:call)
+      expect(result).to eq(%w(A B Terminal))
+    end
+  end
+
+  describe "#build_sequence" do
+    subject(:sequence) do
+      root_item = Coach::MiddlewareItem.new(terminal_middleware)
+      handler.build_sequence(root_item, {}).map(&:middleware)
+    end
+
+    context "given a route that includes simple middleware" do
+      before { terminal_middleware.uses(middleware_a) }
+
+      it "assembles a sequence including all middleware" do
+        expect(sequence).to match_array([middleware_a, terminal_middleware])
+      end
+    end
+
+    context "given a route that includes nested middleware" do
+      before { middleware_b.uses(middleware_c) }
+      before { middleware_a.uses(middleware_b) }
+      before { terminal_middleware.uses(middleware_a) }
+
+      it "assembles a sequence including all middleware" do
+        expect(sequence).to match_array([middleware_c, middleware_b,
+                                         middleware_a, terminal_middleware])
+      end
+    end
+
+    context "when a middleware has been included more than once" do
+      before { middleware_a.uses(middleware_c) }
+      before { middleware_b.uses(middleware_c) }
+      before { terminal_middleware.uses(middleware_a) }
+      before { terminal_middleware.uses(middleware_b) }
+
+      it "only appears once" do
+        expect(sequence).to match_array([middleware_c, middleware_a,
+                                         middleware_b, terminal_middleware])
+      end
+
+      context "with a different config" do
+        before { middleware_b.uses(middleware_c, foo: "bar") }
+
+        it "appears more than once" do
+          expect(sequence).to match_array([middleware_c, middleware_a,
+                                           middleware_c, middleware_b,
+                                           terminal_middleware])
+        end
+      end
+    end
+  end
+
+  describe "#build_request_chain" do
+    before { terminal_middleware.uses(middleware_a) }
+    before { terminal_middleware.uses(middleware_b, if: ->(ctx) { false }) }
+    before { terminal_middleware.uses(middleware_c) }
+
+    let(:root_item) { Coach::MiddlewareItem.new(terminal_middleware) }
+    let(:sequence) { handler.build_sequence(root_item, {}) }
+
+    it "instantiates all matching middleware items in the sequence" do
+      expect(middleware_a).to receive(:new)
+      expect(middleware_c).to receive(:new)
+      expect(terminal_middleware).to receive(:new)
+      handler.build_request_chain(sequence, {})
+    end
+
+    it "doesn't instantiate non-matching middleware items" do
+      expect(middleware_b).not_to receive(:new)
+      handler.build_request_chain(sequence, {})
+    end
+
+    it "sets up the chain correctly, calling each item in the correct order" do
+      expect(handler.build_request_chain(sequence, {}).call).
+        to eq(%w(A C Terminal))
+    end
+  end
+
+  describe "#call" do
+    before { terminal_middleware.uses(middleware_a) }
+
+    describe 'notifications' do
+      before { Coach::Notifications.subscribe! }
+
+      # Prevent RequestSerializer from erroring due to insufficient request mock
+      before do
+        allow(Coach::RequestSerializer).
+          to receive(:new).
+          and_return(double(serialize: {}))
+      end
+
+      subject(:coach_events) do
+        events = []
+        subscription =
+          ActiveSupport::Notifications.subscribe(/coach/) do |name, *args|
+            events << name
+          end
+
+        handler.call({})
+        ActiveSupport::Notifications.unsubscribe(subscription)
+        events
+      end
+
+      it { is_expected.to include('coach.handler.start') }
+      it { is_expected.to include('coach.middleware.start') }
+      it { is_expected.to include('coach.request') }
+      it { is_expected.to include('coach.middleware.finish') }
+      it { is_expected.to include('coach.handler.finish') }
+    end
+  end
+end

data/spec/lib/coach/middleware_spec.rb

@@ -0,0 +1,43 @@
+require "coach/middleware"
+
+describe Coach::Middleware do
+  let(:middleware_class) { Class.new(Coach::Middleware) }
+  let(:context_) { {} }
+  let(:middleware_obj) { middleware_class.new(context_, nil) }
+
+  describe ".provides?" do
+    context "given names it does provide" do
+      before { middleware_class.provides(:foo, :bar) }
+
+      it "returns true" do
+        expect(middleware_class.provides?(:foo)).to be_truthy
+        expect(middleware_class.provides?(:bar)).to be_truthy
+      end
+    end
+
+    context "given names it doesn't provide" do
+      before { middleware_class.provides(:foo) }
+
+      it "returns false" do
+        expect(middleware_class.provides?(:baz)).to be_falsy
+      end
+    end
+  end
+
+  describe "#provide" do
+    before { middleware_class.provides(:foo) }
+
+    context "given a name it can provide" do
+      it "adds it to the context" do
+        expect { middleware_obj.provide(foo: "bar") }.
+          to change { context_ }.from({}).to(foo: "bar")
+      end
+    end
+
+    context "given a name it can't provide" do
+      it "blows up" do
+        expect { middleware_obj.provide(baz: "bar") }.to raise_error(NameError)
+      end
+    end
+  end
+end

data/spec/lib/coach/middleware_validator_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "coach/middleware_validator"
+
+describe Coach::MiddlewareValidator do
+  subject(:validator) { described_class.new(head_middleware, already_provided) }
+
+  let(:head_middleware) { build_middleware('Head') }
+  let(:already_provided) { [] }
+
+  let(:middleware_a) { build_middleware('A') }
+  let(:middleware_b) { build_middleware('B') }
+  let(:middleware_c) { build_middleware('C') }
+
+  # head <── a
+  #       └─ b <- c
+  before do
+    head_middleware.uses middleware_a
+    head_middleware.uses middleware_b
+    middleware_b.uses middleware_c
+  end
+
+  describe "#validated_provides!" do
+    subject { -> { validator.validated_provides! } }
+
+    context "with satisfied requires" do
+      context "one level deep" do
+        before do
+          head_middleware.requires :a
+          middleware_a.provides :a
+        end
+
+        it { is_expected.to_not raise_error }
+      end
+
+      context "that are inherited up" do
+        before do
+          head_middleware.requires :c
+          middleware_c.provides :c
+        end
+        it { is_expected.to_not raise_error }
+      end
+
+      # Middlewares should be able to use the keys provided by the items `used` before
+      # them. In this scenario, terminal will use a then b, and if b requires :a as a key
+      # then our dependencies should be satisfied.
+      context "that are inherited laterally" do
+        before do
+          middleware_a.provides :a
+          middleware_b.requires :a
+        end
+        it { is_expected.to_not raise_error }
+      end
+    end
+
+    context "with missing requirements" do
+      context "at terminal" do
+        before { head_middleware.requires :a, :c }
+
+        it { is_expected.to raise_exception(/requires keys \[a,c\]/) }
+      end
+
+      context "from unordered middleware" do
+        before do
+          middleware_a.requires :b
+          middleware_b.provides :b
+        end
+
+        it { is_expected.to raise_exception(/requires keys \[b\]/) }
+      end
+    end
+  end
+end