mirage 2.2.3 → 2.3.0

data/lib/mirage/client.rb

@@ -1,208 +1,6 @@
 $LOAD_PATH.unshift "#{File.dirname(__FILE__)}"
-require 'uri'
-require 'waitforit'
-require 'childprocess'
 require 'client/web'
-require 'cli'
-require 'ostruct'
-require 'optparse'
-
-module Mirage
-
-  class << self
-
-    def start args={}
-      puts "Starting Mirage"
-      args = convert_to_command_line_argument_array(args) if args.is_a? Hash
-
-      Mirage::CLI.run args
-      mirage_client = Mirage::Client.new "http://localhost:#{Mirage::CLI.parse_options(args)[: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
-
-    def stop
-      puts "Stopping Mirage"
-      Mirage::CLI.stop
-    end
-
-    private
-    def convert_to_command_line_argument_array(args)
-      command_line_arguments = {}
-      args.each do |key, value|
-        command_line_arguments["--#{key}"] = "#{value}"
-      end
-      command_line_arguments.to_a.flatten
-    end
-  end
-
-  class MirageError < ::Exception
-    attr_reader :code
-
-    def initialize message, code
-      super message
-      @code = message, code
-    end
-  end
-
-  class Response < OpenStruct
-
-    attr_accessor :content_type
-    attr_reader :value
-
-    def initialize response
-      @content_type = 'text/plain'
-      @value = response
-      super({})
-    end
-
-    def headers
-      headers = {}
-
-      @table.each { |header, value| headers["X-mirage-#{header.to_s.gsub('_', '-')}"] = value }
-      headers['Content-Type']=@content_type
-      headers['X-mirage-file'] = 'true' if @response.kind_of?(IO)
-
-      headers
-    end
-
-  end
-
-  class InternalServerException < MirageError;
-  end
-
-  class ResponseNotFound < MirageError;
-  end
-
-  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
-
-
-    # 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 = Response.new response_value
-
-      yield response if block_given?
-
-      build_response(http_put("#{@url}/templates/#{endpoint}", response.value, response.headers))
-    end
-
-    # Use to look at what a response contains without actually triggering it.
-    # 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
-    #
-    #   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 :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:
-    #   Client.new.track(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 up and running
-    def running?
-      begin
-        http_get(@url) and return true
-      rescue Errno::ECONNREFUSED
-        return false
-      end
-    end
-
-    # Clear down the Mirage Server and load any defaults that are in Mirages default responses directory.
-    def prime
-      puts "#{@url}/defaults"
-      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
+require 'client/error'
+require 'client/runner'
+require 'client/response'
+require 'client/client'

data/mirage.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "mirage"
-  s.version = "2.2.3"
+  s.version = "2.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Leon Davis"]
-  s.date = "2012-07-15"
+  s.date = "2012-08-26"
   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 = [
@@ -24,13 +24,16 @@ Gem::Specification.new do |s|
     "VERSION",
     "bin/mirage",
     "features/client/clear.feature",
-    "features/client/command_line_interface.feature",
-    "features/client/mirage_client.feature",
+    "features/client/preview_responses.feature",
     "features/client/put.feature",
-    "features/client/request.feature",
-    "features/client/response.feature",
+    "features/client/requests.feature",
+    "features/client/running.feature",
     "features/client/save_and_revert.feature",
-    "features/server/command_line_iterface.feature",
+    "features/client/start.feature",
+    "features/client/stop.feature",
+    "features/server/commandline_interface/help.feature",
+    "features/server/commandline_interface/start.feature",
+    "features/server/commandline_interface/stop.feature",
     "features/server/logging.feature",
     "features/server/prime.feature",
     "features/server/requests/delete.feature",
@@ -45,10 +48,16 @@ Gem::Specification.new do |s|
     "features/server/templates/put/put_with_substitutions.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",
     "full_build.sh",
-    "lib/mirage/cli.rb",
     "lib/mirage/client.rb",
+    "lib/mirage/client/client.rb",
+    "lib/mirage/client/error.rb",
+    "lib/mirage/client/response.rb",
+    "lib/mirage/client/runner.rb",
     "lib/mirage/client/web.rb",
     "mirage.gemspec",
     "mirage_server.rb",
@@ -57,6 +66,8 @@ Gem::Specification.new do |s|
     "server/extensions/hash.rb",
     "server/extensions/object.rb",
     "server/mock_response.rb",
+    "spec/running_via_api_spec.rb",
+    "spec/running_via_api_windows_spec.rb",
     "test.rb",
     "views/index.erb"
   ]
