mirage 2.4.2 → 3.0.0.alpha.1

data/lib/mirage/client.rb

@@ -1,7 +1,10 @@
 $LOAD_PATH.unshift "#{File.dirname(__FILE__)}"
-require 'client/web'
+require 'client/template_configuration'
 require 'client/error'
 require 'client/cli_bridge'
 require 'client/runner'
-require 'client/response'
+require 'client/template'
+require 'client/templates'
+require 'client/requests'
+require 'client/request'
 require 'client/client'

data/lib/mirage/client/client.rb

@@ -1,20 +1,15 @@
 require 'uri'
+require 'httparty'
+require 'base64'
+require 'json'
+
 module Mirage
   class Client
-    Defaults = Struct.new(:method, :status, :delay, :content_type, :default)
-    include Mirage::Web
-    attr_reader :url
+    include HTTParty
 
+    attr_reader :url
 
-    # Creates an instance of the Mirage client that can be used to interact with the Mirage Server
-    #
-    #   Client.new => a client that is configured to connect to Mirage on http://localhost:7001/mirage (the default settings for Mirage)
-    #   Client.new(URL) => a client that is configured to connect to an instance of Mirage running on the specified url.
-    #   Client.new(hash) => a client that is configured to connect to an instance of Mirage running on the specified url or localhost port.
-    #     e.g: Client.new(:url => url) or Client.new(:port => port)
-    #
-    #   a block can be passed to configure the client with defaults: see configure
-    def initialize options={:url => "http://localhost:7001/mirage"}, &block
+    def initialize options={:url => "http://localhost:7001/mirage"}
       if options.is_a?(String) && options =~ URI.regexp
         warn("Client.new(url): Deprecated usage, please use :url => url | :port => port")
         @url = options
@@ -25,142 +20,40 @@ module Mirage
       else
         raise "specify a valid URL or port"
       end
-
-      reset
-      configure &block if block_given?
-    end
-
-
-    # Configures default settings to be applied to all response templates put on to Mirage
-    #
-    #   Example:
-    #   Client.new.configure do
-    #     defaults.method = :post
-    #     defaults.status = 202
-    #     defaults.default = true
-    #     defaults.delay = 2
-    #     defaults.content_type = "text/xml"
-    #   end
-    def configure &block
-      yield @defaults
-    end
-
-    # Remove any defaults applied to this client
-    def reset
-      @defaults = Defaults.new
-    end
-
-    def stop
-      Mirage.stop :port => URI.parse(@url).port
-    end
-
-
-    # Set a text or file based response template, to be hosted at a given end point. A block can be specified to configure the template
-    # client.set(endpoint, response, &block) => unique id that can be used to call back to the server
-    #
-    # Examples:
-    # client.put('greeting', 'hello')
-    #
-    # client.put('greeting', 'hello') do |response|
-    #   response.pattern = 'pattern' #regex or string literal applied against the request querystring and body
-    #   response.method = :post #By default templates will respond to get requests
-    #   response.content_type = 'text/html' #defaults text/plain
-    #   response.default = true # defaults to false. setting to true will allow this template to respond to request made to sub resources should it match.
-    # end
-    def put endpoint, response_value, &block
-      response = Mirage::Response.new response_value
-      @defaults.each_pair { |key, value| response.send("#{key}=", value) if value }
-      yield response if block_given?
-
-      build_response(http_put("#{@url}/templates/#{endpoint}", response.value, response.headers))
     end
 
-    # Use to look to preview the content of a response template would return to a client without actually triggering.
-    # client.response(response_id) => response held on the server as a String
-    def response response_id
-      response = build_response(http_get("#{@url}/templates/#{response_id}"))
-      case response
-        when String then
-          return response
-        when Mirage::Web::FileResponse then
-          return response.response.body
-      end
-
+    def templates id=nil
+      return Template.get("#{@url}/templates/#{id}") if id
+      Templates.new(@url)
     end
 
-    # Clear Content from Mirage
-    #
-    # If a response id is not valid, a ResponseNotFound exception will be thrown
-    #
-    # Example Usage:
-    #   client.clear -> clear all responses and associated requests
-    #   client.clear(response_id) -> Clear the response and tracked request for a given response id
-    #   client.clear(:requests) -> Clear all tracked request information
-    #   client.clear(:request => response_id) -> Clear the tracked request for a given response id
-    def clear thing=nil
-
-      case thing
-        when :requests
-          http_delete("#{@url}/requests")
-        when Numeric then
-          http_delete("#{@url}/templates/#{thing}")
-        when Hash then
-          puts "deleteing request #{thing[:request]}"
-          http_delete("#{@url}/requests/#{thing[:request]}") if thing[:request]
-        else
-          NilClass
-          http_delete("#{@url}/templates")
-      end
-
+    def requests id=nil
+      return Request.get "#{@url}/requests/#{id}" if id
+      Requests.new(@url)
     end
 
