mirage 2.4.2 → 3.0.0.alpha.1

data/server/server.rb

@@ -0,0 +1,167 @@
+require 'sinatra'
+require 'helpers'
+require 'base64'
+module Mirage
+
+  class Server < Sinatra::Base
+
+    REQUESTS = {}
+
+
+    helpers Mirage::Server::Helpers
+
+    put '/mirage/templates/*' do |name|
+      content_type :json
+      mock_response = MockResponse.new(name, JSON.parse(request.body.read))
+      mock_response.requests_url = request.url.gsub("/mirage/templates/#{name}", "/mirage/requests/#{mock_response.response_id}")
+      {:id => mock_response.response_id}.to_json
+    end
+
+    %w(get post delete put).each do |http_method|
+      send(http_method, '/mirage/responses/*') do |name|
+        body, query_string = Rack::Utils.unescape(request.body.read.to_s), request.query_string
+
+        options = {:body => body,
+                   :http_method => http_method,
+                   :endpoint => name,
+                   :params => request.params,
+                   :headers => extract_http_headers(env)}
+        begin
+          record = MockResponse.find(options)
+        rescue ServerResponseNotFound
+          record = MockResponse.find_default(options)
+        end
+
+        REQUESTS[record.response_id] = request.dup
+
+        send_response(record, body, request, query_string)
+      end
+    end
+
+    delete '/mirage/templates/:id' do
+      MockResponse.delete(response_id)
+      REQUESTS.delete(response_id)
+      200
+    end
+
+    delete '/mirage/requests' do
+      REQUESTS.clear
+      200
+    end
+
+    delete '/mirage/requests/:id' do
+      REQUESTS.delete(response_id)
+      200
+    end
+
+    delete '/mirage/templates' do
+      REQUESTS.clear
+      MockResponse.delete_all
+      200
+    end
+
+    get '/mirage/templates/:id' do
+      MockResponse.find_by_id(response_id).raw
+    end
+
+    get '/mirage/requests/:id' do
+      content_type :json
+      tracked_request = REQUESTS[response_id]
+      if tracked_request
+
+        tracked_request.body.rewind
+        body = tracked_request.body.read
+
+        parameters = tracked_request.params.dup.select{|key, value| key != body}
+
+        { request_url: request.url,
+          headers: extract_http_headers(tracked_request.env),
+          parameters: parameters,
+          body: body}.to_json
+
+      else
+        404
+      end
+    end
+
+    get '/mirage' do
+      haml :index
+    end
+
+
+    put '/mirage/defaults' do
+      MockResponse.delete_all
+      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
+    end
+#
+    put '/mirage/backup' do
+      MockResponse.backup
+      200
+    end
+
+
+    put '/mirage' do
+      MockResponse.revert
+      200
+    end
+
+    get '/mirage/pid' do
+      "#{$$}"
+    end
+
+    error ServerResponseNotFound do
+      404
+    end
+
+    error do
+      erb request.env['sinatra.error'].message
+    end
+
+    helpers do
+
+      def response_id
+        params[:id].to_i
+      end
+
+      def prime &block
+        block.call Mirage::Client.new "http://localhost:#{settings.port}/mirage"
+      end
+
+      def send_response(response, body='', request={}, query_string='')
+        sleep response.response_spec['delay']
+        content_type(response.response_spec['content_type'])
+        status response.response_spec['status']
+        response.value(body, request, query_string)
+      end
+
+      def extract_http_headers(env)
+        headers = env.reject do |k, v|
+          !(/^HTTP_[A-Z_]+$/ === k) || v.nil?
+        end.map do |k, v|
+          [reconstruct_header_name(k), v]
+        end.inject(Rack::Utils::HeaderHash.new) do |hash, k_v|
+          k, v = k_v
+          hash[k] = v
+          hash
+        end
+
+        x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
+
+        headers.merge!("X-Forwarded-For" => x_forwarded_for)
+      end
+
+      def reconstruct_header_name(name)
+        name.sub(/^HTTP_/, "").gsub("_", "-")
+      end
+    end
+  end
+end

data/spec/{cli_bridge_spec.rb → client/cli_bridge_spec.rb}

@@ -3,7 +3,11 @@ require 'mirage/client'
 
 describe Mirage::CLIBridge do
 
-  include Mirage::CLIBridge
+
+  before :each do
+    @bridge = Object.new
+    @bridge.extend(Mirage::CLIBridge)
+  end
 
   describe 'Windows' do
 
@@ -15,8 +19,8 @@ describe Mirage::CLIBridge do
       #{process_string_for_mirage(7002, 18904)}
       #{process_string_for_mirage(7003, 18905)}"
 
