mirage 0.1.2

data/full_build.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+blue='\033[34m'
+red='\033[31m'
+green='\033[32m'
+yellow='\033[33m'
+white='\033[37m'
+bold='\033[1m'
+reset='\033[0m'
+
+println(){
+    echo -e "$1${reset}"
+}
+
+print(){
+    echo -ne "$1${reset}"
+}
+
+
+
+usage(){
+    println "${bold}Usage:\n"
+    println "./full_build.sh [ruby_version]\n"
+    println "When running with out a ruby version, the full build is run for ruby versions:"
+    println "1.8.6\n1.8.7\n1.9.1\n1.9.2\njruby\n"
+    println "Else specify a particular ruby version to run the build against\n"
+}
+
+
+if [ -f "$HOME/.rvm/scripts/rvm" ]
+then
+  source "$HOME/.rvm/scripts/rvm"
+elif [ -f "/usr/local/rvm/scripts/rvm" ]
+then
+  source "/usr/local/rvm/scripts/rvm"
+else
+    println "${bold}RVM Not found"
+    println "I looked in $HOME/.rvm/scripts/rvm and /usr/local/rvm/scripts/rvm"
+    println "RVM must be installed to run this script. It's great! find out more: here ${bold}http://rvm.beginrescueend.com/"
+    println "Until it is installed simply run the default rake target to test Mirage against your active version of Ruby and installed gems"
+    exit 1
+fi
+
+while getopts ":h" opt; do
+  case $opt in
+    h)
+      usage
+      exit 0
+      ;;
+    \?)
+      println "Invalid option: -$OPTARG"
+      usage
+      exit 1
+      ;;
+  esac
+done
+
+message=""
+result=true
+
+run_build_for_ruby( ){
+    println "${green}Running build for: $1"
+
+    ruby_list=`rvm list`
+    if [[ ${ruby_list} == *$1* ]]
+    then
+        rvm --create $1@mirage
+        rvm --force gemset empty
+        [ -f Gemfile.lock ] && rm Gemfile.lock
+        gem install bundler
+        bundle install
+        rake
+
+        if [ $? == 0 ]
+        then
+          message="${message}${blue}$1: ${green}pass\n"
+        else
+          message="${message}${blue}$1: ${red}fail\n"
+          result=false
+        fi
+    else
+        message="${message}${blue}$1: ${yellow}Not installed\n"
+        result=false
+    fi
+}
+
+if [ $1 ]
+then
+    run_build_for_ruby $1
+else
+    run_build_for_ruby 'ruby-1.8.6'
+    run_build_for_ruby 'ruby-1.8.7'
+    run_build_for_ruby 'ruby-1.9.1'
+    run_build_for_ruby 'ruby-1.9.2'
+    run_build_for_ruby 'jruby'
+fi
+
+println "\n\n${message}"
+print "${white}Result: "
+[ ${result} == true ] && println "${green}Pass\n" || println "${red}Fail\n"
+

data/lib/config.ru

@@ -0,0 +1,5 @@
+require 'rubygems'
+require "#{::File.expand_path("#{::File.dirname(__FILE__)}/mirage/core")}"
+Ramaze.start(:root => __DIR__, :started => true)
+run Ramaze
+

data/lib/mirage.rb

@@ -0,0 +1,14 @@
+require 'mirage/web'
+require 'mirage/util'
+require 'mirage/core'
+require 'mirage/client'
+
+module Mirage
+  def self.default
+    yield @@client
+  end
+
+  def self.client= client
+    @@client = client
+  end
+end

data/lib/mirage/client.rb

