http_stub 0.27.0 → 0.28.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9130ae13d037581af8407734972808552052ad35
-  data.tar.gz: b185025a934c899e37e257647f444d80376ab307
+  metadata.gz: e93b34750d08ac6ef4488d2fea5a9c9084776cc4
+  data.tar.gz: 31b000bf7e1a75cd549ab63c3d9cbbd935d8abd2
 SHA512:
-  metadata.gz: 359a8710eb2c61f341c78dc5dc1a58bc70af70a179f6d648cd6301e8b0aec1d591db3d3cc32ec24c6c8a4b7cc089fd944fe99b9c1d338271ab6fac8e9c975c11
-  data.tar.gz: 4ec1a47dd1ac04109f73de519751b6b1eb9be35c6cadd05db1f208ccd33da5ad4166ac36545b1cfb5d60303baf8b33aab93e048ff1d4368733300800022ca199
+  metadata.gz: 820dcaac517a6972ce83a01f58640120f723cc6b6d23ef81e1719ec6a141eb341611356282fe9414d592ce825dad0c00816abf15678f103ef241a7bc660bb3e0
+  data.tar.gz: 383722facf4da0cb57491d2e571b20a23227f1b3abaabb6df626235df97927d5b12a98cb6720efdf9ef2c458e6b1c4db5cc1e76caf62f2426048db9f34d96a93

data/lib/http_stub/client.rb

@@ -0,0 +1,18 @@
+require 'net/http'
+
+require_relative 'client/request'
+require_relative 'client/server'
+require_relative 'client/session'
+require_relative 'client/client'
+
+module HttpStub
+
+  module Client
+
+    def self.create(server_uri)
+      HttpStub::Client::Client.new(server_uri)
+    end
+
+  end
+
+end

data/lib/http_stub/client/client.rb

@@ -0,0 +1,28 @@
+module HttpStub
+  module Client
+
+    class Client
+
+      TRANSACTIONAL_SESSION_ID = "http_stub_transactional".freeze
+
+      private_constant :TRANSACTIONAL_SESSION_ID
+
+      delegate :activate!, to: :@default_session
+
+      def initialize(server_uri)
+        @server          = HttpStub::Client::Server.new(server_uri)
+        @default_session = HttpStub::Client::Session.new(TRANSACTIONAL_SESSION_ID, @server)
+      end
+
+      def session(id)
+        HttpStub::Client::Session.new(id, @server)
+      end
+
+      def reset!
+        @server.submit!(method: :delete, path: "sessions", intent: "reset server")
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/client/request.rb

@@ -0,0 +1,38 @@
+module HttpStub
+  module Client
+
+    class Request
+
+      def initialize(args)
+        @base_uri     = URI(args[:base_uri])
+        @path         = args[:path]
+        @method       = args[:method]
+        @headers      = args[:headers] || {}
+        @parameters   = args[:parameters]
+        @http_options = args[:http_options] || {}
+        @intent       = args[:intent]
+      end
+
+      def submit
+        Net::HTTP.start(@base_uri.host, @base_uri.port, @http_options) { |http| http.request(http_request) }
+      rescue StandardError => error
+        raise "#{error_message_prefix} #{error}"
+      end
+
+      def error_message_prefix
+        "Error occurred issuing request to #{@base_uri} - intent: #{@intent}, cause: "
+      end
+
+      private
+
+      def http_request
+        http_request_class = Net::HTTP.const_get(@method.to_s.capitalize)
+        http_request_class.new("/http_stub/#{@path}", @headers.stringify_keys).tap do |request|
+          request.set_form_data(@parameters) if @parameters
+        end
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/client/server.rb

@@ -0,0 +1,20 @@
+module HttpStub
+  module Client
+
+    class Server
+
+      def initialize(base_uri)
+        @base_uri = base_uri
+      end
+
+      def submit!(args)
+        request = HttpStub::Client::Request.new(args.merge(base_uri: @base_uri))
+        response = request.submit
+        raise "#{request.error_message_prefix} #{response.code} #{response.message}" unless response.code == "200"
+        response
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/client/session.rb

@@ -0,0 +1,43 @@
+module HttpStub
+  module Client
+
+    class Session
+
+      def initialize(id, server)
+        @session_id  = id
+        @server      = server
+        @description = "session '#{@session_id}'"
+      end
+
+      def activate!(*scenario_names)
+        parameters = { http_stub_session_id: @session_id, "names[]" => scenario_names }
+        @server.submit!(
+          method:     :post,
+          path:       "scenarios/activate",
+          parameters: parameters,
+          intent:     "activate scenarios #{scenario_names.map { |name| "'#{name}'" }.join(", ")} in #{@description}"
+        )
+      end
+
+      def reset!
+        @server.submit!(
+          method:     :post,
+          path:       "stubs/reset",
+          parameters: { http_stub_session_id: @session_id },
+          intent:     "reset stubs in #{@description}"
+        )
+      end
+
+      def delete!
+        @server.submit!(
+          method:     :delete,
+          path:       "sessions",
+          parameters: { http_stub_session_id: @session_id },
+          intent:     "delete #{@description}"
+        )
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator.rb