-
-    # Retrieve the last request that triggered a response to be returned. If the request contained content in its body, this is returned. If the
-    # request did not have any content in its body then what ever was in the request query string is returned instead
-    #
-    # Example Usage
-    #   client.request(response_id) -> Tracked request as a String
-    def request response_id
-      build_response(http_get("#{@url}/requests/#{response_id}"))
+    def prime
+      self.class.send(:put, "#{@url}/defaults", :body => "")
     end
 
-    # Save the state of the Mirage server so that it can be reverted back to that exact state at a later time.
     def save
-      http_put("#{@url}/backup", '').code == 200
+      self.class.send(:put, "#{@url}/backup", :body => "")
     end
 
-
-    # Revert the state of Mirage back to the state that was last saved
-    # If there is no snapshot to rollback to, nothing happens
     def revert
-      http_put(@url, '').code == 200
+      self.class.send(:put, @url, :body => "")
     end
 
-
-    # Check to see if mirage is running on the url that the client is pointing to
-    def running?
-      Mirage.running?(@url)
+    def put endpoint, value, &block
+      templates.put endpoint, value, &block
     end
 
-    # Clear down the Mirage Server and load any defaults that are in Mirages default responses directory.
-    def prime
-      build_response(http_put("#{@url}/defaults", ''))
+    def clear
+      templates.delete_all
     end
 
     def == client
-      client.is_a?(Client) && @url == client.url
-    end
-
-    private
-    def build_response response
-      case response.code.to_i
-        when 500 then
-          raise ::Mirage::InternalServerException.new(response.body, response.code.to_i)
-        when 404 then
-          raise ::Mirage::ResponseNotFound.new(response.body, response.code.to_i)
-        else
-          response.body
-      end
+      client.instance_of?(Client) && self.url == client.url
     end
   end
 end

data/lib/mirage/client/request.rb

@@ -0,0 +1,25 @@
+require 'hashie/mash'
+module Mirage
+  class Request
+    include HTTParty
+
+    class << self
+      alias_method :backedup_get, :get
+      def get url
+        result = Hashie::Mash.new(backedup_get(url, format: :json))
+        request = new
+        request.parameters = result.parameters
+        request.headers = result.headers
+        request.request_url = result.request_url
+        request.body = result.body
+        request
+      end
+    end
+
+    attr_accessor :parameters, :headers, :body, :request_url
+
+    def delete
+      self.class.delete(request_url)
+    end
+  end
+end

data/lib/mirage/client/requests.rb

@@ -0,0 +1,13 @@
+module Mirage
+  class Requests
+    include HTTParty
+
+    def initialize base_url
+      @url = "#{base_url}/requests"
+    end
+
+    def delete_all
+      self.class.delete(@url)
+    end
+  end
+end

data/lib/mirage/client/runner.rb

@@ -2,15 +2,16 @@ require 'thor'
 require 'waitforit'
 require 'childprocess'
 require 'uri'
+require 'httparty'
 module Mirage
   class << self
-    include Web
 
     # Start Mirage locally on a given port
     # Example Usage:
     #
     #   Mirage.start :port => 9001 -> Configured MirageClient ready to use.
-    def start options={:port => 7001}
+    def start options={}
+      options={:port => 7001}.merge(options)
       Runner.new.invoke(:start, [], options)
       Mirage::Client.new(options)
     end
@@ -42,7 +43,7 @@ module Mirage
     #   Mirage.running? url -> boolean indicating whether Mirage is running on the given URL
     def running? options_or_url = {:port => 7001}
       url = options_or_url.kind_of?(Hash) ? "http://localhost:#{options_or_url[:port]}/mirage" : options_or_url
-      http_get(url) and return true
+      HTTParty.get(url) and return true
     rescue Errno::ECONNREFUSED
       return false
     end
@@ -50,7 +51,6 @@ module Mirage
   end
 
   class Runner < Thor
-    include ::Mirage::Web
     include CLIBridge
     RUBY_CMD = ChildProcess.jruby? ? 'jruby' : 'ruby'
 

data/lib/mirage/client/template.rb