-      self.should_receive(:`).with(/tasklist.*/).any_number_of_times.and_return(tasklist_output)
-      mirage_process_ids([7001, 7002]).should == {"7001" => "18903", "7002" => "18904"}
+      @bridge.should_receive(:`).with(/tasklist.*/).any_number_of_times.and_return(tasklist_output)
+      @bridge.mirage_process_ids([7001, 7002]).should == {"7001" => "18903", "7002" => "18904"}
     end
 
     it 'should find the pids of mirage instances for all ports' do
@@ -24,13 +28,13 @@ describe Mirage::CLIBridge do
       #{process_string_for_mirage(7002, 18904)}
       #{process_string_for_mirage(7003, 18905)}"
 
-      self.should_receive(:`).with(/tasklist.*/).any_number_of_times.and_return(tasklist_output)
-      mirage_process_ids([:all]).should == {"7001" => "18903", "7002" => "18904", "7003" => "18905"}
+      @bridge.should_receive(:`).with(/tasklist.*/).any_number_of_times.and_return(tasklist_output)
+      @bridge.mirage_process_ids([:all]).should == {"7001" => "18903", "7002" => "18904", "7003" => "18905"}
     end
 
     it 'should kill the given process id' do
-      self.should_receive(:`).with(/taskkill \/F \/T \/PID 18903/)
-      kill(18903)
+      @bridge.should_receive(:`).with(/taskkill \/F \/T \/PID 18903/)
+      @bridge.kill(18903)
     end
   end
 
@@ -44,7 +48,7 @@ describe Mirage::CLIBridge do
       #{process_string_for_mirage(7003, 18905)}"
 
       IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
-      mirage_process_ids([7001, 7002]).should == {"7001" => "18903", "7002" => "18904"}
+      @bridge.mirage_process_ids([7001, 7002]).should == {"7001" => "18903", "7002" => "18904"}
     end
 
     it 'should find the pids of mirage instances for all ports' do
@@ -53,12 +57,12 @@ describe Mirage::CLIBridge do
       #{process_string_for_mirage(7003, 18905)}"
 
       IO.should_receive(:popen).with(/ps aux.*/).any_number_of_times.and_return(ps_aux_output)
-      mirage_process_ids([:all]).should == {"7001" => "18903", "7002" => "18904", "7003" => "18905"}
+      @bridge.mirage_process_ids([:all]).should == {"7001" => "18903", "7002" => "18904", "7003" => "18905"}
     end
 
     it 'should kill the given process id' do
-      self.should_receive(:`).with(/kill -9 18903/)
-      kill(18903)
+      @bridge.should_receive(:`).with(/kill -9 18903/)
+      @bridge.kill(18903)
     end
   end
 end

