mock_server 0.1.0

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2011 Charles Barbier <http://github.com/unixcharles>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# MockServer
+
+So you have spec for your models and controller for your API.
+Now you're building a neat javascript application that consumer that JSON.
+And you're going to test it with something like capybara?
+The thing is that its going to be slow! And you're testing testing all you're application logic again!
+
+MockServer allow you to record your interaction with the server and give you a way to match
+the record request with the real request. Its like a rack [VCR](https://github.com/myronmarston/vcr) for your own API!
+
+# Recording mode
+
+Create mount the rack application, in rails
+
+    require 'mock_server/record'
+    config.middleware.use MockServer::Record, { :path => 'fixtures/records', :filename => 'uploads'
+                                               :routes => [ '/api/*/**', '/api/*/**' ] }
+
+And you're ready to record. Run the test, build so seed by clicking around. whatever.
+
+# Playback mode
+
+    require 'mock_server/playback'
+    config.middleware.use MockServer::Playback, { :path => 'fixtures/records' ] }
+
+Recording your own playback? Noes, don't use the two Rack middleware at the same time.
+
+# Rspec
+
+    require 'mock_server/spec/helpers'
+    RSpec.configure do |config|
+      config.include MockServer::Spec::Helpers
+    end
+
+In your spec
+
+    before :each do
+
+      # Set the filename where you store the records
+      mock_server_use_record 'uploads'
+
+      # From now on, those path belong to MockServer.
+      #
+      # if we can't match to a record, the server return a 404 and populate the errors stack.
+      mock_server_enable_routes '**/uploads/*', '**/uploads', '**/folders'
+
+    end
+
+    after :each do
+      mock_server_disable_all_routes!
+      mock_server_clear_matchers!
+      mock_server_response_stack_clear!
+    end
+
+    scenario "Some json api fun" do
+      mock_server_get('/api/2/projects')
+      mock_server_post('/api/2/projects') do |request, recorded_request|
+
+        # I use the should helpers because it return the method
+        # but it won't raise a failure in the test, since it happen
+        # inside a proc ouside the scenario. But It will populate the
+        # error stack if can't match anything.
+
+        recorded_request.body.name.should == recorded_request.body.name and
+        recorded_request.body.name.should == 'MockServer'
+
+        # Its a normal detect block, so it has to return true to match
+        # the record response.
+      }
+
+      ... fun stuff ...
+
+      mock_server_success_stack.should include('/api/2/projects')
+      mock_server_errors_stack.should be_empty
+    end
+
+# Pull request?
+
+Yes.

data/lib/mock_server/playback.rb

@@ -0,0 +1,69 @@
+require 'mock_server/utils'
+
+module MockServer
+  class Playback
+    include MockServer::Utils
+
+    def initialize(app, options = {})
+      @options = options
+      @app = app
+      $mock_server_options ||= options
+    end
+
+    def call(env)
+      return @app.call(env) unless $mock_server_options and
+                                   $mock_server_options[:routes] and
+                                   lazy_match $mock_server_options[:routes], env["PATH_INFO"]
+
+      @options.merge!($mock_server_options)
+
+      @request = Rack::Request.new(env)
+      @data = load_data
+
+      record = match_request
+
+      if record
+        $mock_server_options[:success_stack] ||= []
+        $mock_server_options[:success_stack] << @request.path
+
+        response = record[:response]
+        [response[:status], response[:headers], [response[:body]]]
+      else
+        $mock_server_options[:errors_stack] ||= []
+        error = { @request.path => "Couldn't match #{@request.request_method} #{@request.path}" }
+        $mock_server_options[:errors_stack] << error
+        [404, {}, ['RECORD NOT FOUND!']]
+      end
+    end
+
+    private
+
+    def match_request
+      request = Hashie::Mash.new hashified_request
+
+      # Filter out data records by path and method
+      @data.select! { |record|
+        record[:request][:path] == request[:path] and record[:request][:method] == request[:method]
+      }
+
+      # Filter out matchers by path and method
+      matchers = @options[:matchers].select { |match| 
+        request[:method].to_s.upcase == match[:method].to_s.upcase and request[:path] == match[:path]
+      }
+
+      # Match the request with a record by validating against the matcher if any.
+      @data.detect { |entry|
+        recorded_request = Hashie::Mash.new entry[:request]
+
+        matchers.detect { |matcher|
+          if matcher[:matcher]
+            matcher[:matcher].call(request, recorded_request) rescue false
+          else
+            true
+          end
+        }
+      }
+    end
+
+  end
+end