@@ -0,0 +1,108 @@
+require 'ostruct'
+require 'json'
+require 'httparty'
+require 'hashie/mash'
+module Mirage
+
+  class Template
+    include HTTParty
+
+    class << self
+      alias_method :backedup_get, :get
+
+      def get url
+        response_hashie = Hashie::Mash.new backedup_get(url, :format => :json)
+
+        response_config = response_hashie.response
+        request_config = response_hashie.request
+
+        template = new(response_hashie.endpoint, response_config.body)
+
+        template.id = response_hashie.id
+        template.default = response_config['default']
+        template.delay = response_config.delay
+        template.content_type = response_config.content_type
+        template.status = response_config.status
+
+        template.required_parameters = request_config.parameters
+        template.required_body_content = request_config.body_content
+        template.http_method = request_config.http_method
+        template.url = url
+        template.requests_url = response_hashie.requests_url
+        template.required_headers = request_config.headers
+
+        template
+      end
+    end
+
+    format :json
+
+    attr_accessor :content_type, :http_method, :default, :status, :delay, :required_parameters, :required_body_content, :required_headers, :endpoint, :id, :url, :requests_url
+    attr_reader :value
+
+
+    def initialize endpoint, response, default_config=TemplateConfiguration.new
+
+      @endpoint = endpoint
+      @content_type = default_config.content_type
+      @value = response
+      @http_method = default_config.http_method
+      @status = default_config.status
+      @delay = default_config.delay
+      @required_parameters = {}
+      @required_headers = {}
+      @required_body_content = []
+      @default = default_config.default
+    end
+
+    def create
+      @id = self.class.put("#{@endpoint}", :body => self.to_json, :headers => {'content-type' => 'application/json'})['id']
+      self
+    end
+
+    def delete
+      self.class.delete(url)
+      Request.delete requests_url
+    end
+
+
+    def to_json
+      {
+          :response => {
+              :body => Base64.encode64(@value),
+              :status => status,
+              :default => default,
+              :content_type => content_type
+
+          },
+          :request => {
+              :parameters => encode_regexs(required_parameters),
+              :headers => encode_regexs(required_headers),
+              :body_content => encode_regexs(required_body_content),
+              :http_method => http_method
+
+          },
+          :delay => delay
+      }.to_json
+    end
+
+
+    def encode_regexs hash_or_array
+      case hash_or_array
+        when Array
+          hash_or_array.collect { |value| encode(value) }
+        else
+          encoded = {}
+          hash_or_array.each do |key, value|
+            encoded[key] = encode(value)
+          end
+          encoded
+      end
+    end
+
+    def encode(value)
+      value.is_a?(Regexp) ? "%r{#{value.source}}" : value
+    end
+
+  end
+end

data/lib/mirage/client/template_configuration.rb

@@ -0,0 +1,22 @@
+module Mirage
+  class TemplateConfiguration
+    attr_accessor :http_method, :status, :delay, :content_type, :default
+    DEFAULT_HTTP_METHOD=:get
+    DEFAULT_STATUS=200
+    DEFAULT_DELAY=0
+    DEFAULT_CONTENT_TYPE="text/plain"
+    DEFAULT_DEFAULT=false
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @http_method = DEFAULT_HTTP_METHOD
+      @status = DEFAULT_STATUS
+      @delay = DEFAULT_DELAY
+      @content_type = DEFAULT_CONTENT_TYPE
+      @default = DEFAULT_DEFAULT
+    end
+  end
+end

data/lib/mirage/client/templates.rb

@@ -0,0 +1,26 @@
+module Mirage
+  class Templates
+    include HTTParty
+    def initialize base_url
+      @url = "#{base_url}/templates"
+      @requests = Requests.new(base_url)
+      @default_config = TemplateConfiguration.new
+    end
+
+    def default_config &block
+      return @default_config unless block_given?
+      yield @default_config
+    end
+
+    def delete_all
+      self.class.delete(@url)
+      @requests.delete_all
+    end
+
+    def put endpoint, response
+      template = Mirage::Template.new  "#{@url}/#{endpoint}", response, @default_config
+      yield template if block_given?
+      template.create
+    end
+  end
+end

