mirage-on-thin 3.0.8

data/features/templates/put.feature

@@ -0,0 +1,77 @@
+Feature: Creating a Template
+  Mirage can be configured with Templates. Templates describe the characteristics of responses that should be returned to a client. In addition to this a templates also describe the conditions under which a template may be used to generate a response.
+
+  On setting a template, a unique id is returned. This is a key that can be used to manage the Template.
+
+  Templates can be configured to respond to either, GET, POST, PUT, or DELETE.
+
+  More than one Template can be placed at the same resource address as long as they have different request contraints. In this case they are given different IDs. For example if two templates are configured to respond to request using different HTTP methods then they will not overwrite each other but both be stored.
+
+  Requirements can be specified as required when configuring a Template:
+  * request parameters
+  * body content
+  * HTTP Headers
+  * HTTP Method
+
+  The following attributes of a response can be configured
+  * HTTP status code
+  * Whether this template is to be treated as the default response if a match is not found for a sub URI
+  * A delay before the response is returned to the client. This is in seconds and floats are accepted
+  * Content-Type
+
+  Things to note:
+  ---------------
+  The body attribute of the response should be Base64 encoded. This is so that you may specify binary data if that is what you would like to send back to clients.
+
+
+  Scenario: Setting a Template on Mirage
+    Given the following Template JSON:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"get",
+            "headers": {},
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"SGVsbG8=",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    When the template is sent using PUT to '/templates/greeting'
+    Then '{"id":1}' should be returned
+
+    When GET is sent to '/responses/greeting'
+    Then 'Hello' should be returned
+    And a 200 should be returned
+
+
+  Scenario: Template defaults
+    Given the following Template JSON:
+    """
+    {}
+    """
+    When the template is sent using PUT to '/templates/greeting'
+    Then the template request specification should have the following set:
+      | Setting      | Default |
+      | parameters   | none    |
+      | body content | none    |
+      | headers      | none    |
+      | HTTP method  | GET     |
+    And the template response specification should have the following set:
+      | Setting      | Default    |
+      | default      | false      |
+      | body         | none       |
+      | content_type | text/plain |
+      | delay        | 0          |
+      | status       | 200        |
+
+  Scenario: Making a request that is unmatched
+    When GET is sent to '/responses/unmatched'
+    Then a 404 should be returned
+

data/features/templates/put_with_substitutions.feature

@@ -0,0 +1,22 @@
+Feature: Substituting values from requests in to a template
+  Parts of a response can be substituted for values found in the request body or query string.
+  This allows dynamic content to be sent back to a client.
+
+  To do this, substitution, matchers must be put in the the response value.
+
+  Either a string literal or a regex can be used in between ${} to find a match
+
+  Scenario: A response template populated from matches found in the request body using a regex
+    Given the following template template:
+    """
+      {
+         "response":{
+            "body":"Hello ${name}"
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/greeting'
+    When I send GET to '/responses/greeting' with parameters:
+      |name|Joe  |
+    Then 'Hello Joe' should be returned

data/features/templates/readme.md

@@ -0,0 +1,4 @@
+Templates are the descriptors pushed to Mirage to tell it what to return to a client.
+
+They can be configured to place restrictions on the requests that should be met before they are allowed to be used to generate a response.
+

data/features/templates/required_content.feature

@@ -0,0 +1,113 @@
+Feature: Placing requirements on requests
+  If you want Mirage to be choosy when using a Template to generate a response the following can have requirements placed on them when looking for a suitable to Template to generate responses:
+
+  * request parameters
+  * body content
+  * HTTP Headers
+  * HTTP Method
+
+  When specifying requirements on Headers, request parameters or the body of a request either a litteral string
+  or a regular expression can be used for matching.
+
+  Background: There is already a default response for 'greeting'
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"get",
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Stranger",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/greeting'
+
+  Scenario: Configuring a template with requirements on HTTP headers
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"get",
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Stranger",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/greeting'
+
+
+  Scenario: Configuring a template with requirements on request parameters
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{
+                "firstname" : "%r\{.*e}",
+                "surname"   : "Blogs"
+            },
+            "http_method":"get",
+            "body_content":[]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Joe",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/greeting'
+
+    When I send GET to '/responses/greeting' with parameters:
+    |firstname|Joe  |
+    |surname  |Blogs|
+    Then 'Hello Joe' should be returned
+
+  Scenario: Configuring a template with requirements on the body
+    Given the following template template:
+    """
+      {
+         "request":{
+            "parameters":{},
+            "http_method":"POST",
+            "body_content":["Joe", "%r{B..gs}"]
+         },
+         "response":{
+            "default":false,
+            "body":"Hello Joe",
+            "delay":0,
+            "content_type":"text/plain",
+            "status":200
+         }
+      }
+    """
+    And 'response.body' is base64 encoded
+    And the template is sent using PUT to '/templates/greeting'
+
+    When I send POST to '/responses/greeting' with request entity
+    """
+    {"username":"Joe Blogs"}
+    """
+    Then 'Hello Joe' should be returned
+
+
+    
+      

data/features/web_user_interface.feature

@@ -0,0 +1,44 @@
+Feature: Web interface
+  Note: This feature is being rewritten but the screens pretty basic so take a look:
+
+  The home page is served from '/' so by default is found at http://localhost:7001/
+
+  Mirage's home page allows you to see what response are currently being hosted.
+  From this page you can:
+  - See all currently hosted templates
+  - Preview at a Templates content
+  - View the last request to trigger a particular Template
+
+
+#  Background: There are already a couple of responses hosted on he Mirage server
+#    Given the following template template:
+#    """
+#      {
+#         "response":{
+#            "body":"SGVsbG8="
+#         },
+#         "request":{
+#         }
+#      }
+#    """
+#    And the template is sent using PUT to '/templates/greeting'
+#
+#
+#  Scenario: Using the home page to see what response are being hosted
+#    Given I goto to the Mirage home page
+#    Then I should see 'greeting/*'
+#    Then I should see 'leaving'
+#
+#  Scenario: Using the home page to peek at a response
+#    Given I goto ''
+#    When  I click 'peek_response_1'
+#    Then I should see 'hello'
+#
+#  Scenario: Using the home page to track if a request has been made
+#    Given I send POST to '/responses/greeting' with request entity
+#    """
+#    Yo!
+#    """
+#    Given I goto ''
+#    When  I click 'track_response_1'
+#    Then I should see 'Yo!'

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-p378'
+    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/mirage/client.rb

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