data/lib/mock_server/record.rb

@@ -0,0 +1,40 @@
+require 'mock_server/utils'
+
+module MockServer
+  class Record
+    include MockServer::Utils
+
+    def initialize(app, options = {})
+      @options = options
+      @app = app
+      $mock_server_options ||= options
+    end
+
+    def call(env)
+      return @app.call(env) unless $mock_server_options and
+                                   $mock_server_options[:routes] and
+                                   lazy_match $mock_server_options[:routes], env["PATH_INFO"]
+
+      @options.merge!($mock_server_options)
+
+      @request = Rack::Request.new(env)
+      @data = load_data
+
+      @app.call(env).tap do |response|
+        record_response(response)
+        response
+      end
+    end
+  
+    private
+    
+    def record_response(response)
+      request = hashified_request
+      @data.reject! { |record| record[:request] == request }
+
+      @data << { :request => request, :response => hashify_response(response) }
+      save_data(@data)
+    end
+
+  end
+end

data/lib/mock_server/spec/helpers.rb

@@ -0,0 +1,158 @@
+# The purpose of the helper is to manpulate MockServer global var
+# in an rspec way. $mock_server_options
+#
+#
+# The basic:
+#
+#   $mock_server_options = { :path => 'fixtures/records', :filename => 'uploads' }
+#
+#
+# $mock_server_options tell you application which URL to do its magic for both, 
+# record and playback mode.
+#
+# Example:
+#
+#   $mock_server_options[:routes] = [ '**/uploads.json', '**/uploads/*',
+#                                     '**/folders.json', '**/folders', '**/folders' ]
+#
+# $mock_server_options[:matchers] is an array of path, url, and matchers proc
+#
+# Example:
+#
+# $mock_server_options[:matchers] = [
+#   { :method => :get, :path => '/api/2/projects/1/uploads.json',
+#     :matcher => Proc.new { |request, recorded_request|
+#       request.query == recorded_request.query and
+#       request.query == 'count=0'
+#     }
+#   },
+#   { :method => :put, :path => '/api/2/uploads/20',
+#     :matcher => Proc.new { |request, recorded_request|
+#       request.query == recorded_request.query and
+#       request.query == 'count=0'
+#     }
+#   },
+#   { :method => :delete, :path => '/api/2/uploads/20' },
+#   { :method => :get, :path => '/api/2/projects/1/folders.json' },
+#   { :method => :post, :path => '/api/2/folders',
+#     :matcher => Proc.new { |request, recorded_request|
+#       request.body.project_id == recorded_request.body.project_id and
+#       request.body.project_id == 1 and
+#       recorded_request.body.name == recorded_request.body.name and
+#       recorded_request.body.name == 'Mockup'
+#     }
+#   },
+#   { :method => :put, :path => '/api/2/uploads/20', 
+#     :matcher => Proc.new { |request, recorded_request|
+#       request.body.name == recorded_request.body.name
+#     }
+#   },
+#   { :method => :delete, :path => '/api/2/folders/3' }
+# ]
+
+
+
+module MockServer
+  module Spec
+    module Helpers
+
+      # Inspect
+      def mock_server_inspect
+        $mock_server_options.inspect
+      end
+
+      # Configuration
+      def mock_server_use_record(filename)
+        mock_server_config_set(:filename, filename)
+      end
+
+      def mock_server_set_fixture_path(path)
+        mock_server_config_set(:path, path)
+      end
+
+      # Active path config
+      def mock_server_enable_routes(*arguments)
+        $mock_server_options ||= {}
+        $mock_server_options[:routes] ||= []
+        $mock_server_options[:routes] << arguments
+        $mock_server_options[:routes].flatten!
+      end
+
+      def mock_server_disable_path(path)
+        return unless $mock_server_options and $mock_server_options[:routes]
+        $mock_server_options[:routes] = if path.is_an? Array
+          path unless path.empty?
+        else
+          $mock_server_options[:routes] - [path]
+        end
+      end
+
+      def mock_server_disable_all_routes!
+        $mock_server_options[:routes] = nil
+      end
+
+      # Matchers helpers
+      def mock_server_get(path, &block)
+        mock_server_request :get, path, block
+      end
+
+      def mock_server_post(path, &block)
+        mock_server_request :post, path, block
+      end
+
+      def mock_server_put(path, &block)
+        mock_server_request :put, path, block
+      end
+
+      def mock_server_delete(path, &block)
+        mock_server_request :delete, path, block
+      end
+
+      def mock_server_clear_matchers!
+        mock_server_config_set(:matchers, [])
+      end
+
+      # Errors / Success stack
+
+      def mock_server_errors_stack
+        $mock_server_options[:errors_stack] || []
+      end
+
+      def mock_server_errors_stack_clear!
+        $mock_server_options[:errors_stack] = []
+      end
+
+      def mock_server_success_stack
+        $mock_server_options[:success_stack] || []
+      end
+
+      def mock_server_success_stack_clear!
+        $mock_server_options[:success_stack] = []
+      end
+
+      def mock_server_response_stack_clear!
+        mock_server_success_stack_clear!
+        mock_server_errors_stack_clear!
+      end
+
+      protected
+      # Configuration
+      def mock_server_config_set(key, value)
+        $mock_server_options ||= {}
+        $mock_server_options[key] = value
+      end
+
+      # Matchers helpers
+      def mock_server_request(method, path, matcher)
+        add_mock_server_matcher({ :method => method, :path => path, :matcher => matcher })
+      end
+
+      def add_mock_server_matcher(matcher)
+        $mock_server_options ||= {}
+        $mock_server_options[:matchers] ||= []
+        $mock_server_options[:matchers] << matcher
+      end
+
+    end
+  end
+end

