http_stub 0.25.1 → 0.26.0

data/lib/http_stub/server/session/empty.rb

@@ -0,0 +1,15 @@
+module HttpStub
+  module Server
+    module Session
+
+      class Empty
+
+        def self.stubs
+          []
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/session/identifier_strategy.rb

@@ -0,0 +1,24 @@
+module HttpStub
+  module Server
+    module Session
+
+      class IdentifierStrategy
+
+        def initialize(session_configuration)
+          @identifier_configuration = session_configuration.identifier_configuration
+        end
+
+        def identifier_for(sinatra_request)
+          @identifier_configuration.map do |configuration_entry|
+            configuration_entry.map do |attribute_type, attribute_name|
+              identifier_attributes = attribute_type == :header ? sinatra_request.headers : sinatra_request.parameters
+              identifier_attributes[attribute_name]
+            end
+          end.flatten.compact.first
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/session/registry.rb

@@ -0,0 +1,38 @@
+module HttpStub
+  module Server
+    module Session
+
+      class Registry
+
+        delegate :find, :all, :delete, to: :@session_registry
+
+        def initialize(session_configuration, scenario_registry, memory_session)
+          @session_configuration = session_configuration
+          @scenario_registry     = scenario_registry
+          @memory_session        = memory_session
+          @session_registry      = HttpStub::Server::Registry.new("session", [ memory_session ])
+        end
+
+        def find_or_create(session_id, logger)
+          effective_session_id = session_id || @session_configuration.default_identifier
+          @session_registry.find(effective_session_id, logger) || create(effective_session_id, logger)
+        end
+
+        def clear(logger)
+          @memory_session.clear(logger)
+          @session_registry.replace([ @memory_session ], logger)
+        end
+
+        private
+
+        def create(session_id, logger)
+          HttpStub::Server::Session::Session.new(session_id, @scenario_registry, @memory_session).tap do |session|
+            @session_registry.add(session, logger)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/session/session.rb

@@ -0,0 +1,80 @@
+module HttpStub
+  module Server
+    module Session
+
+      class Session
+
+        attr_reader :id
+
+        def initialize(id, scenario_registry, memory_session)
+          @id                  = id
+          @scenario_registry   = scenario_registry
+          @stub_registry       = HttpStub::Server::Stub::Registry.new(memory_session)
+          @stub_match_registry = HttpStub::Server::Registry.new("stub match")
+          @stub_miss_registry  = HttpStub::Server::Registry.new("stub miss")
+        end
+
+        def matches?(id, _logger)
+          id == @id
+        end
+
+        def activate_scenario!(name, logger)
+          found_scenario = @scenario_registry.find(name, logger)
+          raise HttpStub::Server::Scenario::NotFoundError, name unless found_scenario
+          @stub_registry.concat(found_scenario.stubs, logger)
+          found_scenario.triggered_scenarios.each { |scenario| activate_scenario!(scenario.name, logger) }
+        end
+
+        def add_stub(stub, logger)
+          @stub_registry.add(stub, logger)
+        end
+
+        def find_stub(id, logger)
+          @stub_registry.find(id, logger)
+        end
+
+        def stubs
+          @stub_registry.all
+        end
+
+        def match(request, logger)
+          @stub_registry.match(request, logger)
+        end
+
+        def add_match(match, logger)
+          @stub_match_registry.add(match, logger)
+          match.stub.triggers.scenario_names.each { |scenario_name| activate_scenario!(scenario_name, logger) }
+          match.stub.triggers.stubs.each { |stub| add_stub(stub, logger) }
+        end
+
+        def matches
+          @stub_match_registry.all
+        end
+
+        def last_match(args, logger)
+          @stub_match_registry.find(args, logger)
+        end
+
+        def add_miss(miss, logger)
+          @stub_miss_registry.add(miss, logger)
+        end
+
+        def misses
+          @stub_miss_registry.all
+        end
+
+        def reset(logger)
+          @stub_miss_registry.clear(logger)
+          @stub_match_registry.clear(logger)
+          @stub_registry.reset(logger)
+        end
+
+        def clear(logger)
+          [ @stub_miss_registry, @stub_match_registry, @stub_registry ].each { |registry| registry.clear(logger) }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/http_stub/server/stub/controller.rb