data/lib/mirage/client/cli_bridge.rb

@@ -0,0 +1,30 @@
+module Mirage
+module CLIBridge
+  def mirage_process_ids ports
+    mirage_instances = {}
+    ["Mirage Server", "mirage_server", "mirage server"].each do |process_name|
+      processes_with_name(process_name).each_line.collect { |line| line.chomp }.each do |process_line|
+        pid = process_line.split(' ')[1]
+        port = process_line[/port (\d+)/, 1]
+        mirage_instances[port] = pid
+      end
+    end
+
+    return mirage_instances if ports.first.to_s == "all" || ports.empty?
+    Hash[mirage_instances.find_all { |port, pid| ports.include?(port.to_i) }]
+  end
+
+  def kill pid
+    ChildProcess.windows? ? `taskkill /F /T /PID #{pid}` : `kill -9 #{pid}`
+  end
+
+  def processes_with_name name
+    if ChildProcess.windows?
+      `tasklist /V | findstr "#{name.gsub(" ", '\\ ')}"`
+    else
+      IO.popen("ps aux | grep '#{name}' | grep -v grep | grep -v #{$$}")
+    end
+  end
+
+end
+end

data/lib/mirage/client/client.rb

@@ -0,0 +1,73 @@
+require 'uri'
+require 'httparty'
+require 'base64'
+require 'json'
+
+module Mirage
+  class Client
+    include HTTParty
+
+    attr_reader :url
+
+    def initialize options={:url => "http://localhost:7001"}, &block
+      if options.is_a?(String) && options =~ URI.regexp
+        @url = options
+      elsif options.kind_of?(Hash) && options[:port]
+        @url = "http://localhost:#{options[:port]}"
+      elsif options.kind_of?(Hash) && options[:url]
+        @url = options[:url]
+      else
+        raise "specify a valid URL or port"
+      end
+
+      @templates = Templates.new(@url)
+      @templates.default_config &block if block
+    end
+
+    def configure &block
+      templates.default_config &block if block
+    end
+
+    def reset
+      templates.default_config.reset
+    end
+
+    def templates id=nil
+      return Template.get("#{@url}/templates/#{id}") if id
+      @templates
+    end
+
+    def requests id=nil
+      return Request.get "#{@url}/requests/#{id}" if id
+      Requests.new(@url)
+    end
+
+    def prime
+      self.class.send(:put, "#{@url}/defaults", :body => "")
+    end
+
+    def save
+      self.class.send(:put, "#{@url}/backup", :body => "")
+    end
+
+    def revert
+      self.class.send(:put, @url, :body => "")
+    end
+
+    def put *args, &block
+      templates.put *args, &block
+    end
+
+    def clear
+      templates.delete_all
+    end
+
+    def == client
+      client.instance_of?(Client) && self.url == client.url
+    end
+
+    def running?
+      Mirage.running? @url
+    end
+  end
+end