mirage 3.0.13 → 3.0.14

data/spec/mirage/client/templates_spec.rb

@@ -1,197 +0,0 @@
-require 'spec_helper'
-require 'mirage/client'
-
-describe 'templates' do
-
-
-  describe 'deleting' do
-    it 'should delete all templates and associated request data' do
-      base_url = "base_url"
-      requests = double('requests')
-      Requests.should_receive(:new).with(base_url).and_return(requests)
-
-      Templates.should_receive(:delete).with("#{base_url}/templates")
-      requests.should_receive(:delete_all)
-
-      Templates.new(base_url).delete_all
-    end
-  end
-
-  describe 'setting default config' do
-
-    it 'should preset configuration for templates' do
-      Template.stub(:put).and_return(convert_keys_to_strings({:id => 1}))
-      templates = Templates.new "base_url"
-
-      http_method = :post
-      status = 202
-      default = true
-      delay = 2
-      content_type = "text/xml"
-
-      templates.default_config do
-        http_method http_method
-        status status
-        default default
-        delay delay
-        content_type content_type
-      end
-
-      template = templates.put('greeting', 'hello')
-
-      template.http_method.should == http_method
-      template.status.should == status
-      template.default.should == default
-      template.delay.should == delay
-      template.content_type.should == content_type
-    end
-
-    it 'should fall over to methods on the caller if the method does not exist on the configuration object' do
-      templates_wrapper = Class.new do
-        def initialize
-          @templates = Templates.new "base_url"
-          @outer_method_called = false
-        end
-
-        def outer_method_call
-          @outer_method_called = true
-        end
-
-
-        def outer_method_called?
-          @outer_method_called
-        end
-
-        def test
-          @templates.default_config do
-            outer_method_call
-          end
-        end
-      end
-
-
-      wrapper = templates_wrapper.new
-
-      wrapper.test
-      wrapper.outer_method_called?.should == true
-
-    end
-  end
-
-  describe 'putting templates' do
-
-
-    endpoint = "greeting"
-    value = "hello"
-    let(:base_url) { "base_url" }
-    let!(:templates) { Templates.new(base_url) }
-    let!(:model_class) do
-      Class.new do
-        extend Template::Model
-        endpoint endpoint
-
-        def create
-          self
-        end
-      end
-    end
-
-
-    context 'model as parameter' do
-      let!(:endpoint) { 'endpoint' }
-
-      before :each do
-        @base_url = "base_url"
-        @templates = Templates.new(@base_url)
-      end
-      it 'should take a model as a parameter' do
-        template = model_class.new
-        template = @templates.put template
-        template.endpoint.should == "#{@base_url}/templates/#{endpoint}"
-      end
-
-      it 'should prepend base url to the endpoint unless it is set already' do
-        original_template = model_class.new
-        stored_template = @templates.put original_template
-        stored_template.endpoint.should == "#{@base_url}/templates/#{endpoint}"
-        stored_template = @templates.put original_template
-        stored_template.endpoint.should == "#{@base_url}/templates/#{endpoint}"
-      end
-
-      it 'should fall over to methods on the caller if the method does not exist on the template object' do
-        template_wrapper = Class.new do
-          def initialize
-            @templates = Templates.new "base_url"
-            @outer_method_called = false
-          end
-
-          def outer_method_call
-            @outer_method_called = true
-          end
-
-          def outer_method_called?
-            @outer_method_called
-          end
-
-          def test
-            template = Template.new 'endpoint'
-            Template.should_receive(:new).and_return template
-            template.stub(:create).and_return(template)
-            @templates.put('endpoint', 'value') do |response|
-              outer_method_call
-            end
-          end
-        end
-
-        wrapper = template_wrapper.new
-
-        template = wrapper.test
-        wrapper.outer_method_called?.should == true
-        template.caller_binding.should == nil
-
-      end
-
-
-    end
-
-    context 'endpoint and value as parameters' do
-      before :each do
-        @base_url = "base_url"
-        @templates = Templates.new(@base_url)
-
-        @template_mock = double('template')
-        Template.should_receive(:new).with("#{@base_url}/templates/#{endpoint}", value, @templates.default_config).and_return(@template_mock)
-        @template_mock.should_receive(:create)
-      end
-
-      it 'should create a template' do
-        @templates.put(endpoint, value)
-      end
-    end
-
-    context 'endpoint and model as parameters' do
-      it 'should put the given template on the given endpoint' do
-        @base_url = "base_url"
-        @templates = Templates.new(@base_url)
-
-        template = model_class.new
-        template  = @templates.put 'greeting', template
-        template.endpoint.should == "#{@base_url}/templates/greeting"
-      end
-    end
-
-    describe 'block parameter that can be used for template customisation' do
-      it 'it is called in the context of the template' do
-        template = Template.new('', '')
-        template.stub(:create)
-        Template.should_receive(:new).and_return(template)
-        templates.put(endpoint, value) do
-          status 404
-        end
-        template.status.should == 404
-      end
-
-    end
-
-  end
-end