@@ -0,0 +1,140 @@
+require 'uri'
+require 'mechanize'
+require 'open-uri'
+require 'mirage/web'
+
+module Mirage
+
+  class MirageError < ::Exception
+    attr_reader :code
+
+    def initialize message, code
+      super message
+      @code = message, code
+    end
+  end
+
+  class InternalServerException < MirageError;
+  end
+
+  class ResponseNotFound < MirageError;
+  end
+
+  class Client
+    include ::Mirage::Web
+
+    # 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.
+    def initialize url="http://localhost:7001/mirage"
+      @url = url
+    end
+
+    # Get a response at the given endpoint
+    # Mirage::Client.get(endpoint) => response as a string
+    # If a response is not found a ResponseNotFound exception is thrown
+    #
+    #   Examples:
+    #   Getting a response, passing request parameters
+    #   Mirage::Client.new.get('greeting', :param1 => 'value1', param2=>'value2')
+    #
+    #   Getting a response, passing a content in the body of the request
+    #   Mirage::Client.new.get('greeting', :body => 'content')
+
+    def get endpoint, params={}
+      response(http_get("#{@url}/get/#{endpoint}", params))
+    end
+
+    # Set a text or file based response, to be hosted at a given end point optionally with a given pattern and delay
+    # Client.set(endpoint, params) => unique id that can be used to call back to the server
+    #
+    #  Examples:
+    #  Client.set('greeting', :response => 'hello':)
+    #  Client.set('greeting', :response => 'hello', :pattern => 'regex or plain text':)
+    #  Client.set('greeting', :response => 'hello', :delay => 5) # number of seconds
+    def set endpoint, params
+      response(http_post("#{@url}/set/#{endpoint}", params))
+    end
+
+    # Use to look at what a response contains without actually triggering it.
+    # Client.peek(response_id) => response held on the server as a String
+    def peek response_id
+      response(http_get("#{@url}/peek/#{response_id}"))
+    end
+
+    # Clear Content from Mirage
+    #
+    # If a response id is not valid, a ResponseNotFound exception will be thrown
+    #
+    #   Examples:
+    #   Client.new.clear # clear all responses and associated requests
+    #   Client.new.clear(response_id) # Clear the response and tracked request for a given response id
+    #   Client.new.clear(:requests) # Clear all tracked request information
+    #   Client.new.clear(:request => response_id) # Clear the tracked request for a given response id
+    def clear thing=nil
+      case thing
+        when NilClass then
+          http_get("#{@url}/clear")
+        when Fixnum then
+          http_get("#{@url}/clear/#{thing}")
+        when :requests then
+          http_get("#{@url}/clear/requests")
+        when Hash then
+          case thing.keys.first
+            when :request then
+              http_get("#{@url}/clear/request/#{thing.values.first}")
+          end
+      end
+    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:
+    #   Client.new.check(response_id) => Tracked request as a String
+    def check response_id
+      response(http_get("#{@url}/check/#{response_id}"))
+    end
+
+    # Snapshot the state of the Mirage server so that it can be rolled back to that exact state at a later time.
+    def snapshot
+      http_post("#{@url}/snapshot").code == 200
+    end
+
+
+    # Roll the state of Mirage back to that stored in the snapshot
+    # If there is no snapshot to rollback to, nothing happens
+    def rollback
+      http_post("#{@url}/rollback").code == 200
+    end
+
+
+    # Check to see if Mirage is up and running
+    def running?
+      !http_get(@url).is_a?(Errno::ECONNREFUSED)
+    end
+
+    # Clear down the Mirage Server and load any defaults that are in Mirages default responses directory.
+    def load_defaults
+      response(http_post("#{@url}/load_defaults"))
+    end
+
+    private
+    def response response
+      return Mirage::Web::FileResponse.new(response) if response.instance_of?(Mechanize::File)
+      case response.code
+        when 500 then
+          raise ::Mirage::InternalServerException.new(response.page.body, response.code)
+        when 404 then
+          raise ::Mirage::ResponseNotFound.new(response.page.body, response.code)
+        else
+          response.body
+      end
+    end
+
+  end
+
+
+end

data/lib/mirage/core.rb