@@ -72,8 +83,10 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<sinatra>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, ["= 1.0.0.rc.4"])
       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_development_dependency(%q<rake>, [">= 0"])
       s.add_development_dependency(%q<cucumber>, [">= 0"])
@@ -85,8 +98,10 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
     else
       s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, ["= 1.0.0.rc.4"])
       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<rake>, [">= 0"])
       s.add_dependency(%q<cucumber>, [">= 0"])
@@ -99,8 +114,10 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, ["= 1.0.0.rc.4"])
     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<rake>, [">= 0"])
     s.add_dependency(%q<cucumber>, [">= 0"])

data/mirage_server.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-$0='Mirage Server'
 ROOT_DIR = File.dirname(__FILE__)
 $LOAD_PATH.unshift("#{ROOT_DIR}/lib")
 $LOAD_PATH.unshift("#{ROOT_DIR}/server")
@@ -17,9 +16,10 @@ module Mirage
   class Server < Sinatra::Base
 
     configure do
-      options = Mirage::CLI.parse_options(ARGV)
-      set :defaults, options[:defaults]
-      set :port, options[:port]
+      options = Hash[*ARGV]
+      set :defaults, options["defaults"]
+      set :port, options["port"]
+      $0="Mirage Server port #{settings.port}"
       set :show_exceptions, false
       set :logging, true
       set :dump_errors, true
@@ -109,12 +109,13 @@ module Mirage
 
     put '/mirage/defaults' do
       MockResponse.delete_all
-
-      Dir["#{settings.defaults}/**/*.rb"].each do |default|
-        begin
-          eval File.read(default)
-        rescue Exception => e
-          raise "Unable to load default responses from: #{default}"
+      if File.directory?(settings.defaults.to_s)
+        Dir["#{settings.defaults}/**/*.rb"].each do |default|
+          begin
+            eval File.read(default)
+          rescue Exception => e
+            raise "Unable to load default responses from: #{default}"
+          end
         end
       end
       200
@@ -131,6 +132,10 @@ module Mirage
       200
     end
 
+    get '/mirage/pid' do
+      "#{$$}"
+    end
+
     error ServerResponseNotFound do
       404
     end

data/rakefile

@@ -1,6 +1,7 @@
 $LOAD_PATH.unshift('lib')
 require 'rubygems'
 require 'bundler'
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
@@ -10,6 +11,9 @@ rescue Bundler::BundlerError => e
 end
 
 require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
 
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
@@ -59,4 +63,6 @@ task :stop do
 end
 
 
-task :default => [:install,:features,:clean]
+
+
+task :default => [:spec, :install,:features,:clean]

data/spec/running_via_api_spec.rb

