mirage 2.2.3 → 2.3.0

data/features/support/env.rb

@@ -1,5 +1,8 @@
-$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../../lib")
-$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../../server")
+ROOT_DIR = File.expand_path("#{File.dirname(__FILE__)}/../..")
+SOURCE_PATH = "#{ROOT_DIR}/lib"
+
+
+$LOAD_PATH.unshift(SOURCE_PATH)
 require 'rubygems'
 require 'mirage/client'
 require 'cucumber'
@@ -7,130 +10,17 @@ require 'rspec'
 require 'mechanize'
 require 'childprocess'
 
-ENV['RUBYOPT'] =''
-
-module OsSupport
-  def windows?
-    ENV['OS'] == 'Windows_NT'
-  end
-end
-World OsSupport
-include OsSupport
-
-SCRATCH = './scratch'
-RUBY_CMD = RUBY_PLATFORM == 'JAVA' ? 'jruby' : 'ruby'
+SCRATCH = "#{ROOT_DIR}/scratch"
+RUBY_CMD = ChildProcess.jruby? ? 'jruby' : 'ruby'
+BLANK_RUBYOPT_CMD = ChildProcess.windows? ? 'set RUBYOPT=' : "export RUBYOPT=''"
+ENV['RUBYOPT'] = ''
 
 
-BLANK_RUBYOPT_CMD = windows? ? 'set RUBYOPT=' : "export RUBYOPT=''"
-
 if 'regression' == ENV['mode']
-  MIRAGE_CMD = windows? ? `where mirage.bat`.chomp : 'mirage'
+  MIRAGE_CMD = ChildProcess.windows? ? `where mirage.bat`.chomp : 'mirage'
 else
   MIRAGE_CMD = "#{RUBY_CMD} ../bin/mirage"
 end
 
+World(Mirage::Web)
 
-
-module CommandLine
-  COMAND_LINE_OUTPUT_PATH = "#{File.dirname(__FILE__)}/../../#{SCRATCH}/commandline_output.txt"
-  module Windows
-    def run command
-      command = "#{MIRAGE_CMD} #{command.split(' ').drop(1).join(' ')}" if command =~ /^mirage/
-      command = "#{command} > #{COMAND_LINE_OUTPUT_PATH}"
-      Dir.chdir(SCRATCH)
-      `#{BLANK_RUBYOPT_CMD}`
-      process = ChildProcess.build(*(command.split(' ')))
-      process.start
-      sleep 0.5 until process.exited?
-      Dir.chdir('../')
-      File.read(COMAND_LINE_OUTPUT_PATH)
-    end
-  end
-
-  module Linux
-    def run command
-      `#{BLANK_RUBYOPT_CMD} && cd #{SCRATCH} && #{command}`
-    end
-  end
-end
-
-
-module Web
-  include Mirage::Web
-
-  def normalise text
-    text.gsub(/[\n]/, ' ').gsub(/\s+/, ' ')
-  end
-end
-
-
-module Regression
-  include CommandLine
-
-  def run command
-    execute(command)
-  end
-end
-
-module Mirage
-  module Runner
-    def stop_mirage
-      system "cd #{SCRATCH} && #{MIRAGE_CMD} stop"
-    end
-
-    def start_mirage
-      if windows?
-
-        puts "starting mirage"
-        Dir.chdir(SCRATCH)
-        process = ChildProcess.build(MIRAGE_CMD, "start")
-        process.start
-        sleep 0.5 until process.exited?
-        Dir.chdir '../'
-        puts "finished starting mirage"
-      else
-        system "cd #{SCRATCH} && #{MIRAGE_CMD} start"
-      end
-    end
-  end
-end
-
-
-module IntelliJ
-  include CommandLine
-  def run command
-    execute "#{RUBY_CMD} #{command}"
-  end
-end
-
-include Mirage::Runner
-
-World(Web)
-World(Mirage::Runner)
-windows? ? World(CommandLine::Windows) : World(CommandLine::Linux)
-
-
-
-Before do
-  FileUtils.mkdir_p(SCRATCH)
-  $mirage = Mirage::Client.new
-  if $mirage.running?
-    $mirage.clear
-  else
-    start_mirage
-  end
-
-  Dir["#{SCRATCH}/*"].each do |file|
-    FileUtils.rm_rf(file) unless file == "#{SCRATCH}/mirage.log"
-  end
-
-  if File.exists? "#{SCRATCH}/mirage.log"
-    @mirage_log_file = File.open("#{SCRATCH}/mirage.log")
-    @mirage_log_file.seek(0, IO::SEEK_END)
-  end
-end
-
-
-at_exit do
-  stop_mirage if $mirage.running?
-end

