shokkenki-consumer 0.0.2

data/lib/shokkenki/consumer/configuration/provider_configuration.rb

@@ -0,0 +1,30 @@
+require_relative '../model/provider'
+
+module Shokkenki
+  module Consumer
+    module Configuration
+      class ProviderConfiguration
+
+        attr_writer :label
+
+        def initialize name, stubber_classes
+          @name = name
+          @stubber_classes = stubber_classes
+        end
+
+        def stub_with stubber_name, attributes = {}
+          stubber_class = @stubber_classes[stubber_name] || raise("No stubber found named '#{stubber_name}'.")
+          @stubber = stubber_class.new attributes
+        end
+
+        def to_provider
+          Shokkenki::Consumer::Model::Provider.new(
+            :stubber => @stubber,
+            :name => @name,
+            :label => @label
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/configuration/session.rb

@@ -0,0 +1,38 @@
+require_relative 'provider_configuration'
+require_relative '../stubber/http_stubber'
+
+module Shokkenki
+  module Consumer
+    module Configuration
+      module Session
+
+        attr_reader :stubber_classes
+
+        def configure &block
+          instance_eval &block if block
+        end
+
+        def tickets location
+          self.ticket_location = location
+        end
+
+        def stubber_classes
+          @stubber_classes ||= { :local_server => Shokkenki::Consumer::Stubber::HttpStubber }
+        end
+
+        def register_stubber name, clazz
+          stubber_classes[name] = clazz
+        end
+
+        def define_provider name, &block
+          provider_config = ProviderConfiguration.new(
+            name,
+            stubber_classes
+          )
+          provider_config.instance_eval &block if block
+          add_provider provider_config.to_provider
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/consumer.rb

@@ -0,0 +1,9 @@
+require_relative 'session'
+
+module Shokkenki
+
+  def self.consumer
+    @consumer_session ||= Shokkenki::Consumer::Session.new
+  end
+
+end

data/lib/shokkenki/consumer/dsl/http_methods.rb

@@ -0,0 +1,16 @@
+module Shokkenki
+  module Consumer
+    module DSL
+      module HttpMethods
+
+        [:get, :put, :post, :delete, :options, :head].each do |meth|
+
+          define_method meth do |path, details={}|
+            receive({:path => path, :method => meth}.merge(details))
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/dsl/order.rb

@@ -0,0 +1,70 @@
+require 'shokkenki/term/core_ext'
+require_relative '../model/interaction'
+require_relative '../model/fixture'
+require_relative 'http_methods'
+require_relative 'term_dsl'
+
+module Shokkenki
+  module Consumer
+    module DSL
+      class Order
+        include HttpMethods
+        include TermDSL
+
+        def initialize patronage
+          @patronage = patronage
+          @fixtures = []
+        end
+
+        def during label
+          @interaction_label = label
+          self
+        end
+
+        def receive details
+          raise "No request method has been specified." unless details.has_key?(:method)
+          raise "The request method must be a symbol." unless @request_details = details[:method].is_a?(Symbol)
+
+          raise "No request path has been specified." unless details.has_key?(:path)
+          raise "The request path must be a string." unless details[:path].is_a?(String)
+
+          @request_details = details
+          self
+        end
+
+        def and_respond details
+          @response_details = details
+          self
+        end
+
+        def given name, arguments=nil
+          @fixtures << Shokkenki::Consumer::Model::Fixture.new(
+            :name => name,
+            :arguments => arguments
+          )
+          self
+        end
+
+        def validate!
+          raise "No request has been specified." unless @request_details
+          raise "No response has been specified." unless @response_details
+        end
+
+        def to_interaction
+          Shokkenki::Consumer::Model::Interaction.new(
+            :label => @interaction_label,
+            :request => @request_details.to_shokkenki_term,
+            :response => @response_details.to_shokkenki_term,
+            :fixtures => @fixtures
+          )
+        end
+
+        def to &block
+          instance_eval &block
+          validate!
+          @patronage.add_interaction to_interaction
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/dsl/session.rb

@@ -0,0 +1,13 @@
+require_relative 'order'
+
+module Shokkenki
+  module Consumer
+    module DSL
+      module Session
+        def order provider_name
+          order = Order.new current_patronage_for(provider_name)
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/dsl/term_dsl.rb

@@ -0,0 +1,13 @@
+require 'shokkenki/term/json_paths_term'
+
+module Shokkenki
+  module Consumer
+    module DSL
+      module TermDSL
+        def json paths
+          Shokkenki::Term::JsonPathsTerm.new paths
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/model/fixture.rb

@@ -0,0 +1,21 @@
+module Shokkenki
+  module Consumer
+    module Model
+      class Fixture
+
+        attr_reader :name, :arguments
+
+        def initialize attributes
+          @name = attributes[:name]
+          @arguments = attributes[:arguments]
+        end
+
+        def to_hash
+          hash = {:name => @name}
+          hash.merge!(:arguments => @arguments) if @arguments
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Shokkenki
+  module Consumer
+    module Model
+      class Interaction
+
+        attr_reader :label, :request, :response, :time, :fixtures
+
+        def initialize attributes
+          @label = attributes[:label]
+          @request = attributes[:request]
+          @response = attributes[:response]
+          @fixtures = attributes[:fixtures]
+          @time = Time.now
+        end
+
+        def to_hash
+          hash = {
+            :request => @request.to_hash,
+            :response => @response.to_hash,
+            :time => @time.utc.iso8601
+          }
+          hash.merge!(:label => @label) if @label
+          hash.merge!(:fixtures => @fixtures.map{ |f| f.to_hash }) if @fixtures
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/model/patronage.rb

@@ -0,0 +1,31 @@
+require_relative 'ticket'
+
+module Shokkenki
+  module Consumer
+    module Model
+      class Patronage
+
+        attr_reader :provider, :consumer, :interactions
+
+        def initialize attributes
+          @provider = attributes[:provider]
+          @consumer = attributes[:consumer]
+          @interactions = []
+        end
+
+        def add_interaction interaction
+          @interactions << interaction
+          @provider.stub_interaction interaction
+        end
+
+        def ticket
+          Ticket.new(
+            :consumer => @consumer,
+            :provider => @provider,
+            :interactions => @interactions
+          )
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/model/provider.rb

@@ -0,0 +1,33 @@
+require_relative 'role'
+require_relative '../stubber/http_stubber'
+
+module Shokkenki
+  module Consumer
+    module Model
+      class Provider < Role
+        extend Forwardable
+        def_delegators :@stubber, :stub_interaction, :clear_interaction_stubs,
+          :session_started, :session_closed
+
+        attr_reader :stubber
+
+        def initialize attributes
+          super attributes
+          @stubber = attributes[:stubber] || Shokkenki::Consumer::Stubber::HttpStubber.new({})
+        end
+
+        def assert_all_requests_matched!
+          unmatched_requests = @stubber.unmatched_requests
+          message = "In provider '#{@name}' the following requests were not matched: #{JSON.pretty_generate(unmatched_requests)}"
+          raise message unless unmatched_requests.empty?
+        end
+
+        def assert_all_interactions_used!
+          unused_interactions = @stubber.unused_interactions
+          message = "In provider '#{@name}' the following interactions were never used: #{JSON.pretty_generate(unused_interactions)}"
+          raise message unless unused_interactions.empty?
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/model/role.rb

@@ -0,0 +1,27 @@
+require_relative 'simplification'
+require 'active_support/core_ext/string/inflections'
+
+module Shokkenki
+  module Consumer
+    module Model
+      class Role
+        include Simplification
+
+        attr_reader :name, :label
+
+        def initialize arguments
+          @name = simplify(arguments[:name])
+          @label = arguments[:label] || @name.to_s.titleize
+        end
+
+        def to_hash
+          {
+            :name => @name,
+            :label => @label
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/model/simplification.rb

@@ -0,0 +1,16 @@
+module Shokkenki
+  module Consumer
+    module Model
+      module Simplification
+        def simplify name
+          name.to_s.
+            strip.
+            gsub(' ', '_').
+            gsub(/\W/, '').
+            downcase.
+            to_sym if name
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/model/ticket.rb

@@ -0,0 +1,38 @@
+require_relative '../version'
+require 'json'
+
+module Shokkenki
+  module Consumer
+    module Model
+      class Ticket
+
+        attr_reader :provider, :consumer, :interactions
+        attr_accessor :time, :version
+
+        def initialize attributes
+          @provider = attributes[:provider]
+          @consumer = attributes[:consumer]
+          @interactions = attributes[:interactions]
+          @version = Shokkenki::Consumer::Version::STRING
+        end
+
+        def filename
+          "#{@consumer.name}-#{@provider.name}.json"
+        end
+
+        def to_hash
+          {
+            :consumer => @consumer.to_hash,
+            :provider => @provider.to_hash,
+            :interactions => @interactions.collect(&:to_hash),
+            :version => @version
+          }
+        end
+
+        def to_json
+          JSON.pretty_generate to_hash
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/rspec/example_group_binding.rb

@@ -0,0 +1,17 @@
+require_relative '../consumer'
+
+module Shokkenki
+  module Consumer
+    module RSpec
+      module ExampleGroupBinding
+        def shokkenki
+          Shokkenki.consumer
+        end
+
+        def order provider
+          shokkenki.order provider
+        end
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/rspec/hooks.rb

@@ -0,0 +1,32 @@
+require_relative '../consumer'
+require_relative '../model/role'
+
+module Shokkenki
+  module Consumer
+    module RSpec
+      class Hooks
+
+        def self.before_suite
+          Shokkenki.consumer.start
+        end
+
+        def self.before_each name
+          Shokkenki.consumer.add_consumer(Shokkenki::Consumer::Model::Role.new(:name => name)) unless Shokkenki.consumer.consumer(name)
+          Shokkenki.consumer.set_current_consumer name
+          Shokkenki.consumer.clear_interaction_stubs
+        end
+
+        def self.after_each
+          Shokkenki.consumer.assert_all_requests_matched!
+          Shokkenki.consumer.assert_all_interactions_used!
+        end
+
+        def self.after_suite
+          Shokkenki.consumer.print_tickets
+          Shokkenki.consumer.close
+        end
+
+      end
+    end
+  end
+end

data/lib/shokkenki/consumer/rspec/rspec_configuration.rb

@@ -0,0 +1,25 @@
+require_relative 'example_group_binding'
+require_relative 'hooks'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.include(
+    Shokkenki::Consumer::RSpec::ExampleGroupBinding,
+    :shokkenki_consumer => lambda{ |x| true }
+  )
+
+  config.before(:suite) { Shokkenki::Consumer::RSpec::Hooks.before_suite }
+
+  shokkenki_consumer_examples = { :shokkenki_consumer => lambda{ |x| true } }
+
+  config.before(:each, shokkenki_consumer_examples) do |example_group|
+    Shokkenki::Consumer::RSpec::Hooks.before_each example_group.example.metadata[:shokkenki_consumer]
+  end
+
+  config.after(:each, shokkenki_consumer_examples) do
+    Shokkenki::Consumer::RSpec::Hooks.after_each
+  end
+
+  config.after(:suite) { Shokkenki::Consumer::RSpec::Hooks.after_suite }
+end

data/lib/shokkenki/consumer/rspec.rb

@@ -0,0 +1,2 @@
+require_relative 'consumer'
+require_relative 'rspec/rspec_configuration'

data/lib/shokkenki/consumer/session.rb

@@ -0,0 +1,83 @@
+require_relative 'model/patronage'
+require_relative 'model/simplification'
+require_relative 'dsl/session'
+require_relative 'configuration/session'
+
+module Shokkenki
+  module Consumer
+    class Session
+      include Shokkenki::Consumer::Model::Simplification
+      include Shokkenki::Consumer::DSL::Session
+      include Shokkenki::Consumer::Configuration::Session
+
+      attr_reader :current_consumer, :patronages, :configuration, :providers, :consumers
+      attr_accessor :ticket_location
+
+      def initialize
+        @consumers = {}
+        @providers = {}
+        @patronages = {}
+        @ticket_location = 'tickets'
+      end
+
+      def current_patronage_for provider_name
+        consumer = @current_consumer
+        provider = provider(provider_name) || raise("The provider '#{provider_name}' is not recognised. Have you defined it?")
+        key = { consumer => provider }
+        @patronages[key] ||= Shokkenki::Consumer::Model::Patronage.new :consumer => consumer, :provider => provider
+      end
+
+      def add_provider provider
+        @providers[simplify(provider.name)] = provider
+      end
+
+      def add_provider provider
+        @providers[simplify(provider.name)] = provider
+      end
+
+      def add_consumer consumer
+        @consumers[simplify(consumer.name)] = consumer
+      end
+
+      def provider name
+        @providers[simplify(name)]
+      end
+
+      def consumer name
+        @consumers[simplify(name)]
+      end
+
+      def set_current_consumer name
+        @current_consumer = consumer name
+      end
+
+      def clear_interaction_stubs
+        @providers.values.each { |p| p.clear_interaction_stubs }
+      end
+
+      def start
+        @providers.values.each { |p| p.session_started }
+      end
+
+      def close
+        @providers.values.each { |p| p.session_closed }
+      end
+
+      def print_tickets
+        @patronages.values.collect(&:ticket).each do |ticket|
+          ticket_path = File.expand_path(File.join(ticket_location, ticket.filename))
+          File.open(ticket_path, 'w') { |file| file.write(ticket.to_json) }
+        end
+      end
+
+      def assert_all_requests_matched!
+        @providers.values.each { |p| p.assert_all_requests_matched! }
+      end
+
+      def assert_all_interactions_used!
+        @providers.values.each { |p| p.assert_all_interactions_used! }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require_relative 'server'
+require_relative 'stub_server_middleware'
+require 'httparty'
+require 'uri'
+require 'find_a_port'
+
+module Shokkenki
+  module Consumer
+    module Stubber
+      class HttpStubber
+
+        attr_reader :port, :host, :scheme, :interactions_path, :server
+
+        def initialize attributes
+          @port = attributes[:port]
+          @scheme = attributes[:scheme] || :http
+          @host = attributes[:host] || 'localhost'
+          @interactions_path = attributes[:interactions_path] || '/shokkenki/interactions'
+          @unmatched_requests_path = '/shokkenki/requests/unmatched'
+          @unused_interactions_path = '/shokkenki/interactions/unused'
+        end
+
+        def stub_interaction interaction
+          response = HTTParty.post(interactions_uri,
+            :body => interaction.to_hash.to_json,
+            :headers => { 'Content-Type' => 'application/json' }
+          )
+          server.assert_ok!
+          raise "Failed to stub interaction: #{response.inspect}" unless successful?(response.code)
+        end
+
+        def clear_interaction_stubs
+          response = HTTParty.delete interactions_uri
+          server.assert_ok!
+          raise "Failed to clear interaction stubs: #{response.inspect}" unless successful?(response.code)
+        end
+
+        def successful? response_code
+          (200 <= response_code) &&  (response_code < 300)
+        end
+
+        def session_started
+          # Find a port as late as possible to minimise the
+          # chance that it starts being used in between finding it
+          # and using it.
+          @port = FindAPort.available_port unless @port
+
+          @server = Server.new(
+            :app => StubServerMiddleware.new,
+            :host => @host,
+            :port => @port
+          )
+          @server.start
+        end
+
+        def session_closed
+          @server.shutdown
+        end
+
+        def unmatched_requests
+          response = HTTParty.get unmatched_requests_uri
+          server.assert_ok!
+          raise "Failed to find unmatched requests: #{response.inspect}" unless successful?(response.code)
+          JSON.parse response.body
+        end
+
+        def unused_interactions
+          response = HTTParty.get unused_interactions_uri
+          server.assert_ok!
+          raise "Failed to find unused interactions: #{response.inspect}" unless successful?(response.code)
+          JSON.parse response.body
+        end
+
+        def server_properties
+          {
+            :scheme => @scheme.to_s,
+            :host => @host.to_s,
+            :port => @port
+          }
+        end
+
+        def interactions_uri
+          URI::Generic.build(server_properties.merge(:path => @interactions_path.to_s)).to_s
+        end
+
+        def unmatched_requests_uri
+          URI::Generic.build(server_properties.merge(:path => @unmatched_requests_path.to_s)).to_s
+        end
+
+        def unused_interactions_uri
+          URI::Generic.build(server_properties.merge(:path => @unused_interactions_path.to_s)).to_s
+        end
+
+      end
+    end
+  end
+end