mock_server 0.4.2 → 0.4.3

data/lib/mock_server/playback.rb

@@ -8,116 +8,118 @@ unless defined? MockServer::Store
   require 'mock_server/store/global'
 end
 
-class MockServer::Playback
-  include MockServer::Utils
-  include MockServer::Store
+module MockServer
+  class Playback
+    include MockServer::Utils
+    include MockServer::Store
+
+    def initialize(app, opt = {})
+      @app = app
+      @options = mock_server_options_merge(opt)
+    end
 
-  def initialize(app, opt = {})
-    @app = app
-    @options = mock_server_options_merge(opt)
-  end
+    def call(env)
+      @options = self.mock_server_options_read
 
-  def call(env)
-    @options = self.mock_server_options_read
+      verbose(env) if @options[:verbose]
+      return @app.call(env) unless matchable_request?(env)
 
-    verbose(env) if @options[:verbose]
-    return @app.call(env) unless matchable_request?(env)
+      @request = Rack::Request.new(env)
+      @options[:requests_stack] << @request.path
+      @data = load_data
 
-    @request = Rack::Request.new(env)
-    @options[:requests_stack] << @request.path
-    @data = load_data
+      response = build_response
+      self.mock_server_options_write(@options)
+      response
+    end
 
-    response = build_response
-    self.mock_server_options_write(@options)
-    response
-  end
+    private
 
-  private
+    def build_response
+      if record = match_request
+        return_record(record)
+      else
+        return_error
+      end
+    end
 
-  def build_response
-    if record = match_request
-      return_record(record)
-    else
-      return_error
+    def return_record(record)
+      @options[:success_stack] << @request.path
+      @options[:matcher_exceptions].clear
+      response = record[:response]
+      [response[:status], response[:headers], [response[:body]]]
     end
-  end
 
-  def return_record(record)
-    @options[:success_stack] << @request.path
-    @options[:matcher_exceptions].clear
-    response = record[:response]
-    [response[:status], response[:headers], [response[:body]]]
-  end
+    def return_error
+      error = { @request.path => "Couldn't match #{@request.request_method} #{@request.path}" }
+      @options[:errors_stack] << error
+      [404, {}, ['RECORD NOT FOUND!']]
+    end
 
-  def return_error
-    error = { @request.path => "Couldn't match #{@request.request_method} #{@request.path}" }
-    @options[:errors_stack] << error
-    [404, {}, ['RECORD NOT FOUND!']]
-  end
+    def match_request
+      request = Hashie::Mash.new hashified_request
 
-  def match_request
-    request = Hashie::Mash.new hashified_request
+      # Filter out data records by path and method
+      records = filter_records(request)
 
-    # Filter out data records by path and method
-    records = filter_records(request)
+      matchers = filter_matchers(request)
 