@@ -4,28 +4,34 @@ module HttpStub
 
       class Controller
 
-        def initialize(stub_registry, match_registry, miss_registry)
-          @stub_registry  = stub_registry
-          @match_registry = match_registry
-          @miss_registry  = miss_registry
-        end
-
         def register(request, logger)
           stub = HttpStub::Server::Stub.create(HttpStub::Server::Stub::Parser.parse(request))
-          @stub_registry.add(stub, logger)
+          request.session.add_stub(stub, logger)
           HttpStub::Server::Response.ok("headers" => { "location" => stub.uri })
         end
 
         def match(request, logger)
-          stub = @stub_registry.match(request, logger)
+          stub = request.session.match(request, logger)
           response = stub ? stub.response_for(request) : HttpStub::Server::Response::NOT_FOUND
-          @match_registry.add(HttpStub::Server::Stub::Match::Match.new(request, response, stub), logger) if stub
-          @miss_registry.add(HttpStub::Server::Stub::Match::Miss.new(request), logger) unless stub
+          request.session.add_match(HttpStub::Server::Stub::Match::Match.new(request, response, stub), logger) if stub
+          request.session.add_miss(HttpStub::Server::Stub::Match::Miss.new(request), logger) unless stub
           response
         end
 
-        def clear(logger)
-          [ @stub_registry, @match_registry, @miss_registry ].each { |registry| registry.clear(logger) }
+        def find(request, logger)
+          request.session.find_stub(request.parameters[:stub_id], logger)
+        end
+
+        def find_all(request)
+          request.session.stubs
+        end
+
+        def reset(request, logger)
+          request.session.reset(logger)
+        end
+
+        def clear(request, logger)
+          request.session.clear(logger)
         end
 
       end

data/lib/http_stub/server/stub/empty.rb

@@ -10,7 +10,7 @@ module HttpStub
           @uri         = ""
           @match_rules = HttpStub::Server::Stub::Match::Rules::EMPTY
           @response    = HttpStub::Server::Response::EMPTY
-          @triggers    = []
+          @triggers    = HttpStub::Server::Stub::Triggers::EMPTY
         end
 
         public

data/lib/http_stub/server/stub/match/controller.rb

@@ -5,13 +5,17 @@ module HttpStub
 
         class Controller
 
-          def initialize(result_registry)
-            @result_registry = result_registry
+          def last_match(request, logger)
+            result = request.session.last_match(request.parameters.slice(:method, :uri), logger)
+            result ? HttpStub::Server::Response.ok("body" => result.to_json) : HttpStub::Server::Response::NOT_FOUND
           end
 
-          def find_last(request, logger)
-            result = @result_registry.find(request.parameters.slice(:method, :uri), logger)
-            result ? HttpStub::Server::Response.ok("body" => result.to_json) : HttpStub::Server::Response::NOT_FOUND
+          def matches(request)
+            request.session.matches
+          end
+
+          def misses(request)
+            request.session.misses
           end
 
         end

data/lib/http_stub/server/stub/payload/response_body_modifier.rb

@@ -8,7 +8,9 @@ module HttpStub
           def self.modify!(payload, request)
             response_file = request.parameters["response_file_#{payload["id"]}"]
             payload["response"]["body"] = response_file if response_file
-            payload["triggers"].each { |trigger_payload| modify!(trigger_payload, request) } if payload["triggers"]
+            payload["triggers"]["stubs"].each do |trigger_payload|
+              modify!(trigger_payload, request)
+            end if payload["triggers"] && payload["triggers"]["stubs"]
           end
 
         end

data/lib/http_stub/server/stub/registry.rb