data/lib/mock_server/utils.rb

@@ -0,0 +1,65 @@
+module MockServer
+  module Utils
+
+    private
+
+    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
+      body = JSON.parse(@request.body.to_a.join) rescue ''
+      {
+        :method  => @request.request_method,
+        :path    => @request.path,
+        :query   => @request.query_string,
+        :body    => body
+      }
+    end
+  
+    def hashify_response(response)
+      status  = response[0]
+      headers = response[1]
+      body    = response[2].body rescue ''
+
+      {
+        :method  => @request.request_method,
+        :path    => @request.path,
+        :status  => status,
+        :headers => headers,
+        :body    => body
+      }
+    end
+
+    # File utils
+    def records_path
+      File.join( @options[:path], @options[:filename] + '.yml' )
+    end
+
+    def load_data
+      FileUtils.mkdir_p(@options[:path]) unless File.exists? @options[:path]
+
+      data = YAML.load_file(records_path) rescue []
+
+      if data.is_a? Array
+        data
+      else
+        []
+      end
+    end
+
+    def save_data(data)
+      File.open(records_path, 'w') do |f|
+        YAML.dump(data, f)
+      end
+    end
+
+  end
+end

data/lib/mock_server.rb

@@ -0,0 +1,3 @@
+# Don't load both at the same time anyway.
+require 'mock_server/record'
+require 'mock_server/playback'

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: mock_server
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Charles Barbier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-03 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: unixcharles@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- lib/mock_server.rb
+- lib/mock_server/record.rb
+- lib/mock_server/playback.rb
+- lib/mock_server/utils.rb
+- lib/mock_server/spec/helpers.rb
+homepage: http://www.github.com/unixcharles/mock_server
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Mock you're entire application
+test_files: []