mirage-on-thin 3.0.8

data/spec/client/template_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'mirage/client'
+
+
+describe Mirage::Template do
+
+  describe 'get' do
+    it 'should load a template given its id' do
+      endpoint = "endpoint"
+      id = 1
+      requests_url = 'request_url'
+      body = "Hello"
+      default = true
+      delay = 1.2
+      content_type = "application/json"
+      status = 201
+      headers = {'header' => 'value'}
+
+
+      required_parameters = {"name" => 'joe'}
+      required_body_content = %{content}
+      required_headers = {"header" => 'value'}
+      http_method = "get"
+
+      template_json = {
+          endpoint: endpoint,
+          id: id,
+          requests_url: requests_url,
+          response:{
+              default: default,
+              body: Base64.encode64(body),
+              delay: delay,
+              content_type: content_type,
+              status: status,
+              headers: headers
+          },
+          request: {
+              parameters: required_parameters,
+              body_content: required_body_content,
+              headers: required_headers,
+              http_method: http_method
+          }
+      }
+      template_json.should_receive(:code).and_return 200
+
+      template_url = "url"
+      Template.should_receive(:backedup_get).with(template_url, :format => :json).and_return(template_json)
+
+      template = Template.get(template_url)
+      template.body.should == body
+      template.endpoint.should == endpoint
+      template.id.should == id
+
+      template.default.should == default
+      template.delay.should == delay
+      template.content_type.should == content_type
+      template.status.should == status
+      template.headers.should == headers
+
+      template.required_parameters.should  == required_parameters
+      template.required_body_content.should == required_body_content
+      template.required_headers.should  == required_headers
+      template.http_method.should == http_method
+      template.url.should  == template_url
+      template.requests_url.should == requests_url
+    end
+
+    it 'should raise an error if the template is not found' do
+      template_url = 'url'
+      response = double(code: 404)
+      Template.should_receive(:backedup_get).with(template_url, :format => :json).and_return response
+      expect{Template.get(template_url)}.to raise_error Mirage::TemplateNotFound
+    end
+  end
+
+  describe 'initialize' do
+    it 'throws and exception if an endpoint is not supplied as the first parameter' do
+      expect{Template.new}.to raise_error(ArgumentError)
+    end
+
+    it 'throws and exception if first argument is not a string' do
+      expect{Template.new(:endpoint)}.to raise_error(ArgumentError)
+    end
+  end
+
+
+  describe 'creating' do
+    json = "reponse json"
+    endpoint = "greeting"
+
+    it 'should create a template on mirage' do
+      template = Template.new(endpoint,json)
+
+      template.should_receive(:to_json).and_return(json)
+      Template.should_receive(:put).with(endpoint, :body => json, :headers => {'content-type' => 'application/json'}).and_return(convert_keys_to_strings({:id => 1}))
+      template.create
+      template.id.should == 1
+    end
+
+    it 'should have default values set' do
+      template = Template.new(endpoint,json)
+      template.http_method.should == :get
+      template.status.should == 200
+      template.content_type.should == "text/plain"
+      template.default.should == false
+      template.delay.should == 0
+    end
+  end
+
+
+  describe 'deleting' do
+
+    it 'should clear a response' do
+      id = 1
+      template_url = "base_url/templates/#{id}"
+      request_url = "base_url/requests/#{id}"
+
+      template = Template.new("", "")
+      template.url template_url
+      template.requests_url request_url
+
+
+      template.stub(:id).and_return(id)
+
+      Template.should_receive(:delete).with(template_url)
+
+      Mirage::Request.should_receive(:delete).with(request_url)
+      template.delete
+    end
+
+  end
+
+  describe 'method missing' do
+    it 'should delagate to the caller if it is set' do
+      caller = Object.new
+      caller.should_receive(:some_method)
+      template = Template.new('endpoint')
+      template.caller_binding = caller
+      template.some_method
+    end
+
+    it 'should throw a standard method missing error if a caller binding is not set' do
+      expect{Template.new('endpoint').some_method}.to raise_error(NameError)
+    end
+  end
+end

data/spec/client/templates_spec.rb

@@ -0,0 +1,197 @@
+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/server/binary_data_checker_spec.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,34 @@
+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_spec.rb

@@ -0,0 +1,577 @@
+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