@@ -0,0 +1,206 @@
+require 'ramaze'
+require 'ramaze/helper/send_file'
+
+class Object
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
+end
+
+module Mirage
+
+  class MockResponse
+    @@id_count = 0
+    attr_reader :response_id, :delay, :name, :pattern
+    attr_accessor :response_id
+
+    def initialize name, value, pattern=nil, delay=0, root_response=false
+      @name, @value, @pattern, @response_id, @delay, @root_response = name, value, pattern, @@id_count+=1, delay, root_response
+    end
+
+    def self.reset_count
+      @@id_count = 0
+    end
+
+    def root_response?
+      @root_response
+    end
+
+    def file?
+      !@value.is_a?(String)
+    end
+
+
+    def value(body='', request_parameters={}, query_string='')
+      return @value if file?
+
+      value = @value
+      value.scan(/\$\{(.*)?\}/).flatten.each do |pattern|
+
+        if (parameter_match = request_parameters[pattern])
+          value = value.gsub("${#{pattern}}", parameter_match)
+        end
+
+        [body, query_string].each do |string|
+          if (string_match = find_match(string, pattern))
+            value = value.gsub("${#{pattern}}", string_match)
+          end
+        end
+
+      end
+      value
+    end
+
+    private
+    def find_match(string, regex)
+      string.scan(/#{regex}/).flatten.first
+    end
+  end
+
+
+  class MirageServer < Ramaze::Controller
+    include Ramaze::Helper::SendFile
+    map '/mirage'
+    RESPONSES, REQUESTS, SNAPSHOT= {}, {}, {}
+
+    def index
+      @responses = {}
+
+      RESPONSES.each do |name, responses|
+        @responses[name]=responses.default unless responses.default.nil?
+
+        responses.each do |pattern, response|
+          @responses["#{name}#{'/*' if response.root_response?}: #{pattern}"] = response
+        end
+      end
+    end
+
+    def peek response_id
+      peeked_response = nil
+      RESPONSES.values.each do |responses|
+        peeked_response = responses[:default] if responses[:default] && responses[:default].response_id == response_id.to_i
+        peeked_response = responses.values.find { |response| response.response_id == response_id.to_i } if peeked_response.nil?
+        break unless peeked_response.nil?
+      end
+      respond("Can not peek reponse, id:#{response_id} does not exist}", 404) unless peeked_response
+      send_response(peeked_response)
+    end
+
+    def set *args
+      delay = (request['delay']||0)
+      pattern = request['pattern'] ? /#{request['pattern']}/ : :default
+      name = args.join('/')
+      is_root_response = request['root_response'] == 'true'
+
+      response = MockResponse.new(name, (request[:file]||response_value), pattern, delay.to_f, is_root_response)
+
+      stored_responses = RESPONSES[name]||={}
+
+      old_response = stored_responses.delete(pattern)
+      stored_responses[pattern] = response
+
+      # Right not an the main id count goes up by one even if the id is not used because the old id is reused from another response
+      response.response_id = old_response.response_id if old_response
+      response.response_id
+    end
+
+    def get *args
+      body, query_string = Rack::Utils.unescape(request.body.read.to_s), request.env['QUERY_STRING']
+      name = args.join('/')
+      stored_responses = RESPONSES[name]
+
+      if stored_responses
+        record = find_response(body, query_string, stored_responses)
+      else
+        root_responses, record = find_root_responses(name), nil
+
+        until record  || root_responses.empty?
+          record = find_response(body, query_string, root_responses.delete_at(0))
+          record = record.root_response? ? record : nil
+        end
+      end
+
+      respond('Response not found', 404) unless record
+      REQUESTS[record.response_id] = body.empty? ? query_string : body
+
+      sleep record.delay
+      send_response(record, body, request, query_string)
+    end
+
+    def clear datatype=nil, response_id=nil
+      response_id = response_id.to_i
+      case datatype
+        when 'requests' then
+          REQUESTS.clear
+        when 'responses' then
+          RESPONSES.clear and REQUESTS.clear and MockResponse.reset_count
+        when /\d+/ then
+          response_id = datatype.to_i
+          delete_response(response_id)
+          REQUESTS.delete(response_id)
+        when 'request'
+          REQUESTS.delete(response_id)
+        when nil
+          [REQUESTS, RESPONSES].each { |map| map.clear }
+          MockResponse.reset_count
+      end
+    end
+
+    def check id
+      REQUESTS[id.to_i] || respond("Nothing stored for: #{id}", 404)
+    end
+
+    def snapshot
+      SNAPSHOT.clear and SNAPSHOT.replace(RESPONSES.deep_clone)
+    end
+
+    def rollback
+      RESPONSES.clear and RESPONSES.replace(SNAPSHOT.deep_clone)
+    end
+
+    def load_defaults
+      clear
+      Dir["#{DEFAULT_RESPONSES_DIR}/**/*.rb"].each do |default|
+        begin
+          load default
+        rescue Exception
+          respond("Unable to load default responses from: #{default}", 500)
+        end
+
+      end
+    end
+
+    private
+    def find_response(body, query_string, stored_responses)
+      pattern_match = stored_responses.keys.find_all { |pattern| pattern != :default }.find { |pattern| body =~ pattern || query_string =~ pattern }
+      record = pattern_match ? stored_responses[pattern_match] : stored_responses[:default]
+      record
+    end
+
+    def response_value
+      return request['response'] unless request['response'].nil?
+      respond('response or file parameter required', 500)
+    end
+
+    def find_root_responses(name)
+      matches = RESPONSES.keys.find_all { |key| name.index(key) == 0 }.sort { |a, b| b.length <=> a.length }
+      matches.collect { |key| RESPONSES[key] }
+    end
+
+    def delete_response(response_id)
+      RESPONSES.each do |name, response_set|
+        response_set.each { |key, response| response_set.delete(key) if response.response_id == response_id }
+      end
+    end
+
+    def send_response(response, body='', request={}, query_string='')
+      if response.file?
+        tempfile, filename, type = response.value.values_at(:tempfile, :filename, :type)
+        send_file(tempfile.path, type, "Content-Disposition: attachment; filename=#{filename}")
+      else
+        response.value(body, request, query_string)
+      end
+    end
+
+  end
+end