@@ -0,0 +1,61 @@
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require_relative 'extensions/core/hash/indifferent_and_insensitive_access'
+require_relative 'extensions/core/hash/with_indifferent_and_insensitive_access'
+
+require_relative 'configurator/stub/stub'
+require_relative 'configurator/stub/template'
+require_relative 'configurator/stub'
+require_relative 'configurator/scenario'
+require_relative 'configurator/endpoint_template'
+require_relative 'configurator/state'
+require_relative 'configurator/server'
+require_relative 'configurator/part'
+
+module HttpStub
+
+  module Configurator
+
+    def self.included(mod)
+      mod.extend(HttpStub::Configurator::ClassMethods)
+      mod.send(:include, HttpStub::Configurator::InstanceMethods)
+    end
+
+    module ClassMethods
+
+      def state
+        @state ||= HttpStub::Configurator::State.new
+      end
+
+      def stub_server
+        @stub_server ||= HttpStub::Configurator::Server.new(state)
+      end
+
+      def parts=(parts)
+        parts.each do |name, part|
+          part.apply_to(self)
+          self.define_singleton_method(name) { part }
+          self.send(:define_method, name) { part }
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      def state
+        self.class.state
+      end
+
+      def stub_server
+        self.class.stub_server
+      end
+
+    end
+
+  end
+
+end

data/lib/http_stub/configurator/endpoint_template.rb

@@ -0,0 +1,24 @@
+module HttpStub
+  module Configurator
+
+    class EndpointTemplate
+
+      delegate :match_requests, :schema, :respond_with, :trigger, :invoke, :build_stub, to: :@stub_template
+
+      def initialize(server, default_stub_template, &block)
+        @server        = server
+        @stub_template = HttpStub::Configurator::Stub::Template.new(default_stub_template, &block)
+      end
+
+      def add_scenario!(name, response_overrides={}, &block)
+        @server.add_scenario_with_one_stub!(name, self.build_stub(response_overrides, &block))
+      end
+
+      def add_stub!(response_overrides={}, &block)
+        @server.add_stub!(self.build_stub(response_overrides, &block))
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator/part.rb

@@ -0,0 +1,23 @@
+module HttpStub
+  module Configurator
+
+    module Part
+
+      def apply_to(configurator)
+        @configurator = configurator
+        configuration_methods = self.methods.find_all { |method| method.to_s =~ /^configure_.+_(stub|scenario)s?$/ }
+        configuration_methods.each { |configuration_method| self.send(configuration_method) }
+      end
+
+      def method_missing(name, *args, &block)
+        @configurator.respond_to?(name, true) ? @configurator.send(name, *args, &block) : super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @configurator.respond_to?(name, include_private)
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator/scenario.rb

@@ -0,0 +1,42 @@
+module HttpStub
+  module Configurator
+
+    class Scenario
+
+      delegate :build_stub, to: :@default_stub_template
+
+      def initialize(name, default_stub_template)
+        @default_stub_template = default_stub_template
+        @hash                  = {
+          name:                     name,
+          activated:                false,
+          stubs:                    [],
+          triggered_scenario_names: []
+        }.with_indifferent_access
+      end
+
+      def add_stub!(stub=nil, &block)
+        resolved_stub = stub || build_stub(&block)
+        @hash[:stubs] << resolved_stub.to_hash
+      end
+
+      def add_stubs!(stubs)
+        stubs.each { |stub| add_stub!(stub) }
+      end
+
+      def activate_scenarios!(*names)
+        @hash[:triggered_scenario_names].concat(names.flatten)
+      end
+
+      def activate!
+        @hash[:activated] = true
+      end
+
+      def to_hash
+        @hash
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator/server.rb