data/features/support/hooks.rb

@@ -0,0 +1,30 @@
+Before do
+  FileUtils.mkdir_p(SCRATCH)
+
+  if Mirage.running?
+    $mirage.clear
+  else
+    $mirage = start_mirage_in_scratch_dir
+  end
+
+  Dir["#{SCRATCH}/*"].each do |file|
+    FileUtils.rm_rf(file) unless file == "#{SCRATCH}/mirage.log"
+  end
+
+  if File.exists? "#{SCRATCH}/mirage.log"
+    @mirage_log_file = File.open("#{SCRATCH}/mirage.log")
+    @mirage_log_file.seek(0, IO::SEEK_END)
+  end
+end
+
+Before ('@command_line') do
+  Mirage.stop :all
+end
+
+After('@command_line') do
+  Mirage.stop :all
+end
+
+at_exit do
+  Mirage.stop :all
+end

data/features/support/mirage.rb

@@ -0,0 +1,8 @@
+module Mirage
+  def start_mirage_in_scratch_dir
+    Dir.chdir SCRATCH do
+      Mirage.start
+    end
+  end
+end
+include Mirage

data/lib/mirage/client/client.rb

@@ -0,0 +1,124 @@
+require 'uri'
+module Mirage
+  class Client
+    include Mirage::Web
+    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.
+    def initialize url="http://localhost:7001/mirage"
+      @url = url
+    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
+
+      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
+
+    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
+
+    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}"))
+    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
+    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
+    end
+
+
+    # Check to see if mirage is running on the url that the client is pointing to
+    def running?
+      Mirage.running?(@url)
+    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", ''))
+    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
+    end
+  end
+end

data/lib/mirage/client/error.rb

@@ -0,0 +1,22 @@
+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 ClientError < ::Exception
+    def initialize message
+      super message
+    end
+  end
+end

data/lib/mirage/client/response.rb

@@ -0,0 +1,29 @@
+require 'ostruct'
+module Mirage
+  class Response
+
+    attr_accessor :content_type,:method, :response_code, :pattern, :default, :status, :delay
+    attr_reader :value
+
+    def initialize response
+      @content_type = 'text/plain'
+      @value = response
+      @method = :get
+      @status = 200
+      @delay = 0
+    end
+
+    def headers
+      headers = {}
+      headers['Content-Type']=@content_type
+      headers['X-mirage-file'] = 'true' if @response.kind_of?(IO)
+      headers['X-mirage-method'] = @method
+      headers['X-mirage-pattern'] = @pattern if @pattern
+      headers['X-mirage-default'] = @default if @default == true
+      headers['X-mirage-status'] = @status
+      headers['X-mirage-delay'] = @delay
+      headers
+    end
+
+  end
+end

data/lib/mirage/client/runner.rb

