mirage 2.4.2 → 3.0.0.alpha.1

data/spec/client/template_configuration_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'mirage/client'
+
+
+
+describe Mirage::TemplateConfiguration do
+  TemplateConfiguration = Mirage::TemplateConfiguration
+  it 'should have defaults' do
+    configuration = TemplateConfiguration.new
+    assert_defaults configuration
+  end
+
+  it 'should be reset' do
+    configuration = TemplateConfiguration.new
+    configuration.http_method = :post
+    configuration.status = 202
+    configuration.delay = 3
+    configuration.default = true
+    configuration.content_type = "text/xml"
+
+    configuration.reset
+    assert_defaults configuration
+  end
+
+  def assert_defaults configuration
+    configuration.http_method.should == :get
+    configuration.status.should == 200
+    configuration.delay.should == 0
+    configuration.default.should == false
+    configuration.content_type.should == "text/plain"
+  end
+end

data/spec/client/template_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+require 'mirage/client'
+
+
+describe Mirage::Template do
+  Template = Mirage::Template
+  Request = Mirage::Request
+
+  describe 'get' do
+    it 'should load a template given its id' do
+      endpoint = "endpoint"
+      id = 1
+      requests_url = 'request_url'
+      value = "Hello"
+      default = false
+      delay = 1.2
+      content_type = "application/json"
+      status = 201
+
+
+      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: value,
+              delay: delay,
+              content_type: content_type,
+              status: status,
+          },
+          request: {
+              parameters: required_parameters,
+              body_content: required_body_content,
+              headers: required_headers,
+              http_method: http_method
+          }
+      }
+
+      template_url = "url"
+      Template.should_receive(:backedup_get).with(template_url, :format => :json).and_return(template_json)
+
+      template = Template.get(template_url)
+      template.value.should == value
+      template.endpoint.should == endpoint
+      template.id.should == id
+
+      template.default.should == default
+      template.default.should == default
+      template.delay.should == delay
+      template.content_type.should == content_type
+      template.status.should == status
+
+      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
+  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 "json representation" do
+
+    describe 'response body' do
+      it 'should base64 encode response values' do
+        response = Template.new "endpoint", "value"
+        JSON.parse(response.to_json)["response"]["body"].should == Base64.encode64("value")
+      end
+    end
+
+    describe 'required request parameters' do
+
+      it 'should contain expected request parameters' do
+        response = Template.new "endpoint", "value"
+        required_parameters = {:key => "value"}
+        response.required_parameters = required_parameters
+        JSON.parse(response.to_json)["request"]["parameters"].should == convert_keys_to_strings(required_parameters)
+      end
+
+      it 'should encode parameter requirements that are regexs' do
+        response = Template.new "endpoint", "value"
+        response.required_parameters = {:key => /regex/}
+        JSON.parse(response.to_json)["request"]["parameters"].should == convert_keys_to_strings({:key => "%r{regex}"})
+      end
+    end
+
+    describe 'required body content' do
+      it 'should contain expected body content' do
+        response = Template.new "endpoint", "value"
+        required_body_content = ["body content"]
+        response.required_body_content = required_body_content
+        JSON.parse(response.to_json)["request"]["body_content"].should == required_body_content
+      end
+
+      it 'should encode body content requirements that are regexs' do
+        response = Template.new "endpoint", "value"
+        response.required_body_content = [/regex/]
+        JSON.parse(response.to_json)["request"]["body_content"].should == %w(%r{regex})
+      end
+    end
+
+    describe 'required headers' do
+      it 'should contain expected headers' do
+        response = Template.new "endpoint", "value"
+        required_headers = {:header => "value"}
+        response.required_headers = required_headers
+        JSON.parse(response.to_json)["request"]["headers"].should == convert_keys_to_strings(required_headers)
+      end
+
+      it 'should encode header requirements that are regexs' do
+        response = Template.new "endpoint", "value"
+        response.required_headers = {:header => /regex/}
+        JSON.parse(response.to_json)["request"]["headers"].should == convert_keys_to_strings(:header => "%r{regex}")
+      end
+    end
+
+    describe 'delay' do
+      it 'should default to 0' do
+        response = Template.new "endpoint", "value"
+        JSON.parse(response.to_json)["delay"].should == 0
+      end
+
+      it 'should set the delay' do
+        delay = 5
+        response = Template.new "endpoint", "value"
+        response.delay = delay
+        JSON.parse(response.to_json)["delay"].should == delay
+      end
+    end
+
+    describe 'status code' do
+      it 'should default to 200' do
+        response = Template.new "endpoint", "value"
+        JSON.parse(response.to_json)["response"]["status"].should == 200
+      end
+
+      it 'should set the status' do
+        status = 404
+        response = Template.new "endpoint", "value"
+        response.status = status
+        JSON.parse(response.to_json)["response"]["status"].should == status
+      end
+    end
+
+    describe 'http method' do
+      it 'should default to get' do
+        response = Template.new "endpoint", "value"
+        JSON.parse(response.to_json)["request"]["http_method"].should == "get"
+      end
+
+      it 'should set the http method' do
+        method = :post
+        response = Template.new "endpoint", "value"
+        response.http_method = method
+        JSON.parse(response.to_json)["request"]["http_method"].should == "post"
+      end
+    end
+
+    describe 'response as default' do
+      it 'should be false by default' do
+        response = Template.new "endpoint", "value"
+        JSON.parse(response.to_json)["response"]["default"].should == false
+      end
+
+      it 'should set the default value' do
+        default = true
+        response = Template.new "endpoint", "value"
+        response.default = default
+        JSON.parse(response.to_json)["response"]["default"].should == default
+      end
+    end
+
+    describe 'content type' do
+      it 'should be text/plain by default' do
+        response = Template.new "endpoint", "value"
+        JSON.parse(response.to_json)["response"]["content_type"].should == "text/plain"
+      end
+
+      it 'should set the default value' do
+        content_type = "application/json"
+        response = Template.new "endpoint", "value"
+        response.content_type = content_type
+        JSON.parse(response.to_json)["response"]["content_type"].should == content_type
+      end
+    end
+
+  end
+end