@@ -6,22 +6,15 @@ module HttpStub
 
         delegate :add, :concat, :find, :all, :clear, to: :@stub_registry
 
-        def initialize
-          @stub_registry = HttpStub::Server::Registry.new("stub")
-        end
-
-        def match(request, logger)
-          @stub_registry.find(request, logger).tap do |matched_stub|
-            matched_stub.triggers.add_to(self, logger) if matched_stub
-          end
-        end
+        alias_method :match, :find
 
-        def remember
-          @remembered_stub = @stub_registry.last
+        def initialize(memory_session)
+          @memory_session = memory_session
+          @stub_registry  = HttpStub::Server::Registry.new("stub", memory_session.stubs)
         end
 
-        def recall
-          @stub_registry.rollback_to(@remembered_stub) if @remembered_stub
+        def reset(logger)
+          @stub_registry.replace(@memory_session.stubs, logger)
         end
 
       end

data/lib/http_stub/server/stub/triggers.rb

@@ -4,22 +4,24 @@ module HttpStub
 
       class Triggers
 
-        delegate :each, to: :@triggers
-
-        def initialize(triggers)
-          @triggers = (triggers || []).map { |trigger| HttpStub::Server::Stub.create(trigger) }
+        attr_reader :scenario_names
+        attr_reader :stubs
+
+        def initialize(args={})
+          resolved_args = { "scenario_names" => [], "stubs" => [] }.merge(args || {})
+          @scenario_names = resolved_args["scenario_names"]
+          @stubs          = resolved_args["stubs"].map { |stub_args| HttpStub::Server::Stub.create(stub_args) }
+          @description    = resolved_args.to_s
         end
 
-        def add_to(registry, logger)
-          @triggers.each { |trigger| registry.add(trigger, logger) }
-        end
+        EMPTY = HttpStub::Server::Stub::Triggers.new.freeze
 
         def to_json(*args)
-          @triggers.to_json(*args)
+          { scenario_names: @scenario_names, stubs: @stubs }.to_json(*args)
         end
 
         def to_s
-          @triggers.reduce("") { |result, trigger| "#{result}\n#{trigger}" }
+          @description
         end
 
       end

data/lib/http_stub/server/views/_home.haml

@@ -0,0 +1,2 @@
+%header
+  %h1 http_stub administration

data/lib/http_stub/server/views/_post_link_function.haml

@@ -0,0 +1,26 @@
+:javascript
+  function postLink(link_selector, successText) {
+    $(window).load(function() {
+      $(link_selector).on("click", function(event) {
+        event.preventDefault();
+        var link = $(event.target)
+        var originalLinkText = link.text();
+        link.prop("disabled", true);
+        $.post(
+          link.attr("href"), link.data(), null, "html"
+        ).done(
+          function() {
+            link.html(successText).css("color", "green");
+            setTimeout(function() { link.html(originalLinkText).css("color", "inherit"); }, 3000);
+          }
+        ).fail(
+          function() {
+            link.html("Failed").css("color", "red");
+            setTimeout(function() { link.html(originalLinkText).css("color", "inherit"); }, 3000);
+          }
+        ).always(
+          function() { link.prop("disabled", false); }
+        );
+      });
+    });
+  }

data/lib/http_stub/server/views/_session.haml

@@ -0,0 +1,16 @@
+%section
+  %a{ href: session_uri("/http_stub/scenarios"), id: :scenarios, class: :link } List Scenarios
+  %br
+  %a{ href: session_uri("/http_stub/stubs"), id: :stubs, class: :link } List Stubs
+  %br
+  %a{ href: session_uri("/http_stub/stubs/matches"), id: :stub_matches, class: :link } List Stub Matches
+  %br
+  %a{ href: session_uri("/http_stub/stubs/misses"), id: :stub_misses, class: :link } List Stub Misses
+  %br
+%section
+  %a{ href: session_uri("/http_stub/stubs/reset"), id: :reset_session, class: :link } Reset To Initial State
+  %br
+  %a{ href: "/http_stub/memory", id: :memory, class: :link } View Initial State
+  %br
+:javascript
+  postLink("a#reset_session", "Session Reset");