-    matchers = filter_matchers(request)
+      record = false
+      matchers.detect { |matcher|
+        # Match the request with a record by validating against the matcher if any.
+        record = records.detect { |entry|
+          recorded_request  = Hashie::Mash.new entry[:request]
+          recorded_response = entry[:response].dup
 
-    record = false
-    matchers.detect { |matcher|
-      # Match the request with a record by validating against the matcher if any.
-      record = records.detect { |entry|
-        recorded_request  = Hashie::Mash.new entry[:request]
-        recorded_response = entry[:response].dup
+          recorded_response[:body] = JSON.parse(recorded_response[:body]) rescue recorded_response[:body]
+          recorded_response = Hashie::Mash.new recorded_response
 
-        recorded_response[:body] = JSON.parse(recorded_response[:body]) rescue recorded_response[:body]
-        recorded_response = Hashie::Mash.new recorded_response
+          test_request_and_matcher(matcher, request, recorded_request, recorded_response)
+        }
+      }
+      record
+    end
 
-        test_request_and_matcher(matcher, request, recorded_request, recorded_response)
+    def filter_matchers(request)
+      @options[:matchers].select { |match|
+        request[:method].to_s.upcase == match[:method].to_s.upcase and request[:path] == match[:path]
       }
-    }
-    record
-  end
+    end
 
-  def filter_matchers(request)
-    @options[:matchers].select { |match|
-      request[:method].to_s.upcase == match[:method].to_s.upcase and request[:path] == match[:path]
-    }
-  end
+    def filter_records(request)
+      @data.select { |record|
+        record[:request][:path] == request[:path] and record[:request][:method] == request[:method]
+      }
+    end
 
-  def filter_records(request)
-    @data.select { |record|
-      record[:request][:path] == request[:path] and record[:request][:method] == request[:method]
-    }
-  end
+    def test_request_and_matcher(matcher, request, recorded_request, recorded_response)
+      return true if matcher[:matcher].nil?
+      begin
+        matcher[:matcher].call(request, recorded_request, recorded_response) == true
+      rescue => matcher_err
+        store_matcher_exception(matcher_err)
+        false
+      end
+    end
 
-  def test_request_and_matcher(matcher, request, recorded_request, recorded_response)
-    return true if matcher[:matcher].nil?
-    begin
-      matcher[:matcher].call(request, recorded_request, recorded_response) == true
-    rescue => matcher_err
-      store_matcher_exception(matcher_err)
-      false
+    def store_matcher_exception(exception)
+      @options[:matcher_exceptions] << exception
     end
-  end
 
-  def store_matcher_exception(exception)
-    @options[:matcher_exceptions] << exception
-  end
+    def load_data
+      FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
 
-  def load_data
-    FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
+      data = []
 
-    data = []
+      @options[:record_filenames].map do |filename|
+        file_path = File.join( @options[:path], filename + '.yml' )
+        content   = File.open(file_path).read
+        compiled  = ERB.new(content).result
+        parsed    = YAML.load(compiled)
+        data     += parsed
+      end
 
-    @options[:record_filenames].map do |filename|
-      file_path = File.join( @options[:path], filename + '.yml' )
-      content   = File.open(file_path).read
-      compiled  = ERB.new(content).result
-      parsed    = YAML.load(compiled)
-      data     += parsed
+      data
     end
-
-    data
   end
 end

data/lib/mock_server/record.rb

@@ -5,59 +5,61 @@ unless defined? MockServer::Store
   require 'mock_server/store/global'
 end
 
-class MockServer::Record
-  include MockServer::Utils
-  include MockServer::Store
+module MockServer
+  class Record
+    include MockServer::Utils
+    include MockServer::Store
 
-  def initialize(app, opt = {})
-    @app = app
-    @options = mock_server_options_merge(opt)
-  end
+    def initialize(app, opt = {})
+      @app = app
+      @options = mock_server_options_merge(opt)
+    end
 
-  def call(env)
-    @options = self.mock_server_options_read
+    def call(env)
+      @options = self.mock_server_options_read
 
-    verbose(env) if @options[:verbose]
-    return @app.call(env) unless matchable_request?(env)
+      verbose(env) if @options[:verbose]
+      return @app.call(env) unless matchable_request?(env)
 
-    @request = Rack::Request.new(env)
-    @data = load_data
+      @request = Rack::Request.new(env)
+      @data = load_data
 
-    @app.call(env).tap do |status, header, response|
-      record_response(status, header, response)
-      self.mock_server_options_write(@options)
-      response
+      @app.call(env).tap do |status, header, response|
+        record_response(status, header, response)
+        self.mock_server_options_write(@options)
+        response
+      end
     end
-  end
 
-  private
+    private
 
-  def record_response(status, header, response)
-    request = hashified_request
+    def record_response(status, header, response)
+      request = hashified_request
 
-    @data << { :request => request, :response => hashify_response(status, header, response) }
-    save_data(@data)
-  end
+      @data << { :request => request, :response => hashify_response(status, header, response) }
+      save_data(@data)
+    end
 
-  def records_path
-    File.join( @options[:path], @options[:filename] + '.yml' )
-  end
+    def records_path
+      File.join( @options[:path], @options[:filename] + '.yml' )
+    end
 
-  def save_data(data)
-    File.open(records_path, 'w') do |f|
-      YAML.dump(data, f)
+    def save_data(data)
+      File.open(records_path, 'w') do |f|
+        YAML.dump(data, f)
+      end
     end
-  end
 
-  def load_data
-    FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
+    def load_data
+      FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
 
-    data = YAML.load_file(records_path) rescue []
+      data = YAML.load_file(records_path) rescue []
 
-    if data.is_a? Array
-      data
-    else
-      []
+      if data.is_a? Array
+        data
+      else
+        []
+      end
     end
   end
 end

data/lib/mock_server/spec/helpers.rb

@@ -2,7 +2,7 @@ unless defined? MockServer::Store
   require 'mock_server/store/global'
 end
 
-module MockServer::Spec
+module MockServer; module Spec
   module Helpers
     include MockServer::Store
 
@@ -298,4 +298,4 @@ module MockServer::Spec
     end
 
   end
-end
+end; end

data/lib/mock_server/state.rb

@@ -1,30 +1,32 @@
 require 'hashie'
 
-class MockServer::State < Hashie::Dash
-  property :path, :default => 'fixtures/records'
-  property :filename, :default => 'record'
-  property :routes, :default => []
-  property :record_filenames, :default => []
-  property :matchers, :default => []
-  property :verbose, :default => false
-  property :requests_stack, :default => []
-  property :success_stack, :default => []
-  property :errors_stack, :default => []
-  property :requests_stack, :default => []
-  property :matcher_exceptions, :default => []
+module MockServer
+  class State < Hashie::Dash
+    property :path, :default => 'fixtures/records'
+    property :filename, :default => 'record'
+    property :routes, :default => []
+    property :record_filenames, :default => []
+    property :matchers, :default => []
+    property :verbose, :default => false
+    property :requests_stack, :default => []
+    property :success_stack, :default => []
+    property :errors_stack, :default => []
+    property :requests_stack, :default => []
+    property :matcher_exceptions, :default => []
 
-  def merge(hash)
-    new_hash = self
-    hash.each do |k,v|
-      new_hash[k] = v
+    def merge(hash)
+      new_hash = self
+      hash.each do |k,v|
+        new_hash[k] = v
+      end
+      new_hash
     end
-    new_hash
-  end
 
-  def merge!(hash)
-    hash.each do |k,v|
-      self[k] = v
+    def merge!(hash)
+      hash.each do |k,v|
+        self[k] = v
+      end
+      self
     end
-    self
   end
 end

data/lib/mock_server/store/global.rb

@@ -1,18 +1,20 @@
 require 'hashie'
 
-module MockServer::Store
-  def mock_server_options_merge(opt = {})
-    $mock_server_options ||= MockServer::State.new(opt)
-    $mock_server_options.merge!(opt)
-  end
+module MockServer
+  module Store
+    def mock_server_options_merge(opt = {})
+      $mock_server_options ||= MockServer::State.new(opt)
+      $mock_server_options.merge!(opt)
+    end
 
-  def mock_server_options_read
-    $mock_server_options ||= MockServer::State.new
-    $mock_server_options
-  end
+    def mock_server_options_read
+      $mock_server_options ||= MockServer::State.new
+      $mock_server_options
+    end
 
-  def mock_server_options_write(value)
-    $mock_server_options ||= MockServer::State.new
-    $mock_server_options = value
+    def mock_server_options_write(value)
+      $mock_server_options ||= MockServer::State.new
+      $mock_server_options = value
+    end
   end
 end

data/lib/mock_server/utils.rb

@@ -1,60 +1,62 @@
 require 'yaml'
 require 'json'
 
-module MockServer::Utils
-  private
-
-  def verbose(env)
-    interception = lazy_match(@options[:routes], env["PATH_INFO"]) ? "intercepted!" : "NOT intercepted."
-    puts %([MockServer] #{env["PATH_INFO"]} was #{interception}"\n)
-  end
-
-  def matchable_request?(env)
-    @options[:routes] and lazy_match @options[:routes], env["PATH_INFO"]
-  end
-
-  def lazy_match(strings, path)
-    regexps = strings.map { |str|
-      escaped = Regexp.escape(str)
-      escaped.gsub!('\\*\\*', '[\w|.|\-|\/]+')
-      escaped.gsub!('\\*', '[\w|.|\-]+')
-      Regexp.new("^#{escaped}$")
-    }
-
-    regexps.any? { |regex| regex.match(path) }
-  end
-
-  def hashified_request
-    #rewind to ensure we read from the start
-    @request.body.rewind
-
-    #read body
-    body = @request.body.read
-
-    #rewind in case upstream expects it rewound
-    @request.body.rewind
-
-    json = JSON.parse(body) rescue body
-
-    {
-      :method  => @request.request_method,
-      :path    => @request.path,
-      :query   => @request.query_string,
-      :body    => json
-    }
-  end
-
-  def hashify_response(status, header, response)
-    {
-      :method  => @request.request_method,
-      :path    => @request.path,
-      :status  => status,
-      :headers => header,
-      :body    => if response.respond_to? :body
-        response.body
-      else
-        response.join
-      end
-    }
+module MockServer
+  module Utils
+    private
+
+    def verbose(env)
+      interception = lazy_match(@options[:routes], env["PATH_INFO"]) ? "intercepted!" : "NOT intercepted."
+      puts %([MockServer] #{env["PATH_INFO"]} was #{interception}"\n)
+    end
+
+    def matchable_request?(env)
+      @options[:routes] and lazy_match @options[:routes], env["PATH_INFO"]
+    end
+
+    def lazy_match(strings, path)
+      regexps = strings.map { |str|
+        escaped = Regexp.escape(str)
+        escaped.gsub!('\\*\\*', '[\w|.|\-|\/]+')
+        escaped.gsub!('\\*', '[\w|.|\-]+')
+        Regexp.new("^#{escaped}$")
+      }
+
+      regexps.any? { |regex| regex.match(path) }
+    end
+
+    def hashified_request
+      #rewind to ensure we read from the start
+      @request.body.rewind
+
+      #read body
+      body = @request.body.read
+
+      #rewind in case upstream expects it rewound
+      @request.body.rewind
+
+      json = JSON.parse(body) rescue body
+
+      {
+        :method  => @request.request_method,
+        :path    => @request.path,
+        :query   => @request.query_string,
+        :body    => json
+      }
+    end
+
+    def hashify_response(status, header, response)
+      {
+        :method  => @request.request_method,
+        :path    => @request.path,
+        :status  => status,
+        :headers => header,
+        :body    => if response.respond_to? :body
+          response.body
+        else
+          response.join
+        end
+      }
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mock_server
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors: