shokkenki-consumer 0.0.2

data/lib/shokkenki/consumer/stubber/interaction.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'shokkenki/term/term_factory'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class Interaction
+
+        attr_reader :label, :request, :response, :time, :matched_requests
+
+        def self.from_json json
+          attributes = json.with_indifferent_access
+
+          new(
+            :label => attributes[:label],
+            :request => Shokkenki::Term::TermFactory.from_json(attributes[:request]),
+            :response => Shokkenki::Term::TermFactory.from_json(attributes[:response]),
+            :time => attributes[:time]
+          )
+        end
+
+        def initialize attributes
+          @label = attributes[:label]
+          @request = attributes[:request]
+          @response = attributes[:response]
+          @time = attributes[:time]
+          @matched_requests = []
+        end
+
+        def to_hash
+          {
+            :label => @label
+          }
+        end
+
+        def generate_response
+          @response.example
+        end
+
+        def match_request? request
+          @request.match? request
+        end
+
+        def add_match request
+          @matched_requests << request
+          request.interaction = self
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/interactions.rb

@@ -0,0 +1,41 @@
+module Shokkenki
+  module Consumer
+    module Stubber
+      class Interactions
+
+        attr_reader :interactions, :requests
+
+        def initialize
+          @interactions = []
+          @requests = []
+        end
+
+        def find request
+          matching_interaction = @interactions.find do |interaction|
+            interaction.match_request? request
+          end
+          matching_interaction.add_match(request) if matching_interaction
+          @requests << request
+          matching_interaction
+        end
+
+        def delete_all
+          @interactions.clear
+          @requests.clear
+        end
+
+        def add interaction
+          @interactions << interaction
+        end
+
+        def unmatched_requests
+          @requests.select{ |r| r.interaction.nil? }
+        end
+
+        def unused_interactions
+          @interactions.select { |i| i.matched_requests.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/interactions_middleware.rb

@@ -0,0 +1,34 @@
+require_relative 'interaction'
+require_relative 'restful_middleware'
+require 'json'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class InteractionsMiddleware < RestfulMiddleware
+
+        def initialize interactions
+          @interactions = interactions
+        end
+
+        get { |env| [200, {}, ["[]"]] }
+
+        post do |env|
+          @interactions.add Interaction.from_json(body_json(env['rack.input']))
+          [204, {}, []]
+        end
+
+        delete do |env|
+          @interactions.delete_all
+          [204, {}, []]
+        end
+
+        private
+
+        def body_json body_io
+          JSON.parse body_io.read
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/rack_response.rb

@@ -0,0 +1,28 @@
+require 'active_support/core_ext/string/inflections'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class RackResponse
+
+        def self.from_interaction interaction
+          defaults = { :status => 200 }
+          response = defaults.merge interaction.generate_response
+          [response[:status], as_rack_headers(response[:headers]), [response[:body]]]
+        end
+
+        def self.as_rack_headers headers
+          (headers || []).inject({}) do |h, key_value|
+            k, v = key_value
+            h[as_header_name(k)] = v.to_s
+            h
+          end
+        end
+
+        def self.as_header_name name
+          name.to_s.split('-').map{ |word| word.titleize }.join('-')
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/request.rb

@@ -0,0 +1,72 @@
+require 'uri'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class Request
+
+        attr_reader :path, :method, :body, :query, :headers
+        attr_accessor :interaction
+
+        def self.from_rack rack_env
+          env = rack_env.dup
+          new(
+            :path => env['PATH_INFO'],
+            :method => env['REQUEST_METHOD'].downcase,
+            :body => env['rack.input'].read,
+            :query => query_from(env['QUERY_STRING']),
+            :headers => headers_from(env)
+          )
+        end
+
+        def initialize attributes
+          @path = attributes[:path]
+          @method = attributes[:method]
+          @body = attributes[:body]
+          @query = attributes[:query]
+          @headers = attributes[:headers]
+        end
+
+        def to_hash
+          hash = {
+            :path => @path,
+            :method => @method,
+            :headers => @headers,
+            :query => @query,
+            :body => @body
+          }
+          hash.merge!(:interaction => @interaction.to_hash) if @interaction
+          hash
+        end
+
+        def self.headers_from env
+          env.reject{ |k, v|
+            [
+              'PATH_INFO',
+              'REQUEST_METHOD',
+              'QUERY_STRING'
+            ].include?(k)
+          }.
+          reject { |k, v| k.start_with?('rack.') }.
+          reject { |k, v| k.start_with?('async.') }.
+          inject({}) do |headers, key_value|
+            headers[as_header_name(key_value[0])] = key_value[1]
+            headers
+          end
+        end
+
+        def self.query_from query_string
+          query_string.split('&').inject({}) do |query, param|
+            k, v = param.split '='
+            query[k.to_sym] = URI.decode v
+            query
+          end
+        end
+
+        def self.as_header_name name
+          name.to_s.gsub(/^HTTP_/, '').gsub('_', '-').downcase.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/restful_middleware.rb

@@ -0,0 +1,33 @@
+module Shokkenki
+  module Consumer
+    module Stubber
+      class RestfulMiddleware
+
+        def self.post &block
+          handlers[:post] = block
+        end
+
+        def self.delete &block
+          handlers[:delete] = block
+        end
+
+        def self.get &block
+          handlers[:get] = block
+        end
+
+        def self.handlers
+          @handlers ||= {}
+        end
+
+        def call env
+          handler = self.class.handlers[env['REQUEST_METHOD'].downcase.to_sym]
+          handler ? instance_exec(env, &handler) : [405, {'Allow' => allowed_methods.join(', ')}, []]
+        end
+
+        def allowed_methods
+          self.class.handlers.keys.map {|k| k.to_s.upcase }
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/server.rb

@@ -0,0 +1,69 @@
+require 'uri'
+require 'net/http'
+require 'rack'
+require 'rack/handler/webrick'
+require_relative 'server_application_error'
+
+# pinched from https://github.com/jnicklas/capybara/blob/master/lib/capybara/server.rb
+module Shokkenki
+  module Consumer
+    module Stubber
+      class Server
+
+        attr_reader :app, :port, :host, :server_thread, :error
+
+        def initialize attributes
+          @app = attributes[:app]
+          @server_thread = nil # suppress warnings
+          @host = attributes[:host]
+          @port = attributes[:port]
+        end
+
+        def error
+          @app.error
+        end
+
+        def assert_ok!
+          raise ServerApplicationError.new(error) if error
+        end
+
+        def responsive?
+          return false if server_thread && server_thread.join(0)
+          res = Net::HTTP.start(host, @port) do |http|
+            http.get @app.identify_path
+          end
+          assert_ok!
+          ok?(res) && is_app?(res)
+        rescue SystemCallError
+          return false
+        end
+
+        def is_app? response
+          response.body.to_s == @app.object_id.to_s
+        end
+
+        def ok? response
+          response.is_a?(Net::HTTPSuccess) or response.is_a?(Net::HTTPRedirection)
+        end
+
+        def run app, host, port
+          Rack::Handler::WEBrick.run(app, :Host => host, :Port => port, :AccessLog => [], :Logger => WEBrick::Log::new(nil, 0))
+        end
+
+        def start
+          @server_thread = Thread.new do
+            run @app, @host, @port
+          end
+
+          Timeout.timeout(10) { @server_thread.join(0.1) until responsive? }
+        rescue Timeout::Error
+          raise "Rack application #{@app} timed out during boot"
+        end
+
+        def shutdown
+          server_thread.kill
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/server_application_error.rb

@@ -0,0 +1,16 @@
+module Shokkenki
+  module Consumer
+    module Stubber
+      class ServerApplicationError < StandardError
+        def initialize error
+          super "An error occurred in the stub server: #{error.message}"
+          @error = error
+        end
+
+        def set_backtrace backtrace
+          super (@error.backtrace || []) + backtrace
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/stub_server_middleware.rb

@@ -0,0 +1,46 @@
+require_relative 'interactions'
+require_relative 'interactions_middleware'
+require_relative 'stubbed_response_middleware'
+require_relative 'unmatched_requests_middleware'
+require_relative 'unused_interactions_middleware'
+
+# adapted from middleware in https://github.com/jnicklas/capybara/blob/master/lib/capybara/server.rb
+module Shokkenki
+  module Consumer
+    module Stubber
+      class StubServerMiddleware
+
+        attr_accessor :error
+
+        def initialize
+          @interactions = Interactions.new
+          @middlewares = {
+            %r{^#{identify_path}} => lambda(&method(:identify)),
+            %r{^/shokkenki/interactions/unused} => UnusedInteractionsMiddleware.new(@interactions),
+            %r{^/shokkenki/interactions} => InteractionsMiddleware.new(@interactions),
+            %r{^/shokkenki/requests/unmatched} => UnmatchedRequestsMiddleware.new(@interactions),
+            /.*/ => StubbedResponseMiddleware.new(@interactions)
+          }
+        end
+
+        def call env
+          begin
+            handler = @middlewares.find {|path, m| path.match(env['PATH_INFO']) }[1]
+            handler.call env
+          rescue StandardError => e
+            @error = e unless @error
+            raise e
+          end
+        end
+
+        def identify env
+          [200, {}, [object_id.to_s]]
+        end
+
+        def identify_path
+          '/shokkenki/__identify__'
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/stubbed_response_middleware.rb

@@ -0,0 +1,34 @@
+require 'json'
+require_relative 'request'
+require_relative 'rack_response'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class StubbedResponseMiddleware
+
+        def initialize interactions
+          @interactions = interactions
+        end
+
+        def call env
+          request = Request.from_rack env
+          interaction = @interactions.find request
+          interaction ? RackResponse.from_interaction(interaction) : no_interaction(request)
+        end
+
+        private
+
+        def no_interaction request
+          body = {
+            :shokkenki => {
+              :message => 'No matching responses were found for the request.',
+              :request => request.to_hash
+            }
+          }
+          [404, {'Content-Type' => 'application/json'}, [body.to_json]]
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/unmatched_requests_middleware.rb

@@ -0,0 +1,22 @@
+require_relative 'interaction'
+require_relative 'restful_middleware'
+require 'json'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class UnmatchedRequestsMiddleware < RestfulMiddleware
+
+        def initialize interactions
+          @interactions = interactions
+        end
+
+        get do |env|
+          requests = @interactions.unmatched_requests
+          json = JSON.pretty_generate(requests.collect{|r| r.to_hash})
+          [200, {'Content-Type' => 'application/json'}, [json]]
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/stubber/unused_interactions_middleware.rb

@@ -0,0 +1,21 @@
+require_relative 'restful_middleware'
+require 'json'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class UnusedInteractionsMiddleware < RestfulMiddleware
+
+        def initialize interactions
+          @interactions = interactions
+        end
+
+        get do |env|
+          interactions = @interactions.unused_interactions
+          json = JSON.pretty_generate(interactions.collect{|r| r.to_hash})
+          [200, {'Content-Type' => 'application/json'}, [json]]
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/version.rb

@@ -0,0 +1,7 @@
+module Shokkenki
+  module Consumer
+    module Version
+      STRING = '0.0.2'
+    end
+  end
+end