data/lib/http_stub/server/views/_stub.haml

@@ -4,5 +4,11 @@
   %h3 Response
   = partial :response, locals: { response: the_stub.response }
   %h3 Triggers
-  - the_stub.triggers.each do |trigger|
-    = partial :stub, locals: { the_stub: trigger }
+  - if the_stub.triggers.scenario_names.present?
+    %h4 Scenarios
+    - the_stub.triggers.scenario_names.each do |triggered_scenario_name|
+      %span= triggered_scenario_name
+  - if the_stub.triggers.stubs.present?
+    %h4 Stubs
+    - the_stub.triggers.stubs.each do |triggered_stub|
+      = partial :stub, locals: { the_stub: triggered_stub }

data/lib/http_stub/server/views/_stubs.haml

@@ -0,0 +1,4 @@
+%section
+  - stubs.each do |the_stub|
+    = partial :stub, locals: { the_stub: the_stub }
+    .header-rule

data/lib/http_stub/server/views/application.sass

@@ -15,13 +15,16 @@ body
 
 header
   :padding-left 1rem
+  :text-align center
 
 section
+  :display flex
+  :align-items center
+  :flex-direction column
   :max-width 800px
   :border-radius 10px
   :background white
   :padding 1rem
-  :display inline-block
 
 table
   :padding 1rem

data/lib/http_stub/server/views/layout.haml

@@ -5,5 +5,6 @@
     %link{ rel: "icon",       href: "/favicon.ico",         type: "image/x-icon" }
     %script{                  src:  "/jquery-2.2.4.min.js", type: "text/javascript" }
     %title http_stub server diagnostics
+    = partial :post_link_function
   %body
     =yield

data/lib/http_stub/server/views/scenario.haml

@@ -1,12 +1,13 @@
 %header
   %h1= scenario.name
 %section
-  %a{ href: scenario.links.activate, class: [:scenario, :link, :activate_scenario], data: { name: scenario.name } } Activate
+  %a{ href: session_uri(scenario.links.activate), class: [:scenario, :link, :activate_scenario], data: { name: scenario.name } } Activate
   %h2 Stubs
   - scenario.stubs.each do |the_stub|
     = partial :stub, locals: { the_stub: the_stub }
   - if scenario.triggered_scenarios.present?
     %h2 Triggered Scenarios
     - scenario.triggered_scenarios.each do |triggered_scenario|
-      %a{ href: triggered_scenario.links.detail, class: :triggered_scenario_detail }= triggered_scenario.name
-= partial :activate_scenario
+      %a{ href: session_uri(triggered_scenario.links.detail), class: :triggered_scenario_detail }= triggered_scenario.name
+:javascript
+  postLink("a.activate_scenario", "Activated");

data/lib/http_stub/server/views/scenarios.haml

@@ -4,9 +4,10 @@
   %table{ class: :scenarios }
     - scenarios.each do |scenario|
       %tr
-        %td{ class: [:scenario_name, :"header-rule"] }= scenario.name
-        %td{ class: :"header-rule" }
-          %a{ href: scenario.links.activate, class: [:scenario, :link, :activate_scenario], data: { name: scenario.name } } Activate
-        %td{ class: :"header-rule" }
-          %a{ href: scenario.links.detail, class: [:scenario, :link, :view_scenario] } View Detail
-= partial :activate_scenario
+        %td{ class: ["scenario_name", "header-rule"] }= scenario.name
+        %td{ class: "header-rule" }
+          %a{ href: session_uri(scenario.links.activate), class: [:scenario, :link, :activate_scenario], data: { name: scenario.name } } Activate
+        %td{ class: "header-rule" }
+          %a{ href: session_uri(scenario.links.detail), class: [:scenario, :link, :view_scenario] } View Detail
+:javascript
+  postLink("a.activate_scenario", "Activated");