data/spec/mirage/wait_methods_spec.rb

@@ -1,42 +0,0 @@
-require 'mirage/wait_methods'
-module Mirage
-  describe WaitMethods do
-    subject do
-      Object.new.tap do |o|
-        o.extend(described_class)
-      end
-    end
-
-    let(:default_options) { { timeout_after: 0.1, retry_every: 0.05 } }
-
-    it 'waits until the prescribed thing has happened' do
-      expect { subject.wait_until(default_options) { true } }.to_not raise_exception
-    end
-
-    it 'should keep trying for a specified period' do
-      start_time = Time.now
-
-      expect { subject.wait_until(default_options) { false } }.to raise_exception TimeoutException
-
-      expect(Time.now - default_options[:timeout_after]).to be > start_time
-    end
-
-    context 'timeout_after specified' do
-      it 'throws an exception if when the prescribed action does not happen in time' do
-        expect { subject.wait_until(default_options) { false } }.to raise_error TimeoutException
-      end
-    end
-
-    context 'retry time specified' do
-      it 'retries at the given interval' do
-        count = 0
-        expect do
-          subject.wait_until(timeout_after: default_options[:timeout_after] * 2, retry_every: 0.1) do
-            count += 1
-          end
-        end.to raise_exception TimeoutException
-        expect(count).to eq(2)
-      end
-    end
-  end
-end

data/spec/server/binary_data_checker_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'binary_data_checker'
-
-
-describe Mirage::BinaryDataChecker do
-  include_context :resources
-  it 'should find binary data' do
-    BinaryDataChecker.contains_binary_data?(File.read("#{resources_dir}/binary.file")).should == true
-  end
-
-  it 'should not find binary data' do
-    BinaryDataChecker.contains_binary_data?("string").should == false
-  end
-
-  it 'should clean up the temporary file created when checking string content' do
-    tmpfile = Tempfile.new("file")
-    Tempfile.should_receive(:new).and_return tmpfile
-    FileUtils.should_receive(:rm).with(tmpfile.path)
-    BinaryDataChecker.contains_binary_data?("string")
-  end
-end

data/spec/server/helpers/http_headers_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'helpers/http_headers'
-describe Mirage::Server::Helpers::HttpHeaders do
-  describe '#extract_http_headers' do
-    it 'returns content-type' do
-      helpers = Object.new
-      helpers.extend(described_class)
-      expected = {'CONTENT_TYPE' => 'application/json'}
-      expect(helpers.extract_http_headers(expected)['Content-Type']).to eq('application/json')
-    end
-
-    it 'returns content-length' do
-      helpers = Object.new
-      helpers.extend(described_class)
-      expected = {'CONTENT_LENGTH' => '10'}
-      expect(helpers.extract_http_headers(expected)['Content-Length']).to eq('10')
-    end
-
-  end
-end