data/spec/client/client_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'mirage/client'
+
+describe Mirage::Client do
+  Client = Mirage::Client
+  Templates = Mirage::Templates
+  Template = Mirage::Template
+  Requests = Mirage::Requests
+  Request = Mirage::Request
+
+  before :each do
+    @response = mock('response').as_null_object
+  end
+
+  describe 'configuration' do
+    it 'is configured to connect to local host port 7001 by default' do
+      Client.new.url.should == "http://localhost:7001/mirage"
+    end
+
+    it 'can be configured with a url pointing to Mirage' do
+      mirage_url = "http://url.for.mirage"
+      Client.new(mirage_url).url.should == mirage_url
+
+      Client.new(:url => mirage_url).url.should == mirage_url
+    end
+
+    it 'can be configured with a port refering to which port Mirage is running on on localhost' do
+      port = 9001
+      Client.new(:port => port).url.should == "http://localhost:#{port}/mirage"
+    end
+
+    it 'raises an error if neither a port or url specified in the argument' do
+      expect { Client.new({}) }.to raise_error()
+      expect { Client.new("rubbish") }.to raise_error()
+    end
+  end
+
+  it 'should clear mirage' do
+    templates_mock = mock('templates')
+    Templates.should_receive(:new).and_return(templates_mock)
+    templates_mock.should_receive(:delete_all)
+    Client.new.clear
+  end
+
+
+
+
+  it 'should prime mirage' do
+    Client.should_receive(:put) do |url|
+      url.should == "http://localhost:7001/mirage/defaults"
+    end
+    Client.new.prime
+  end
+
+  describe 'templates' do
+    it 'should give access to templates' do
+      mirage = Client.new
+      mirage.templates.instance_of?(Templates).should == true
+    end
+
+    it 'should find a template' do
+      id = 1
+      mirage = Client.new
+      mock_template = mock('template')
+      Template.should_receive(:get).with("#{mirage.url}/templates/#{id}").and_return(mock_template)
+      mirage.templates(1).should == mock_template
+    end
+
+    it 'should put a response on mirage' do
+      endpoint, value, block = 'greeting', 'hello', Proc.new{}
+
+      templates_mock = mock('templates')
+      Templates.should_receive(:new).and_return(templates_mock)
+
+      templates_mock.should_receive(:put).with(endpoint, value, &block)
+
+      mirage = Client.new
+      mirage.put endpoint, value, &block
+    end
+  end
+
+  describe 'requests' do
+    it 'should give access to requests' do
+      mirage = Client.new
+      mirage.requests.instance_of?(Requests).should == true
+    end
+
+    it 'should find a request' do
+      id = 1
+      mirage = Client.new
+      Request.should_receive(:get).with("#{mirage.url}/requests/#{id}")
+      mirage.requests(id)
+    end
+  end
+
+  #describe 'stop' do
+  #
+  #end
+
+  describe 'save' do
+    it 'should save the current template setup of mirage' do
+      mirage = Client.new
+      Client.should_receive(:put).with("#{mirage.url}/backup", :body => "")
+      mirage.save
+    end
+  end
+
+  describe 'revert' do
+    it 'should revert the current template set' do
+      mirage = Client.new
+      Client.should_receive(:put).with(mirage.url, :body => "")
+      mirage.revert
+    end
+  end
+
+
+  describe 'interface to mirage' do
+
+    after :each do
+      Mirage.stop
+    end
+
+    it 'should set a response' do
+      client = Mirage.start
+      response = client.templates.put("greeting", "hello")
+      response.id.should == 1
+    end
+
+    it 'should find mirage running' do
+      Mirage.start
+      Mirage.running?.should == true
+    end
+
+    it 'should not find mirage running' do
+      Mirage.running?.should == false
+    end
+
+  end
+end

data/spec/client/request_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'mirage/client'
+
+
+describe Mirage::Request do
+  Request = Mirage::Request
+
+  it 'delete a request' do
+    request_url = "url"
+    Request.should_receive(:delete).with(request_url)
+    request = Request.new
+    request.request_url = request_url
+    request.delete
+  end
+
+  it 'should load request data' do
+    request_url = "url"
+    trigger_url = "trigger url"
+
+    body = "body"
+    parameters = {"name" => "joe"}
+    headers = {"header" => "value"}
+
+    request_json = {
+        body: body,
+        headers: headers,
+        parameters: parameters,
+        request_url: trigger_url
+    }
+
+    Request.should_receive(:backedup_get).with(request_url,format: :json).and_return(request_json)
+
+    request = Request.get(request_url)
+    request.headers.should == headers
+    request.body.should == body
+    request.request_url.should == trigger_url
+    request.parameters.should == parameters
+  end
+
+  it 'should contain parameters' do
+
+  end
+
+  it 'should contain the request body' do
+
+  end
+
+  it 'should contain the triggering url' do
+
+  end
+
+end

data/spec/client/requests_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'mirage/client'
+
+describe 'Requests' do
+  it 'should delete all request data' do
+    base_url = "base_url"
+    Mirage::Requests.should_receive(:delete).with("#{base_url}/requests")
+    Mirage::Requests.new(base_url).delete_all
+  end
+end

data/spec/{runner_spec.rb → client/runner_spec.rb}

@@ -1,9 +1,9 @@
 require 'spec_helper'
 require 'mirage/client'
 
-include Mirage
 
 describe Mirage do
+  Runner = Mirage::Runner
 
   describe 'starting' do
     before(:each) do
@@ -72,7 +72,7 @@ describe Mirage do
       runner.should_not_receive(:kill)
       Mirage::Runner.should_receive(:new).and_return(runner)
 
-      lambda { runner.invoke(:stop, [], options) }.should raise_error(Mirage::ClientError)
+      expect { runner.invoke(:stop, [], options) }.to raise_error(Mirage::ClientError)
     end
 
 
@@ -131,7 +131,7 @@ describe Mirage do
       runner.should_receive(:mirage_process_ids).with([7001]).any_number_of_times.and_return({})
 
       Mirage::Runner.should_receive(:new).and_return(runner)
-      lambda { runner.invoke(:stop, [], options) }.should_not raise_error(Mirage::ClientError)
+      expect { runner.invoke(:stop, [], options) }.to_not raise_error(Mirage::ClientError)
     end
 
   end