@@ -0,0 +1,142 @@
+require 'thor'
+require 'waitforit'
+require 'childprocess'
+require 'uri'
+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}
+      Runner.new.invoke(:start, [], options)
+    end
+
+    # Stop locally running instance(s) of Mirage
+    #
+    # Example Usage:
+    #   Mirage.stop -> Will stop mirage if there is only instance running. Can be running on any port.
+    #   Mirage.stop :port => port -> stop mirage on a given port
+    #   Mirage.stop :port => [port1, port2...] -> stops multiple running instances of Mirage
+    def stop options={}
+      options = {:port => :all} if options == :all
+
+      if options[:port]
+        options[:port] = [options[:port]] unless options[:port].is_a?(Array)
+      end
+
+      Runner.new.invoke(:stop, [], options)
+    rescue ClientError => e
+      raise ClientError.new("Mirage is running multiple ports, please specify the port(s) see api/tests for details")
+    end
+
+
+    # Detect if Mirage is running on a URL or a local port
+    #
+    # Example Usage:
+    #   Mirage.running? -> boolean indicating whether Mirage is running on *locally* on port 7001
+    #   Mirage.running? :port => port -> boolean indicating whether Mirage is running on *locally* on the given port
+    #   Mirage.running? url -> boolean indicating whether Mirage is running on the given URL
+    def running? options_or_url = {:port => 7001}
+      url = options_or_url.is_a?(Hash) ? "http://localhost:#{options_or_url[:port]}/mirage" : options_or_url
+      http_get(url) and return true
+    rescue Errno::ECONNREFUSED
+      return false
+    end
+
+  end
+
+  class Runner < Thor
+    include ::Mirage::Web
+    RUBY_CMD = ChildProcess.jruby? ? 'jruby' : 'ruby'
+
+    desc "start", "Starts mirage"
+    method_option :port, :aliases => "-p", :type => :numeric, :default => 7001, :desc => "port that mirage should be started on"
+    method_option :defaults, :aliases => "-d", :type => :string, :default => 'responses', :desc => "location to load default responses from"
+    method_option :debug, :type => :boolean, :default => false, :desc => "run in debug mode"
+
+    def start
+      unless mirage_process_ids([options[:port]]).empty?
+        puts "Mirage is already running: #{mirage_process_ids([options[:port]]).values.join(",")}"
+        return
+      end
+
+      mirage_server_file = "#{File.dirname(__FILE__)}/../../../mirage_server.rb"
+
+      if ChildProcess.windows?
+        command = ["cmd", "/C", "start", "mirage server port #{options[:port]}", RUBY_CMD, mirage_server_file]
+      else
+        command = [RUBY_CMD, mirage_server_file]
+      end
+
+
+      command = command.concat(options.to_a).flatten.collect { |arg| arg.to_s }
+      ChildProcess.build(*command).start
+
+      mirage_client = Mirage::Client.new "http://localhost:#{options[:port]}/mirage"
+      wait_until(:timeout_after => 30.seconds) { mirage_client.running? }
+
+      begin
+        mirage_client.prime
+      rescue Mirage::InternalServerException => e
+        puts "WARN: #{e.message}"
+      end
+      mirage_client
+    end
+
+    desc "stop", "Stops mirage"
+    method_option :port, :aliases => "-p", :type => :array, :banner => "[port_1 port_2|all]", :desc => "port(s) of mirage instance(s). ALL stops all running instances"
+
+    def stop
+      ports = options[:port] || []
+      if  ports.empty?
+        mirage_process_ids = mirage_process_ids([:all])
+        raise ClientError.new("Mirage is running on ports #{mirage_process_ids.keys.sort.join(", ")}. Please run mirage stop -p [PORT(s)] instead") if mirage_process_ids.size > 1
+      end
+
+      ports = case ports
+                when %w(all), [:all], []
+                  [:all]
+                else
+                  ports.collect { |port| port.to_i }
+              end
+
+      mirage_process_ids(ports).values.each do |process_id|
+        ChildProcess.windows? ? `taskkill /F /T /PID #{process_id}` : IO.popen("kill -9 #{process_id}")
+      end
+
+      wait_until do
+        mirage_process_ids(ports).empty?
+      end
+    end
+
+    private
+
+    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
+
+    def mirage_process_ids *ports
+      ports.flatten!
+      mirage_instances = {}
+      ["Mirage Server", "mirage_server", "mirage server"].each do |process_name|
+        processes_with_name(process_name).lines.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.downcase == "all"
+      Hash[mirage_instances.find_all { |port, pid| ports.include?(port.to_i) }]
+    end
+
+  end
+end