data/spec/server/helpers/template_requirements_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'sinatra'
-require 'helpers/template_requirements'
-
-
-describe "helpers" do
-  include_context :resources
-
-  before :each do
-    @helper = Object.new
-    @helper.extend(Mirage::Server::Helpers::TemplateRequirements)
-  end
-
-  describe 'converting raw parameter requirements' do
-    it 'should split on split on the (:) to derive the required parameter and value' do
-      @helper.convert_raw_required_params(%w(name:leon)).should == {'name' => 'leon'}
-    end
-
-    it 'should store regular expression matcher' do
-      @helper.convert_raw_required_params(%w(name:%r{.*eon})).should == {'name' => /.*eon/}
-    end
-  end
-
-  describe 'converting raw body content requirements' do
-    it 'should extract plan text requirements' do
-      @helper.convert_raw_required_body_content_requirements(%w(leon)).should == %w(leon)
-    end
-
-    it 'should extract plan requirements in the form of a regexp' do
-      @helper.convert_raw_required_body_content_requirements(%w(%r{.*eon})).should == [/.*eon/]
-    end
-  end
-
-end

data/spec/server/mock_response_set_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-require 'mock_response_set'
-describe Mirage::MockResponseSet do
-
-  it 'extends Hash' do
-    expect(subject).to be_a(Hash)
-  end
-  describe '#fuzzy_find' do
-
-    let(:expected_greeting){'hello'}
-    let(:greeting_key){'/greeting'}
-
-    subject do
-      described_class.new.tap do |subject|
-        subject[greeting_key] = expected_greeting
-      end
-    end
-
-    context 'key is not a regex' do
-      context 'input is the same' do
-        it 'returns the stored value' do
-          expect(subject.fuzzy_find(greeting_key)).to eq(expected_greeting)
-        end
-      end
-
-      context 'input is different' do
-        it 'returns nil' do
-          expect(subject.fuzzy_find('/salutation')).to eq(nil)
-        end
-
-      end
-
-    end
-
-    context 'key is a regular expression' do
-      subject do
-        described_class.new.tap do |subject|
-          subject[%r{.*ting}] = expected_greeting
-        end
-      end
-
-      context 'input is matches regex' do
-        it 'returns the stored value' do
-          expect(subject.fuzzy_find(greeting_key)).to eq(expected_greeting)
-        end
-      end
-
-      context 'input does not match regex' do
-        it 'returns nil' do
-          subject[%r{.*ting}] = expected_greeting
-          expect(subject.fuzzy_find('/salutation')).to eq(nil)
-        end
-
-      end
-    end
-  end
-end

data/spec/server/mock_response_spec.rb