data/spec/client/templates_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'mirage/client'
+
+describe 'templates' do
+  Templates = Mirage::Templates
+  Requests = Mirage::Requests
+  Template = Mirage::Template
+
+  describe 'deleting' do
+    it 'should delete all templates and associated request data' do
+      base_url = "base_url"
+      requests = mock('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 |defaults|
+        defaults.http_method = http_method
+        defaults.status = status
+        defaults.default = default
+        defaults.delay = delay
+        defaults.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
+  end
+
+  describe 'putting templates' do
+
+    endpoint = "greeting"
+    value = "hello"
+
+    before :each do
+      @base_url = "base_url"
+      @templates = Templates.new(@base_url)
+
+      @template_mock = mock('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
+
+    it 'should accept a block to allow the template to be customised' do
+      block_called = false
+      @templates.put(endpoint, value) do |template|
+        block_called = true
+        template.should == @template_mock
+      end
+      block_called.should == true
+    end
+  end
+end

data/spec/server/binary_data_checker_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'binary_data_checker'
+
+
+describe Mirage::BinaryDataChecker do
+  BinaryDataChecker = Mirage::BinaryDataChecker
+  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_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'sinatra'
+require 'helpers'
+
+
+describe "helpers" do
+  include_context :resources
+
+  before :each do
+    @helper = Object.new
+    @helper.extend(Mirage::Server::Helpers)
+  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,526 @@
+require 'spec_helper'
+require 'extensions/object'
+require 'mock_response'
+
+describe Mirage::MockResponse do
+  MockResponse = Mirage::MockResponse
+  ServerResponseNotFound = Mirage::ServerResponseNotFound
+  BinaryDataChecker = Mirage::BinaryDataChecker
+  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 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 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 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
+
+  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)
+    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