mirage-on-thin 3.0.8

data/server/server.rb

@@ -0,0 +1,184 @@
+require 'sinatra'
+require 'helpers'
+require 'base64'
+module Mirage
+
+  class Server < Sinatra::Base
+
+    REQUESTS = {}
+
+    helpers Helpers::TemplateRequirements, Helpers::HttpHeaders
+
+    put '/templates/*' do |name|
+      content_type :json
+      mock_response = synchronize do
+        MockResponse.new(name, JSON.parse(request.body.read))
+      end
+
+      mock_response.requests_url = request.url.gsub("/templates/#{name}", "/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, '/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
+
+        synchronize do
+          REQUESTS[record.response_id] = request.dup
+        end
+
+
+        send_response(record, body, request, query_string)
+      end
+    end
+
+    get '/templates/:id/preview' do
+      send_response(MockResponse.find_by_id(response_id), '', {}, '')
+    end
+
+    delete '/templates/:id' do
+      synchronize do
+        MockResponse.delete(response_id)
+        REQUESTS.delete(response_id)
+      end
+
+      200
+    end
+
+    delete '/requests' do
+      synchronize do
+        REQUESTS.clear
+      end
+
+      200
+    end
+
+    delete '/requests/:id' do
+      synchronize do
+        REQUESTS.delete(response_id)
+      end
+
+      200
+    end
+
+    delete '/templates' do
+      synchronize do
+        REQUESTS.clear
+        MockResponse.delete_all
+      end
+
+      200
+    end
+
+    get '/templates/:id' do
+      MockResponse.find_by_id(response_id).raw
+    end
+
+    get '/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 }
+
+        {id: request.url,
+         request_url: tracked_request.url,
+         headers: extract_http_headers(tracked_request.env),
+         parameters: parameters,
+         body: body}.to_json
+
+      else
+        404
+      end
+    end
+
+    get '/' do
+      haml :index
+    end
+
+
+    put '/defaults' do
+      synchronize 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
+      end
+      200
+    end
+#
+    put '/backup' do
+      synchronize do
+        MockResponse.backup
+      end
+
+      200
+    end
+
+
+    put '/' do
+      synchronize do
+        MockResponse.revert
+      end
+
+      200
+    end
+
+    get '/pid' do
+      "#{$$}"
+    end
+
+    error ServerResponseNotFound do
+      404
+    end
+
+    error do
+      erb request.env['sinatra.error'].message
+    end
+
+    helpers do
+
+      def synchronize &block
+        Mutex.new.synchronize &block
+      end
+
+      def response_id
+        params[:id].to_i
+      end
+
+      def prime &block
+        block.call Mirage::Client.new "http://localhost:#{settings.port}"
+      end
+
+      def send_response(mock_response, body='', request={}, query_string='')
+        sleep mock_response.response_spec['delay']
+        content_type(mock_response.response_spec['content_type'])
+        status mock_response.response_spec['status']
+        headers mock_response.headers
+        mock_response.value(body, request, query_string)
+      end
+
+
+    end
+  end
+end

data/spec/client/cli_bridge_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'mirage/client'
+
+describe CLIBridge do
+  def mapping port
+    {port.to_s => port_pid_mappings[port.to_s]}
+  end
+
+  let(:port_pid_mappings) do
+    {"7001" => "18903", "7002" => "18904", "7003" => "18905"}
+  end
+
+  let(:operating_system) do
+    Hashie::Mash.new({
+                         :windows => {
+                             :kill_string => "taskkill /F /T /PID %d",
+                             :set_ps_cmd_expectation => proc{bridge.stub(:`).with(/tasklist.*/).and_return(tasklist_output)}
+                         },
+                         :linux => {
+                             :kill_string => "kill -9 %d",
+                             :set_ps_cmd_expectation => proc{IO.stub(:popen).with(/ps aux.*/).and_return(tasklist_output)}
+                         }
+                     })
+  end
+
+  [:linux,:windows].each do |os_name|
+
+    describe os_name do
+      let(:os){operating_system[os_name]}
+      let!(:bridge) do
+        bridge = Object.new
+        bridge.extend(CLIBridge)
+      end
+
+      include_context os_name do
+
+        let(:tasklist_output) do
+          output = []
+          port_pid_mappings.each do |port, pid|
+            output << process_string_for_mirage(port, pid)
+          end
+          output.join("\n")
+        end
+
+        it 'should find the pids of mirage instances for given ports' do
+          os.set_ps_cmd_expectation.call
+          bridge.mirage_process_ids([7001, 7002]).should == mapping(7001).merge(mapping(7002))
+        end
+
+        it 'should find the pids of mirage instances for all ports' do
+          os.set_ps_cmd_expectation.call
+          bridge.mirage_process_ids([:all]).should == port_pid_mappings
+        end
+
+        it 'should kill the given process id' do
+          bridge.should_receive(:`).with(os.kill_string % 18903)
+          bridge.kill(18903)
+        end
+      end
+    end
+  end
+
+end

data/spec/client/client_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'mirage/client'
+
+describe Mirage::Client do
+
+
+  before :each do
+    @response = double('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"
+    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}"
+    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
+
+
+    describe 'defaults' do
+      it 'can be configured with template defaults on initialize' do
+        templates, config = Templates.new("url"), proc {}
+        Templates.should_receive(:new).and_return(templates)
+        templates.should_receive(:default_config) do |&block|
+          block.should == config
+        end
+        Client.new &config
+      end
+
+      it 'can be configured with template defaults on after initalize' do
+        templates, config = Templates.new("url"), proc {}
+        Templates.should_receive(:new).and_return(templates)
+        templates.should_receive(:default_config) do |&block|
+          block.should == config
+        end
+        Client.new.configure &config
+      end
+
+      it 'can be reset' do
+        client = Client.new do
+          http_method :post
+        end
+
+        client.reset
+        client.templates.default_config.should == Template::Configuration.new
+      end
+
+    end
+  end
+
+  it 'should clear mirage' do
+    templates_mock = double('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/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 'The templates instance should be the one created on construction otherwise the defaults passed in will get lost' do
+      mirage = Client.new
+      mirage.templates.should == mirage.templates
+    end
+
+    it 'should find a template' do
+      id = 1
+      mirage = Client.new
+      mock_template = double('template')
+      Template.should_receive(:get).with("#{mirage.url}/templates/#{id}").and_return(mock_template)
+      mirage.templates(1).should == mock_template
+    end
+
+
+    describe 'put' do
+      it "should put a response on mirage by passing args on to template's put method "  do
+        endpoint, value, block = 'greeting', 'hello', Proc.new{}
+
+        templates_mock = double('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
+  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 '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 'running?' do
+    it 'should check if mirage is runing' do
+      url = 'http://some_url'
+
+      Mirage.should_receive(:running?).with url
+      Client.new(url).running?
+    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/helpers/method_builder_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Helpers::MethodBuilder do
+
+  describe 'a builder method' do
+    let :model do
+      model_class = Class.new do
+        extend Helpers::MethodBuilder
+
+        builder_method :name
+      end
+      model_class.new
+    end
+
+    it 'should set a value' do
+      model.name(:joe)
+      model.name.should == :joe
+    end
+
+    it 'should chain' do
+      model.name(:joe).should == model
+    end
+
+    it 'should work with booleans' do
+      model.name(false)
+      model.name.should == false
+    end
+  end
+
+
+  it 'should let you define more than one builder method at a time' do
+    model_class = Class.new do
+      extend Helpers::MethodBuilder
+      builder_methods :foo, :bar
+    end
+    model = model_class.new
+    model.respond_to?(:foo).should be_true
+    model.respond_to?(:bar).should be_true
+  end
+end