data/mirage.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "mirage"
-  s.version = "2.4.2"
+  s.version = "3.0.0.alpha.1"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Leon Davis"]
-  s.date = "2012-09-20"
+  s.date = "2013-04-01"
   s.description = "Mirage aids testing of your applications by hosting mock responses so that your applications do not have to talk to real endpoints. Its accessible via HTTP and has a RESTful interface."
   s.executables = ["mirage"]
   s.extra_rdoc_files = [
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".rvmrc",
+    ".simplecov",
     "Gemfile",
     "Gemfile.lock",
     "HISTORY",
@@ -43,43 +44,62 @@ Gem::Specification.new do |s|
     "features/server/templates/delete.feature",
     "features/server/templates/get.feature",
     "features/server/templates/put/put.feature",
-    "features/server/templates/put/put_as_default.feature",
-    "features/server/templates/put/put_with_delay.feature",
-    "features/server/templates/put/put_with_pattern.feature",
     "features/server/templates/put/put_with_substitutions.feature",
+    "features/server/templates/put/required_content.feature",
     "features/server/web_user_interface.feature",
     "features/step_definitions/my_steps.rb",
     "features/support/command_line.rb",
     "features/support/env.rb",
     "features/support/hooks.rb",
     "features/support/mirage.rb",
+    "features/support/web.rb",
     "full_build.sh",
     "lib/mirage/client.rb",
     "lib/mirage/client/cli_bridge.rb",
     "lib/mirage/client/client.rb",
     "lib/mirage/client/error.rb",
-    "lib/mirage/client/response.rb",
+    "lib/mirage/client/request.rb",
+    "lib/mirage/client/requests.rb",
     "lib/mirage/client/runner.rb",
-    "lib/mirage/client/web.rb",
+    "lib/mirage/client/template.rb",
+    "lib/mirage/client/template_configuration.rb",
+    "lib/mirage/client/templates.rb",
     "mirage.gemspec",
     "mirage_server.rb",
     "rakefile",
     "responses/default_responses.rb",
+    "server/app.rb",
+    "server/binary_data_checker.rb",
     "server/extensions/hash.rb",
     "server/extensions/object.rb",
+    "server/helpers.rb",
     "server/mock_response.rb",
-    "spec/cli_bridge_spec.rb",
-    "spec/client_spec.rb",
-    "spec/runner_spec.rb",
+    "server/server.rb",
+    "spec/client/cli_bridge_spec.rb",
+    "spec/client/client_spec.rb",
+    "spec/client/request_spec.rb",
+    "spec/client/requests_spec.rb",
+    "spec/client/runner_spec.rb",
+    "spec/client/template_configuration_spec.rb",
+    "spec/client/template_spec.rb",
+    "spec/client/templates_spec.rb",
+    "spec/resources/binary.file",
+    "spec/server/binary_data_checker_spec.rb",
+    "spec/server/helpers_spec.rb",
+    "spec/server/mock_response_spec.rb",
+    "spec/server/server_spec.rb",
     "spec/spec_helper.rb",
+    "test.html",
     "test.rb",
-    "views/index.erb"
+    "todo.lst",
+    "views/index.haml",
+    "views/response.haml"
   ]
   s.homepage = "https://github.com/lashd/mirage"
   s.licenses = ["MIT"]
   s.post_install_message = "\n===============================================================================\nThanks you for installing mirage.   \n\nRun Mirage with:\n\nmirage start                                   \n\nFor more information go to: https://github.com/lashd/mirage/wiki\n===============================================================================\n"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.17"
+  s.rubygems_version = "1.8.24"
   s.summary = "Mirage is a easy mock server for testing your applications"
 
   if s.respond_to? :specification_version then
@@ -90,10 +110,10 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<childprocess>, [">= 0"])
       s.add_runtime_dependency(%q<waitforit>, [">= 0"])
       s.add_runtime_dependency(%q<thor>, [">= 0"])
-      s.add_development_dependency(%q<thin>, [">= 0"])
+      s.add_runtime_dependency(%q<ptools>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, [">= 0"])
+      s.add_runtime_dependency(%q<haml>, [">= 0"])
       s.add_development_dependency(%q<rake>, [">= 0"])
-      s.add_development_dependency(%q<cucumber>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
       s.add_development_dependency(%q<sinatra-contrib>, [">= 0"])
       s.add_development_dependency(%q<mechanize>, [">= 0"])
@@ -104,10 +124,10 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<childprocess>, [">= 0"])
       s.add_dependency(%q<waitforit>, [">= 0"])
       s.add_dependency(%q<thor>, [">= 0"])
-      s.add_dependency(%q<thin>, [">= 0"])
+      s.add_dependency(%q<ptools>, [">= 0"])
+      s.add_dependency(%q<httparty>, [">= 0"])
+      s.add_dependency(%q<haml>, [">= 0"])
       s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<cucumber>, [">= 0"])
-      s.add_dependency(%q<rspec>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
       s.add_dependency(%q<sinatra-contrib>, [">= 0"])
       s.add_dependency(%q<mechanize>, [">= 0"])
@@ -119,10 +139,10 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<childprocess>, [">= 0"])
     s.add_dependency(%q<waitforit>, [">= 0"])
     s.add_dependency(%q<thor>, [">= 0"])
-    s.add_dependency(%q<thin>, [">= 0"])
+    s.add_dependency(%q<ptools>, [">= 0"])
+    s.add_dependency(%q<httparty>, [">= 0"])
+    s.add_dependency(%q<haml>, [">= 0"])
     s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<cucumber>, [">= 0"])
-    s.add_dependency(%q<rspec>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
     s.add_dependency(%q<sinatra-contrib>, [">= 0"])
     s.add_dependency(%q<mechanize>, [">= 0"])