@@ -0,0 +1,147 @@
+$LOAD_PATH.unshift "../lib"
+require 'rspec'
+require 'mirage/client'
+
+def process_string_for_mirage(mirage_port, pid)
+  "team     #{pid}  6.2  0.4  84328 20760 pts/1    Sl   22:15   0:00 Mirage Server port #{mirage_port}"
+end
+
+include Mirage
+
+unless ChildProcess.windows?
+  describe Mirage do
+
+    describe 'starting' do
+      before(:each) do
+        @runner = mock
+        Runner.should_receive(:new).and_return(@runner)
+      end
+
+      it 'should start Mirage on port 7001 by default' do
+        @runner.should_receive(:invoke).with(:start, [], {:port => 7001})
+        Mirage.start
+      end
+
+      it 'should start mirage on the given port' do
+        options = {:port => 9001}
+        @runner.should_receive(:invoke).with(:start, [], options)
+        Mirage.start options
+      end
+    end
+
+    describe 'stopping' do
+      before(:each) do
+        @runner = mock
+        Runner.stub(:new).and_return(@runner)
+      end
+
+      it 'should supply single port argument in an array to the runner' do
+        port = 7001
+        @runner.should_receive(:invoke).with(:stop, [], :port => [port])
+        @runner.should_receive(:invoke).with(:stop, [], :port => [:all])
+        Mirage.stop(:port => port)
+        Mirage.stop(:all)
+      end
+
+      it 'should stop multiple instances of Mirage' do
+        ports = 7001, 7002
+        @runner.should_receive(:invoke).with(:stop, [], :port => ports)
+        Mirage.stop(:port => ports)
+      end
+
+    end
+
+    describe Mirage::Runner do
+      it 'should stop the running instance of Mirage' do
+        IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(process_string_for_mirage(7001, 18903))
+
+        IO.should_receive(:popen).with("kill -9 18903") do
+          IO.rspec_reset
+          IO.stub(:popen).and_return("")
+        end
+        Mirage::Runner.new.stop
+      end
+
+      it 'should not stop any instances when more than one is running' do
+        ps_aux_output =<<PS
+#{process_string_for_mirage(7001, 18901)}
+        #{process_string_for_mirage(7002, 18902)}
+        #{process_string_for_mirage(7003, 18903)}
+PS
+        IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
+        IO.should_not_receive(:popen).with(/kill.*/)
+
+        lambda { Mirage::Runner.new.stop }.should raise_error(Mirage::ClientError)
+
+      end
+
+
+      it 'should stop the instance running on the given port' do
+        ps_aux_output =<<PS
+#{process_string_for_mirage(7001, 18901)}
+        #{process_string_for_mirage(7002, 18902)}
+PS
+        IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
+        IO.should_receive(:popen).with(/kill -9 18901/) do
+          IO.rspec_reset
+          IO.stub(:popen).and_return(process_string_for_mirage(7002, 18902))
+        end
+
+        Mirage::Runner.new.invoke(:stop, [], {:port => [7001]})
+      end
+
+      it 'should stop the instance running on the given ports' do
+        ps_aux_output =<<PS
+#{process_string_for_mirage(7001, 18901)}
+        #{process_string_for_mirage(7002, 18902)}
+        #{process_string_for_mirage(7003, 18903)}
+PS
+        IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
+        IO.should_receive(:popen).with(/kill -9 18901/)
+        IO.should_receive(:popen).with(/kill -9 18902/) do
+          IO.rspec_reset
+          IO.stub(:popen).and_return(process_string_for_mirage("7003", 18903))
+        end
+
+        Mirage::Runner.new.invoke(:stop, [], {:port => [7001, 7002]})
+      end
+
+      it 'should stop all running instances' do
+        ps_aux_output =<<PS
+#{process_string_for_mirage(7001, 18901)}
+        #{process_string_for_mirage(7002, 18902)}
+        #{process_string_for_mirage(7003, 18903)}
+PS
+        IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
+        IO.should_receive(:popen).with(/kill -9 18901/)
+        IO.should_receive(:popen).with(/kill -9 18902/)
+        IO.should_receive(:popen).with(/kill -9 18903/) do
+          IO.rspec_reset
+          IO.stub(:popen).and_return("")
+        end
+
+        Mirage::Runner.new.invoke(:stop, [], {:port => [:all]})
+
+      end
+
+      it 'should not error when asked to stop Mirage on a port that it is not running on' do
+        ps_aux_output =<<PS
+#{process_string_for_mirage(7001, 18901)}
+PS
+        IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
+        IO.should_not_receive(:popen).with(/kill -9 18901/)
+        lambda { Mirage::Runner.new.invoke(:stop, [], {:port => [7002]}) }.should_not raise_error(Mirage::ClientError)
+      end
+
+#  it 'should not start mirage on the same port' do
+#    ps_aux_output =<<PS
+##{process_string_for_mirage(7001, 18901)}
+#PS
+#    IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
+#    lambda{Mirage::Runner.new.invoke(:start, [], {:port => 7001})}.should raise_error(Mirage::ClientError)
+#  end
+
+
+    end
+  end
+end