@@ -0,0 +1,53 @@
+module HttpStub
+  module Configurator
+
+    class Server
+
+      delegate :port=, :external_base_uri, to: :@state
+      delegate :session_identifier=, to: :@state
+      delegate :enable, to: :@state
+
+      delegate :build_stub, to: :@server_stub_template
+
+      def initialize(state)
+        @state                = state
+        @server_stub_template = HttpStub::Configurator::Stub::Template.new
+      end
+
+      def request_defaults=(args)
+        @server_stub_template.match_requests(args)
+      end
+
+      def response_defaults=(args)
+        @server_stub_template.respond_with(args)
+      end
+
+      def endpoint_template(&block)
+        HttpStub::Configurator::EndpointTemplate.new(self, @server_stub_template, &block)
+      end
+
+      def add_scenario!(name, &_block)
+        scenario = HttpStub::Configurator::Scenario.new(name, @server_stub_template)
+        yield scenario
+        @state.add_scenario(scenario)
+      end
+
+      def add_scenario_with_one_stub!(name, stub=nil, &block)
+        add_scenario!(name) do |scenario|
+          scenario.add_stub!(stub) { |added_stub| added_stub.invoke(block.arity == 2 ? scenario : nil, &block) }
+        end
+      end
+
+      def add_stub!(stub=nil, &block)
+        resolved_stub = stub || self.build_stub(&block)
+        @state.add_stub(resolved_stub)
+      end
+
+      def add_stubs!(stubs)
+        stubs.each { |stub| add_stub!(stub) }
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator/state.rb

@@ -0,0 +1,41 @@
+module HttpStub
+  module Configurator
+
+    class State
+
+      attr_accessor :port
+
+      attr_writer :session_identifier
+
+      attr_reader :scenario_hashes, :stub_hashes
+
+      def initialize
+        @scenario_hashes           = []
+        @stub_hashes               = []
+        @cross_origin_support_flag = false
+      end
+
+      def external_base_uri
+        ENV["STUB_EXTERNAL_BASE_URI"] || "http://localhost:#{@port}"
+      end
+
+      def enable(feature)
+        @cross_origin_support_flag = true if feature == :cross_origin_support
+      end
+
+      def add_scenario(scenario)
+        @scenario_hashes << scenario.to_hash
+      end
+
+      def add_stub(stub)
+        @stub_hashes << stub.to_hash
+      end
+
+      def application_settings
+        { port: @port, session_identifier: @session_identifier, cross_origin_support: @cross_origin_support_flag }
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator/stub.rb

@@ -0,0 +1,13 @@
+module HttpStub
+  module Configurator
+
+    module Stub
+
+      def self.create(parent=nil, &block)
+        HttpStub::Configurator::Stub::Stub.new(parent, &block)
+      end
+
+    end
+
+  end
+end

data/lib/http_stub/configurator/stub/stub.rb

@@ -0,0 +1,75 @@
+module HttpStub
+  module Configurator
+    module Stub
+
+      class Stub
+
+        def initialize(parent=nil, &block)
+          @hash = {
+            match_rules: {},
+            response:    { blocks: [] },
+            triggers:    { scenario_names: [], stubs: [] }
+          }.with_indifferent_access
+          self.merge!(parent) if parent
+          self.invoke(&block) if block_given?
+        end
+
+        def match_requests(args)
+          self.tap { @hash[:match_rules].deep_merge!(args) }
+        end
+
+        def schema(type, definition)
+          { schema: { type: type, definition: definition } }
+        end
+
+        def respond_with(args={}, &block)
+          remaining_args = args.clone
+          response_args  = @hash[:response]
+          response_args[:blocks].concat(remaining_args.delete(:blocks) || [])
+          response_args[:blocks] << block if block_given?
+          self.tap { response_args.deep_merge!(remaining_args) }
+        end
+
+        def trigger(args)
+          resolved_args = to_triggers(args)
+          triggers_args = @hash[:triggers]
+          triggers_args[:scenario_names].concat(resolved_args[:scenario_names])
+          triggers_args[:stubs].concat(resolved_args[:stubs])
+          self
+        end
+
+        def invoke(additional_arg=nil, &block)
+          block.arity.zero? ? self.instance_eval(&block) : yield(*[ self, additional_arg ].compact)
+        end
+
+        def merge!(stub)
+          stub_hash = stub.to_hash
+          self.match_requests(stub_hash[:match_rules])
+          self.respond_with(stub_hash[:response])
+          self.trigger(scenarios: stub_hash[:triggers][:scenario_names], stubs: stub_hash[:triggers][:stubs])
+        end
+
+        def id
+          basic_response = @hash[:response].clone.tap { |hash| hash[:blocks] = hash[:blocks].map(&:source_location) }
+          Digest::MD5.hexdigest([ @hash[:match_rules], basic_response, @hash[:triggers] ].to_s)
+        end
+
+        def to_hash
+          @hash.merge(id: id)
+        end
+
+        private
+
+        def to_triggers(args)
+          {}.tap do |resolved_args|
+            resolved_args[:scenario_names] = args[:scenario] ? [ args[:scenario] ] : args[:scenarios] || []
+            stubs = args[:stub] ? [ args[:stub] ] : args[:stubs] || []
+            resolved_args[:stubs] = stubs.map(&:to_hash)
+          end
+        end
+
+      end
+
+    end
+  end
+end