@@ -1,577 +0,0 @@
-require 'spec_helper'
-require 'extensions/object'
-require 'extensions/hash'
-require 'mock_response'
-
-describe Mirage::MockResponse do
-
-  before :each do
-    MockResponse.delete_all
-  end
-
-  describe 'initialisation' do
-    it 'should find binary data' do
-      string="string"
-      response_spec = convert_keys_to_strings({:response => {:body => string}})
-      BinaryDataChecker.should_receive(:contains_binary_data?).with(string).and_return(true)
-      MockResponse.new("greeting", response_spec).binary?.should == true
-    end
-
-    it 'should not find binary data' do
-      string="string"
-      response_spec = convert_keys_to_strings({:response => {:body => string}})
-      BinaryDataChecker.should_receive(:contains_binary_data?).with(string).and_return(false)
-      MockResponse.new("greeting", response_spec).binary?.should == false
-    end
-  end
-
-  describe 'defaults' do
-    describe 'request' do
-      it 'should default http_method' do
-        MockResponse.new("greeting", {}).request_spec['http_method'].should == "get"
-      end
-    end
-
-    describe 'response' do
-
-      it 'should default content_type' do
-        MockResponse.new("greeting", {}).response_spec['content_type'].should == "text/plain"
-      end
-
-      it 'should default status code' do
-        MockResponse.new("greeting", {}).response_spec['status'].should == 200
-      end
-      it 'should default delay' do
-        MockResponse.new("greeting", {}).response_spec['delay'].should == 0
-      end
-
-      it 'should default default' do
-        MockResponse.new("greeting", {}).response_spec['default'].should == false
-      end
-    end
-  end
-
-  describe 'saving state' do
-    it 'should store the current set of responses' do
-      greeting = MockResponse.new("greeting")
-      farewell = MockResponse.new("farewell")
-
-      MockResponse.backup
-      MockResponse.new("farewell", "cheerio")
-      MockResponse.revert
-
-      MockResponse.all.should == [greeting, farewell]
-    end
-  end
-
-  describe "response values" do
-
-    it 'should return any headers set' do
-      headers = {
-          'header' => 'value'
-      }
-      response_spec = convert_keys_to_strings({:response => {:headers => headers}})
-      MockResponse.new("greeting", response_spec).headers.should == headers
-    end
-
-    it 'should return the response value' do
-      response_spec = convert_keys_to_strings({:response => {:body => Base64.encode64("hello")}})
-      MockResponse.new("greeting", response_spec).value.should == "hello"
-    end
-
-    it 'should return if the value contains binary data' do
-      response_spec = convert_keys_to_strings({:response => {:body => Base64.encode64("hello ${name}")}})
-      BinaryDataChecker.should_receive(:contains_binary_data?).and_return(true)
-      response = MockResponse.new("greeting", response_spec)
-
-      response.value("", {"name" => "leon"}).should == "hello ${name}"
-    end
-
-    it 'should replace patterns with values found in request parameters' do
-      response_spec = convert_keys_to_strings({:response => {:body => Base64.encode64("hello ${name}")}})
-      MockResponse.new("greeting", response_spec).value("", {"name" => "leon"}).should == "hello leon"
-    end
-
-    it 'should base64 decode values' do
-      response_spec = convert_keys_to_strings({:response => {:body => "encoded value"}})
-      Base64.should_receive(:decode64).and_return("decoded value")
-      MockResponse.new("greeting", response_spec).value("")
-    end
-
-    it 'should replace patterns with values found in the body' do
-      response_spec = convert_keys_to_strings({:response => {:body => Base64.encode64("hello ${name>(.*?)<}")}})
-      MockResponse.new("greeting", response_spec).value("<name>leon</name>").should == "hello leon"
-    end
-  end
-
-  describe "Matching http method" do
-    it 'should find the response with the correct http method' do
-      response_spec = convert_keys_to_strings({:request => {:http_method => "post"}})
-      response = MockResponse.new("greeting", response_spec)
-
-      options = {:body => "", :params => {}, :endpoint => "greeting", :http_method => "post", :headers => {}}
-      MockResponse.find(options).should == response
-      options[:http_method] = "get"
-      expect { MockResponse.find(options) }.to raise_error(ServerResponseNotFound)
-    end
-  end
-
-  describe 'Finding by id' do
-    it 'should find a response given its id' do
-      response1 = MockResponse.new("greeting", "hello")
-      MockResponse.new("farewell", "goodbye")
-      MockResponse.find_by_id(response1.response_id).should == response1
-    end
-  end
-
-  describe 'deleting' do
-
-    it 'should delete a response given its id' do
-      response1 = MockResponse.new("greeting", "hello")
-      MockResponse.delete(response1.response_id)
-      expect { MockResponse.find_by_id(response1.response_id) }.to raise_error(ServerResponseNotFound)
-    end
-
-    it 'should delete all responses' do
-      MockResponse.new("greeting", "hello")
-      MockResponse.new("farewell", "goodbye")
-      MockResponse.delete_all
-      MockResponse.all.size.should == 0
-    end
-
-  end
-
-  describe 'matching' do
-    it 'should convert requirements in to strings before matching' do
-      requirement = 1234
-      spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :parameters => {:number => requirement},
-                  :body_content => [requirement],
-                  :headers => {:number => requirement}
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-
-      MockResponse.new("greeting", spec)
-      options = {:headers => {'number' => '1234'},
-                 :params => {'number' => "1234"},
-                 :endpoint => "greeting",
-                 :http_method => "get",
-                 :body => "1234", }
-
-      expect { MockResponse.find(options) }.to_not raise_error
-    end
-
-    describe "matching on request parameters" do
-      it 'should find the response if all required parameters are present' do
-        get_spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :http_method => "get",
-                    :parameters => {
-                        :firstname => "leon"
-                    }
-                },
-                :response => {
-                    :body => Base64.encode64("get response")
-                }
-            }
-        )
-
-        post_spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :http_method => "post",
-                    :parameters => {
-                        :firstname => "leon"
-                    }
-                },
-                :response => {
-                    :body => Base64.encode64("post response")
-                }
-            }
-        )
-        get_response = MockResponse.new("greeting", get_spec)
-        post_response = MockResponse.new("greeting", post_spec)
-
-        options = {:body => "", :params => {"firstname" => "leon"}, :endpoint => "greeting", :http_method => "post", :headers => {}}
-
-        MockResponse.find(options).should == post_response
-        MockResponse.find(options.merge(:http_method => "get")).should == get_response
-      end
-
-      it 'should match request parameter values using regexps' do
-        response_spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :parameters => {:firstname => "%r{leon.*}"}
-                },
-                :response => {
-                    :body => 'response'
-                }
-
-            }
-        )
-        response = MockResponse.new("greeting", response_spec)
-
-        options = {:body => "", :params => {"firstname" => "leon"}, :endpoint => "greeting", :http_method => "get", :headers => {}}
-        MockResponse.find(options).should == response
-        MockResponse.find(options.merge(:params => {"firstname" => "leonard"})).should == response
-        expect { MockResponse.find(options.merge(:params => {"firstname" => "leo"})) }.to raise_error(ServerResponseNotFound)
-      end
-    end
-
-    describe 'matching request uri' do
-      it 'should match using wild cards' do
-        response_spec = convert_keys_to_strings(
-            {
-                :response => {
-                    :body => 'response'
-                }
-
-            }
-        )
-        response = MockResponse.new('greeting/*/ashley/*', response_spec)
-        MockResponse.find(:params => {}, :headers => {}, :http_method => "get", endpoint: 'greeting/leon/ashley/davis').should == response
-      end
-    end
-
-    describe 'matching against request http_headers' do
-      it 'should match using literals' do
-        required_headers = {
-            'HEADER-1' => 'value1',
-            'HEADER-2' => 'value2'
-        }
-        spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :headers => required_headers
-                },
-                :response => {
-                    :body => 'response'
-                }
-
-            }
-        )
-        response = MockResponse.new("greeting", spec)
-
-        options = {:body => "<name>leon</name>", :params => {}, :endpoint => "greeting", :http_method => "get", :headers => required_headers}
-        MockResponse.find(options).should == response
-        expect { MockResponse.find(options.merge(:headers => {})) }.to raise_error(ServerResponseNotFound)
-
-      end
-
-      it 'should match using regex' do
-        required_headers = {
-            'CONTENT-TYPE' => '%r{.*/json}',
-        }
-        spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :headers => required_headers
-                },
-                :response => {
-                    :body => 'response'
-                }
-
-            }
-        )
-        response = MockResponse.new("greeting", spec)
-
-        options = {:body => "<name>leon</name>", :params => {}, :endpoint => "greeting", :http_method => "get", :headers => {'CONTENT-TYPE' => 'application/json'}}
-        MockResponse.find(options).should == response
-        expect { MockResponse.find(options.merge(:headers => {'CONTENT-TYPE' => 'text/xml'})) }.to raise_error(ServerResponseNotFound)
-
-      end
-    end
-
-    describe 'matching against the request body' do
-      it 'should match required fragments in the request body' do
-
-        response_spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :body_content => %w(leon)
-                },
-                :response => {
-                    :body => 'response'
-                }
-
-            }
-        )
-
-        response = MockResponse.new("greeting", response_spec)
-
-        options = {:body => "<name>leon</name>", :params => {}, :endpoint => "greeting", :http_method => "get", :headers => {}}
-
-        MockResponse.find(options).should == response
-        expect { MockResponse.find(options.merge(:body => "<name>jeff</name>")) }.to raise_error(ServerResponseNotFound)
-      end
-
-      it 'should use regexs to match required fragements in the request body' do
-        response_spec = convert_keys_to_strings(
-            {
-                :request => {
-                    :body_content => %w(%r{leon.*})
-                },
-                :response => {
-                    :body => 'response'
-                }
-
-            }
-        )
-
-        response = MockResponse.new("greeting", response_spec)
-
-
-        options = {:body => "<name>leon</name>", :params => {}, :endpoint => "greeting", :http_method => "get", :headers => {}}
-        MockResponse.find(options).should == response
-        MockResponse.find(options.merge(:body => "<name>leonard</name>")).should == response
-        expect { MockResponse.find(options.merge(:body => "<name>jeff</name>")) }.to raise_error(ServerResponseNotFound)
-      end
-    end
-  end
-
-  it 'should be equal to another response that is the same not including the response value' do
-
-    spec = convert_keys_to_strings({:response => {:body => "hello1",
-                                                  :content_type => "text/xml",
-                                                  :status => 202,
-                                                  :delay => 1.0,
-                                                  :default => true,
-                                                  :file => false}
-
-                                   })
-
-    response = MockResponse.new("greeting", spec)
-    response.should_not == MockResponse.new("greeting", {})
-    response.should == MockResponse.new("greeting", spec)
-  end
-
-  describe "scoring to represent the specificity of a response" do
-
-    it 'should score an exact requirement match at 2' do
-      response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :parameters => {:firstname => "leon"}
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-      MockResponse.new("greeting", response_spec).score.should == 2
-
-      response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :body_content => %w(login)
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-      MockResponse.new("greeting", response_spec).score.should == 2
-
-      response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :headers => {'header' => 'header'}
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-      MockResponse.new("greeting", response_spec).score.should == 2
-    end
-
-    it 'should score a match found by regexp at 1' do
-
-      response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :parameters => {:firstname => "%r{leon.*}"}
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-      MockResponse.new("greeting", response_spec).score.should == 1
-
-      response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :body_content => %w(%r{input|output})
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-      MockResponse.new("greeting", response_spec).score.should == 1
-
-      response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :headers => {'header' => '%r{.*blah}'}
-              },
-              :response => {
-                  :body => 'response'
-              }
-
-          }
-      )
-      MockResponse.new("greeting", response_spec).score.should == 1
-    end
-
-    it 'should find the most specific response' do
-      default_response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :body_content => %w(login)
-              },
-              :response => {
-                  :body => 'default_response'
-              }
-
-          }
-      )
-
-      specific_response_spec = convert_keys_to_strings(
-          {
-              :request => {
-                  :body_content => %w(login),
-                  :parameters => {
-                      :name => "leon"
-                  }
-              },
-              :response => {
-                  :body => 'specific response'
-              }
-
-          }
-      )
-
-      MockResponse.new("greeting", default_response_spec)
-      expected_response = MockResponse.new("greeting", specific_response_spec)
-      options = {:body => "<action>login</action>", :params => {"name" => "leon"}, :endpoint => "greeting", :http_method => "get", :headers => {}}
-      MockResponse.find(options).should == expected_response
-    end
-  end
-
-
-  it 'should all matching to be based on body content, request parameters and http method' do
-    response_spec = convert_keys_to_strings({
-                                                :request => {
-                                                    :body_content => %w(login),
-                                                    :parameters => {
-                                                        :name => "leon"
-                                                    },
-                                                    :http_method => "post"
-                                                },
-                                                :response => {
-                                                    :body => "response"
-                                                }
-                                            })
-
-
-    response = MockResponse.new("greeting", response_spec)
-    options = {:body => "<action>login</action>", :params => {"name" => "leon"}, :endpoint => "greeting", :http_method => "post", :headers => {}}
-    MockResponse.find(options).should == response
-
-    options[:http_method] = 'get'
-    expect { MockResponse.find(options) }.to raise_error(ServerResponseNotFound)
-  end
-
-  it 'should recycle response ids' do
-    response_spec = convert_keys_to_strings({
-                                                :request => {
-                                                    :body_content => %w(login),
-                                                    :parameters => {
-                                                        :name => "leon"
-                                                    },
-                                                    :http_method => "post"
-                                                },
-                                                :response => {
-                                                    :body => "response"
-                                                }
-                                            })
-    response1 = MockResponse.new("greeting", response_spec)
-    response_spec['response']['body'] = 'response2'
-    response2 = MockResponse.new("greeting", response_spec)
-
-    response1.response_id.should_not == nil
-    response1.response_id.should == response2.response_id
-  end
-
-  it 'should raise an exception when a response is not found' do
-    expect { MockResponse.find(:body => "<action>login</action>", :params => {:name => "leon"}, :endpoint => "greeting", :http_method => "post", :headers => {}) }.to raise_error(ServerResponseNotFound)
-  end
-
-  it 'should return all responses' do
-    MockResponse.new("greeting", convert_keys_to_strings({:response => {:body => "hello"}}))
-    MockResponse.new("greeting", convert_keys_to_strings({:request => {:body_content => %w(leon)}, :response => {:body => "hello leon"}}))
-    MockResponse.new("greeting", convert_keys_to_strings({:request => {:body_content => %w(leon), :http_method => "post"}, :response => {:body => "hello leon"}}))
-    MockResponse.new("deposit", convert_keys_to_strings({:request => {:body_content => %w(amount), :http_method => "post"}, :response => {:body => "received"}}))
-    MockResponse.all.size.should == 4
-  end
-
-  describe 'finding defaults' do
-    it 'most appropriate response under parent resource and same http method' do
-      level1_response = MockResponse.new("level1", convert_keys_to_strings({:response => {:body => "level1", :default => true}}))
-      MockResponse.new("level1/level2", convert_keys_to_strings({:response => {:body => "level2", :default => true}, :request => {:body_content => %w(body)}}))
-      MockResponse.find_default(:body => "", :http_method => "get", :endpoint => "level1/level2/level3", :params => {}, :headers => {}).should == level1_response
-    end
-  end
-
-  it 'should generate subdomains' do
-    MockResponse.subdomains("1/2/3").should == ["1/2/3", '1/2', '1']
-  end
-
-  it 'should generate a json representation of itself' do
-    endpoint = "greeting"
-    requests_url = "requests_url"
-    response_spec = convert_keys_to_strings({
-                                                :id => 1,
-                                                :endpoint => endpoint,
-                                                :requests_url => requests_url,
-                                                :request => {
-                                                    :body_content => %w(login),
-                                                    :parameters => {
-                                                        :name => "leon"
-                                                    },
-                                                    :headers => {
-                                                        :header => 'header'
-                                                    },
-                                                    :http_method => "post"
-                                                },
-                                                :response => {
-                                                    :body => "response",
-                                                    :delay => 0,
-                                                    :content_type => 'text/plain',
-                                                    :status => 200,
-                                                    :default => false
-                                                }
-                                            })
-
-    mock_response = MockResponse.new(endpoint, response_spec)
-    mock_response.requests_url = requests_url
-    JSON.parse(mock_response.raw).should == response_spec
-  end
-
-end