mirage 3.0.0.alpha.11 → 3.0.0.alpha.12

data/lib/mirage/client/templates.rb

@@ -23,7 +23,7 @@ module Mirage
     def put *args, &block
       if args.first.class.is_a?(Template::Model)
         template = args.first
-        template.endpoint "#{@url}/#{template.endpoint}"
+        template.endpoint "#{@url}/#{template.endpoint}" unless template.endpoint.to_s.start_with?(@url)
       else
         endpoint, response = args
         template = Mirage::Template.new  "#{@url}/#{endpoint}", response, @default_config

data/mirage.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "mirage"
-  s.version = "3.0.0.alpha.11"
+  s.version = "3.0.0.alpha.12"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Leon Davis"]
-  s.date = "2013-05-07"
+  s.date = "2013-08-20"
   s.description = "Mirage aids testing of your applications by hosting mock responses so that your applications do not have to talk to real endpoints. Its accessible via HTTP and has a RESTful interface."
   s.executables = ["mirage"]
   s.extra_rdoc_files = [
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
     "README.md",
     "VERSION",
     "bin/mirage",
+    "features/.nav",
     "features/client/clear.feature",
     "features/client/configure.feature",
     "features/client/preview_responses.feature",
@@ -33,26 +34,29 @@ Gem::Specification.new do |s|
     "features/client/save_and_revert.feature",
     "features/client/start.feature",
     "features/client/stop.feature",
-    "features/server/commandline_interface/help.feature",
-    "features/server/commandline_interface/start.feature",
-    "features/server/commandline_interface/stop.feature",
-    "features/server/logging.feature",
-    "features/server/prime.feature",
-    "features/server/requests/delete.feature",
-    "features/server/requests/get.feature",
-    "features/server/save_and_revert.feature",
-    "features/server/templates/delete.feature",
-    "features/server/templates/get.feature",
-    "features/server/templates/put/put.feature",
-    "features/server/templates/put/put_with_substitutions.feature",
-    "features/server/templates/put/required_content.feature",
-    "features/server/web_user_interface.feature",
+    "features/commandline_interface/help.feature",
+    "features/commandline_interface/readme.md",
+    "features/commandline_interface/start.feature",
+    "features/commandline_interface/stop.feature",
+    "features/logging.feature",
+    "features/prime.feature",
+    "features/readme.md",
+    "features/requests/delete.feature",
+    "features/requests/get.feature",
+    "features/save_and_revert.feature",
     "features/step_definitions/my_steps.rb",
     "features/support/command_line.rb",
     "features/support/env.rb",
     "features/support/hooks.rb",
     "features/support/mirage.rb",
     "features/support/web.rb",
+    "features/templates/delete.feature",
+    "features/templates/get.feature",
+    "features/templates/put.feature",
+    "features/templates/put_with_substitutions.feature",
+    "features/templates/readme.md",
+    "features/templates/required_content.feature",
+    "features/web_user_interface.feature",
     "full_build.sh",
     "lib/mirage/client.rb",
     "lib/mirage/client/cli_bridge.rb",
@@ -108,7 +112,7 @@ Gem::Specification.new do |s|
   s.licenses = ["MIT"]
   s.post_install_message = "\n===============================================================================\nThanks you for installing mirage.   \n\nRun Mirage with:\n\nmirage start                                   \n\nFor more information go to: https://github.com/lashd/mirage/wiki\n===============================================================================\n"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.25"
+  s.rubygems_version = "1.8.24"
   s.summary = "Mirage is a easy mock server for testing your applications"
 
   if s.respond_to? :specification_version then

data/mirage_server.rb

@@ -5,8 +5,8 @@ $LOAD_PATH.unshift("#{ROOT_DIR}/server")
 
 require 'sinatra/base'
 require 'extensions/object'
-require 'extensions/hash'
 require 'app'
+require 'extensions/hash'
 require 'mirage/client'
 
 module Mirage

data/server/mock_response.rb

@@ -13,12 +13,12 @@ module Mirage
     class << self
 
       def find_by_id(id)
-        all.find{|response| response.response_id == id} || raise(ServerResponseNotFound)
+        all.find { |response| response.response_id == id } || raise(ServerResponseNotFound)
       end
 
       def delete(id)
         responses.values.each do |set|
-          set.values.each{|responses| responses.delete_if{|response|response.response_id == id}}
+          set.values.each { |responses| responses.delete_if { |response| response.response_id == id } }
         end
       end
 
@@ -37,20 +37,21 @@ module Mirage
       end
 
       def all
-        responses.values.collect do|response_set|
+        responses.values.collect do |response_set|
           response_set.values
         end.flatten
       end
 
       def find_default(options)
-       http_method = options[:http_method].upcase!
+        options[:http_method].upcase!
+        http_method = options[:http_method]
         default_responses = subdomains(options[:endpoint]).collect do |domain|
-          if(responses_for_domain = responses[domain])
-            responses_for_domain[http_method].find_all{|response| response.default?} if responses_for_domain[http_method]
+          if (responses_for_domain = responses[domain])
+            responses_for_domain[http_method].find_all { |response| response.default? } if responses_for_domain[http_method]
           end
         end.flatten.compact
 
-        default_responses.find{|response| match?(options,response)} || raise(ServerResponseNotFound)
+        default_responses.find { |response| match?(options, response) } || raise(ServerResponseNotFound)
       end
 
       def subdomains(name)
@@ -69,7 +70,7 @@ module Mirage
       def add(new_response)
         response_set = responses_for_endpoint(new_response)
         method_specific_responses = response_set[new_response.request_spec['http_method'].upcase]||=[]
-        duplicate_response_location = method_specific_responses.index{|response| response.request_spec == new_response.request_spec}
+        duplicate_response_location = method_specific_responses.index { |response| response.request_spec == new_response.request_spec }
         old_response = method_specific_responses.delete_at(duplicate_response_location) if duplicate_response_location
         if old_response
           new_response.response_id = old_response.response_id
@@ -90,13 +91,13 @@ module Mirage
           match?(options, stored_response)
         end
 
-        responses.sort{|a, b| b.score <=> a.score}.first
+        responses.sort { |a, b| b.score <=> a.score }.first
 
       end
 
-      def match?(options,stored_response)
+      def match?(options, stored_response)
         parameters = options[:params]
-        headers = Hash[options[:headers].collect{|key, value| [key.downcase, value]}]
+        headers = Hash[options[:headers].collect { |key, value| [key.downcase, value] }]
 
         request_spec = stored_response.request_spec
 
@@ -156,7 +157,7 @@ module Mirage
       request_defaults = JSON.parse({:parameters => {},
                                      :body_content => [],
                                      :http_method => 'get',
-                                    :headers => {}}.to_json)
+                                     :headers => {}}.to_json)
       response_defaults = JSON.parse({:default => false,
                                       :body => Base64.encode64(''),
                                       :delay => 0,
@@ -169,9 +170,9 @@ module Mirage
       @request_spec = Hashie::Mash.new request_defaults.merge(spec['request']||{})
       @response_spec = Hashie::Mash.new response_defaults.merge(spec['response']||{})
 
-      @request_spec['headers'] = Hash[@request_spec['headers'].collect{|key, value| [key.downcase, value.to_s]}]
-      @request_spec['parameters'] = Hash[@request_spec['parameters'].collect{|key, value| [key, value.to_s]}]
-      @request_spec['body_content'] = @request_spec['body_content'].collect{|value|value.to_s}
+      @request_spec['headers'] = Hash[@request_spec['headers'].collect { |key, value| [key.downcase, value.to_s] }]
+      @request_spec['parameters'] = Hash[@request_spec['parameters'].collect { |key, value| [key, value.to_s] }]
+      @request_spec['body_content'] = @request_spec['body_content'].collect { |value| value.to_s }
       @binary = BinaryDataChecker.contains_binary_data? @response_spec['body']
 
       MockResponse.add self
@@ -187,7 +188,7 @@ module Mirage
 
     def score
       [@request_spec['headers'].values, @request_spec['parameters'].values, @request_spec['body_content']].inject(0) do |score, matchers|
-        matchers.inject(score){|matcher_score, value| interpret_value(value).is_a?(Regexp) ? matcher_score+=1 : matcher_score+=2}
+        matchers.inject(score) { |matcher_score, value| interpret_value(value).is_a?(Regexp) ? matcher_score+=1 : matcher_score+=2 }
       end
     end
 
@@ -217,7 +218,7 @@ module Mirage
     end
 
     def raw
-      {:id =>response_id, :endpoint => @name, :requests_url => requests_url, :response => @response_spec, :request => @request_spec}.to_json
+      {:id => response_id, :endpoint => @name, :requests_url => requests_url, :response => @response_spec, :request => @request_spec}.to_json
     end
 
     def binary?

data/server/server.rb

@@ -10,15 +10,15 @@ module Mirage
 
     helpers Mirage::Server::Helpers
 
-    put '/mirage/templates/*' do |name|
+    put '/templates/*' do |name|
       content_type :json
       mock_response = MockResponse.new(name, JSON.parse(request.body.read))
-      mock_response.requests_url = request.url.gsub("/mirage/templates/#{name}", "/mirage/requests/#{mock_response.response_id}")
+      mock_response.requests_url = request.url.gsub("/templates/#{name}", "/requests/#{mock_response.response_id}")
       {:id => mock_response.response_id}.to_json
     end
 
     %w(get post delete put).each do |http_method|
-      send(http_method, '/mirage/responses/*') do |name|
+      send(http_method, '/responses/*') do |name|
         body, query_string = Rack::Utils.unescape(request.body.read.to_s), request.query_string
 
         options = {:body => body,
@@ -38,33 +38,33 @@ module Mirage
       end
     end
 
-    delete '/mirage/templates/:id' do
+    delete '/templates/:id' do
       MockResponse.delete(response_id)
       REQUESTS.delete(response_id)
       200
     end
 
-    delete '/mirage/requests' do
+    delete '/requests' do
       REQUESTS.clear
       200
     end
 
-    delete '/mirage/requests/:id' do
+    delete '/requests/:id' do
       REQUESTS.delete(response_id)
       200
     end
 
-    delete '/mirage/templates' do
+    delete '/templates' do
       REQUESTS.clear
       MockResponse.delete_all
       200
     end
 
-    get '/mirage/templates/:id' do
+    get '/templates/:id' do
       MockResponse.find_by_id(response_id).raw
     end
 
-    get '/mirage/requests/:id' do
+    get '/requests/:id' do
       content_type :json
       tracked_request = REQUESTS[response_id]
       if tracked_request
@@ -84,12 +84,12 @@ module Mirage
       end
     end
 
-    get '/mirage' do
+    get '/' do
       haml :index
     end
 
 
-    put '/mirage/defaults' do
+    put '/defaults' do
       MockResponse.delete_all
       if File.directory?(settings.defaults.to_s)
         Dir["#{settings.defaults}/**/*.rb"].each do |default|
@@ -103,18 +103,18 @@ module Mirage
       200
     end
 #
-    put '/mirage/backup' do
+    put '/backup' do
       MockResponse.backup
       200
     end
 
 
-    put '/mirage' do
+    put '/' do
       MockResponse.revert
       200
     end
 
-    get '/mirage/pid' do
+    get '/pid' do
       "#{$$}"
     end
 
@@ -133,7 +133,7 @@ module Mirage
       end
 
       def prime &block
-        block.call Mirage::Client.new "http://localhost:#{settings.port}/mirage"
+        block.call Mirage::Client.new "http://localhost:#{settings.port}"
       end
 
       def send_response(mock_response, body='', request={}, query_string='')

data/spec/client/client_spec.rb

@@ -10,7 +10,7 @@ describe Mirage::Client do
 
   describe 'configuration' do
     it 'is configured to connect to local host port 7001 by default' do
-      Client.new.url.should == "http://localhost:7001/mirage"
+      Client.new.url.should == "http://localhost:7001"
     end
 
     it 'can be configured with a url pointing to Mirage' do
@@ -22,7 +22,7 @@ describe Mirage::Client do
 
     it 'can be configured with a port refering to which port Mirage is running on on localhost' do
       port = 9001
-      Client.new(:port => port).url.should == "http://localhost:#{port}/mirage"
+      Client.new(:port => port).url.should == "http://localhost:#{port}"
     end
 
     it 'raises an error if neither a port or url specified in the argument' do
@@ -31,16 +31,35 @@ describe Mirage::Client do
     end
 
 
-    it 'can be configured with template defaults' do
-      templates, config = Templates.new("url"), proc{}
-      Templates.should_receive(:new).and_return(templates)
-      templates.should_receive(:default_config) do |&block|
-        block.should == config
+    describe 'defaults' do
+      it 'can be configured with template defaults on initialize' do
+        templates, config = Templates.new("url"), proc {}
+        Templates.should_receive(:new).and_return(templates)
+        templates.should_receive(:default_config) do |&block|
+          block.should == config
+        end
+        Client.new &config
+      end
+
+      it 'can be configured with template defaults on after initalize' do
+        templates, config = Templates.new("url"), proc {}
+        Templates.should_receive(:new).and_return(templates)
+        templates.should_receive(:default_config) do |&block|
+          block.should == config
+        end
+        Client.new.configure &config
       end
-      Client.new &config
-    end
 
+      it 'can be reset' do
+        client = Client.new do
+          http_method :post
+        end
 
+        client.reset
+        client.templates.default_config.should == Template::Configuration.new
+      end
+
+    end
   end
 
   it 'should clear mirage' do
@@ -55,7 +74,7 @@ describe Mirage::Client do
 
   it 'should prime mirage' do
     Client.should_receive(:put) do |url|
-      url.should == "http://localhost:7001/mirage/defaults"
+      url.should == "http://localhost:7001/defaults"
     end
     Client.new.prime
   end
@@ -66,6 +85,11 @@ describe Mirage::Client do
       mirage.templates.instance_of?(Templates).should == true
     end
 
+    it 'The templates instance should be the one created on construction otherwise the defaults passed in will get lost' do
+      mirage = Client.new
+      mirage.templates.should == mirage.templates
+    end
+
     it 'should find a template' do
       id = 1
       mirage = Client.new
@@ -74,6 +98,7 @@ describe Mirage::Client do
       mirage.templates(1).should == mock_template
     end
 
+
     describe 'put' do
       it "should put a response on mirage by passing args on to template's put method "  do
         endpoint, value, block = 'greeting', 'hello', Proc.new{}
@@ -119,6 +144,15 @@ describe Mirage::Client do
     end
   end
 
+  describe 'running?' do
+    it 'should check if mirage is runing' do
+      url = 'http://some_url'
+
+      Mirage.should_receive(:running?).with url
+      Client.new(url).running?
+    end
+  end
+
 
   describe 'interface to mirage' do
 

data/spec/client/template/model/common_methods_spec.rb

@@ -7,7 +7,7 @@ describe 'CommonMethods' do
   end
 
   let!(:instance) do
-    model.new '', ''
+    model.new
   end
   it 'should provide methods for customising the model' do
     instance.methods.should include(:content_type,

data/spec/client/template/model/instance_methods_spec.rb

@@ -101,13 +101,13 @@ describe Template::Model::InstanceMethods do
 
     describe 'delay' do
       it 'should default to 0' do
-        JSON.parse(instance.to_json)["delay"].should == 0
+        JSON.parse(instance.to_json)["response"]["delay"].should == 0
       end
 
       it 'should set the delay' do
         delay = 5
         instance.delay delay
-        JSON.parse(instance.to_json)["delay"].should == delay
+        JSON.parse(instance.to_json)["response"]["delay"].should == delay
       end
     end
 

data/spec/client/template_spec.rb

@@ -10,7 +10,7 @@ describe Mirage::Template do
       id = 1
       requests_url = 'request_url'
       body = "Hello"
-      default = false
+      default = true
       delay = 1.2
       content_type = "application/json"
       status = 201
@@ -28,7 +28,7 @@ describe Mirage::Template do
           requests_url: requests_url,
           response:{
               default: default,
-              body: body,
+              body: Base64.encode64(body),
               delay: delay,
               content_type: content_type,
               status: status,
@@ -41,6 +41,7 @@ describe Mirage::Template do
               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)
@@ -50,7 +51,6 @@ describe Mirage::Template do
       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
@@ -64,6 +64,13 @@ describe Mirage::Template do
       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 = mock(code: 404)
+      Template.should_receive(:backedup_get).with(template_url, :format => :json).and_return response
+      expect{Template.get(template_url)}.to raise_error Mirage::ResponseNotFound
+    end
   end
 
   describe 'initialize' do
@@ -133,7 +140,7 @@ describe Mirage::Template do
     end
 
     it 'should throw a standard method missing error if a caller binding is not set' do
-      expect{Template.new('endpoint').some_method}.should raise_error(NameError)
+      expect{Template.new('endpoint').some_method}.to raise_error(NameError)
     end
   end
 end