mirage-on-thin 3.0.8

data/lib/mirage/client/templates.rb

@@ -0,0 +1,50 @@
+module Mirage
+  class Templates
+    include HTTParty
+
+    def initialize base_url
+      @url = "#{base_url}/templates"
+      @requests = Requests.new(base_url)
+      @default_config = Template::Configuration.new
+    end
+
+    def default_config &block
+      return @default_config unless block_given?
+      calling_instance = eval "self", block.binding
+      @default_config.caller_binding = calling_instance
+      @default_config.instance_eval &block
+      @default_config.caller_binding = nil
+    end
+
+    def delete_all
+      self.class.delete(@url)
+      @requests.delete_all
+    end
+
+    def put *args, &block
+      if args.first.class.is_a?(Template::Model)
+        template = args.first
+        template = template.clone
+        template.endpoint "#{@url}/#{template.endpoint}"
+      else
+
+        endpoint, template = args
+        if template.class.is_a?(Template::Model)
+          template = template.clone
+          template.endpoint "#{@url}/#{endpoint}"
+        else
+          template = Mirage::Template.new("#{@url}/#{endpoint}", template, @default_config)
+        end
+
+      end
+
+      if block
+        calling_instance = eval "self", block.binding
+        template.caller_binding = calling_instance
+        template.instance_exec(template, &block)
+        template.caller_binding = nil
+      end
+      template.create
+    end
+  end
+end

data/mirage-on-thin.gemspec

@@ -0,0 +1,175 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "mirage-on-thin"
+  s.version = "3.0.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Leon Davis"]
+  s.date = "2014-11-18"
+  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 = [
+    "README.md"
+  ]
+  s.files = [
+    ".ruby-gemset",
+    ".ruby-version",
+    ".simplecov",
+    ".travis.yml",
+    "Gemfile",
+    "Gemfile.lock",
+    "HISTORY",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/mirage",
+    "features/.nav",
+    "features/client/clear.feature",
+    "features/client/configure.feature",
+    "features/client/model.feature",
+    "features/client/preview_responses.feature",
+    "features/client/prime.feature",
+    "features/client/put.feature",
+    "features/client/readme.md",
+    "features/client/requests.feature",
+    "features/client/running.feature",
+    "features/client/save_and_revert.feature",
+    "features/client/start.feature",
+    "features/client/stop.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/step_definitions/observation_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/path_wildcards.feature",
+    "features/templates/preview.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",
+    "lib/mirage/client/client.rb",
+    "lib/mirage/client/error.rb",
+    "lib/mirage/client/helpers/method_builder.rb",
+    "lib/mirage/client/request.rb",
+    "lib/mirage/client/requests.rb",
+    "lib/mirage/client/runner.rb",
+    "lib/mirage/client/template.rb",
+    "lib/mirage/client/template/configuration.rb",
+    "lib/mirage/client/template/model.rb",
+    "lib/mirage/client/template/model/common_methods.rb",
+    "lib/mirage/client/template/model/instance_methods.rb",
+    "lib/mirage/client/templates.rb",
+    "mirage-on-thin.gemspec",
+    "mirage_server.rb",
+    "server/app.rb",
+    "server/binary_data_checker.rb",
+    "server/extensions/hash.rb",
+    "server/extensions/object.rb",
+    "server/helpers.rb",
+    "server/helpers/http_headers.rb",
+    "server/helpers/template_requirements.rb",
+    "server/mock_response.rb",
+    "server/server.rb",
+    "spec/client/cli_bridge_spec.rb",
+    "spec/client/client_spec.rb",
+    "spec/client/helpers/method_builder_spec.rb",
+    "spec/client/request_spec.rb",
+    "spec/client/requests_spec.rb",
+    "spec/client/runner_spec.rb",
+    "spec/client/template/configuration_spec.rb",
+    "spec/client/template/model/common_methods_spec.rb",
+    "spec/client/template/model/instance_methods_spec.rb",
+    "spec/client/template/model_spec.rb",
+    "spec/client/template_spec.rb",
+    "spec/client/templates_spec.rb",
+    "spec/resources/binary.file",
+    "spec/server/binary_data_checker_spec.rb",
+    "spec/server/helpers/http_headers_spec.rb",
+    "spec/server/helpers/template_requirements_spec.rb",
+    "spec/server/mock_response_spec.rb",
+    "spec/server/server_spec.rb",
+    "spec/spec_helper.rb",
+    "tasks/application.rake",
+    "tasks/packaging.rake",
+    "tasks/tests.rake",
+    "views/index.haml",
+    "views/response.haml"
+  ]
+  s.homepage = "https://github.com/lashd/mirage"
+  s.licenses = ["MIT"]
+  s.post_install_message = "\n===============================================================================\nMirage v3:\n\nMirage has just gone up a major version from 2 to 3. If your project uses\na previous version take a look at https://github.com/lashd/mirage to see\nwhat's changed\n===============================================================================\n"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.0.14"
+  s.summary = "Mirage is a easy mock server for testing your applications"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sinatra>, [">= 0"])
+      s.add_runtime_dependency(%q<thin>, [">= 0"])
+      s.add_runtime_dependency(%q<childprocess>, [">= 0"])
+      s.add_runtime_dependency(%q<waitforit>, [">= 0"])
+      s.add_runtime_dependency(%q<thor>, [">= 0"])
+      s.add_runtime_dependency(%q<ptools>, [">= 0"])
+      s.add_runtime_dependency(%q<httparty>, [">= 0"])
+      s.add_runtime_dependency(%q<haml>, [">= 0"])
+      s.add_runtime_dependency(%q<hashie>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<sinatra-contrib>, [">= 0"])
+      s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
+    else
+      s.add_dependency(%q<sinatra>, [">= 0"])
+      s.add_dependency(%q<thin>, [">= 0"])
+      s.add_dependency(%q<childprocess>, [">= 0"])
+      s.add_dependency(%q<waitforit>, [">= 0"])
+      s.add_dependency(%q<thor>, [">= 0"])
+      s.add_dependency(%q<ptools>, [">= 0"])
+      s.add_dependency(%q<httparty>, [">= 0"])
+      s.add_dependency(%q<haml>, [">= 0"])
+      s.add_dependency(%q<hashie>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<sinatra-contrib>, [">= 0"])
+      s.add_dependency(%q<jruby-openssl>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<sinatra>, [">= 0"])
+    s.add_dependency(%q<thin>, [">= 0"])
+    s.add_dependency(%q<childprocess>, [">= 0"])
+    s.add_dependency(%q<waitforit>, [">= 0"])
+    s.add_dependency(%q<thor>, [">= 0"])
+    s.add_dependency(%q<ptools>, [">= 0"])
+    s.add_dependency(%q<httparty>, [">= 0"])
+    s.add_dependency(%q<haml>, [">= 0"])
+    s.add_dependency(%q<hashie>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<sinatra-contrib>, [">= 0"])
+    s.add_dependency(%q<jruby-openssl>, [">= 0"])
+  end
+end
+

data/mirage_server.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+ROOT_DIR = File.dirname(__FILE__)
+$LOAD_PATH.unshift("#{ROOT_DIR}/lib")
+$LOAD_PATH.unshift("#{ROOT_DIR}/server")
+
+require 'sinatra/base'
+require 'extensions/object'
+require 'app'
+require 'extensions/hash'
+require 'mirage/client'
+
+module Mirage
+  class Server < Sinatra::Base
+    configure do
+      options = Hash[*ARGV]
+      set :defaults, options["defaults"]
+      set :port, options["port"]
+      $0="Mirage Server port #{settings.port}"
+      set :show_exceptions, false
+      set :logging, true
+      set :dump_errors, true
+      set :server, 'thin'
+      set :views, "#{ROOT_DIR}/views"
+      set :bind, '0.0.0.0'
+
+      log_file = File.open('mirage.log', 'a')
+      log_file.sync=true
+      use Rack::CommonLogger, log_file
+      enable :logging
+    end
+  end
+end
+
+
+Mirage::Server.run! :server => 'thin'

data/server/app.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'sinatra'
+require 'mock_response'
+require 'server'

data/server/binary_data_checker.rb

@@ -0,0 +1,15 @@
+require 'ptools'
+module Mirage
+  module BinaryDataChecker
+      class << self
+        def contains_binary_data? string
+          tmpfile = Tempfile.new("binary_check")
+          tmpfile.write(string)
+          tmpfile.close
+          binary = File.binary?(tmpfile.path)
+          FileUtils.rm(tmpfile.path)
+          binary
+        end
+      end
+  end
+end

data/server/extensions/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  alias_method :backup, :[]
+
+  def [] desired_key
+    result = backup(desired_key)
+    return result unless result.nil?
+    key, value = find{|key, value| key.is_a?(Regexp) && desired_key.is_a?(String) && key.match(desired_key) }
+    value
+  end
+end

data/server/extensions/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
+end

data/server/helpers.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helpers/template_requirements'
+require 'helpers/http_headers'

data/server/helpers/http_headers.rb

@@ -0,0 +1,31 @@
+require 'rack/utils'
+require 'sinatra/base'
+module Mirage
+  class Server < Sinatra::Base
+    module Helpers
+      module HttpHeaders
+        HTTP_HEADER_FILTER_EXCEPTIONS = %w(CONTENT_TYPE CONTENT_LENGTH)
+        def extract_http_headers(env)
+          headers = env.reject do |k, v|
+            !HTTP_HEADER_FILTER_EXCEPTIONS.include?(k.to_s.upcase) && (!(/^HTTP_[A-Z_]+$/ === k) || v.nil?)
+          end.map do |k, v|
+            [reconstruct_header_name(k), v]
+          end.inject(Rack::Utils::HeaderHash.new) do |hash, k_v|
+            k, v = k_v
+            hash[k] = v
+            hash
+          end
+
+          x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
+
+          headers.merge!("X-Forwarded-For" => x_forwarded_for)
+        end
+
+        def reconstruct_header_name(name)
+          name.sub(/^HTTP_/, "").gsub("_", "-")
+        end
+      end
+    end
+  end
+
+end

data/server/helpers/template_requirements.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'tempfile'
+require 'ptools'
+require 'sinatra/base'
+require 'helpers/http_headers'
+
+module Mirage
+  class Server < Sinatra::Base
+    module Helpers
+      module TemplateRequirements
+        def convert_raw_required_params raw_requirements
+          raw_requirements.collect { |requirement| requirement.split(":") }.inject({}) do |hash, pair|
+            parameter, value = pair.collect { |string| string.strip }
+            value = convert_value(value)
+            hash[parameter] =value; hash
+          end
+        end
+
+        def convert_raw_required_body_content_requirements raw_requirements
+          raw_requirements.collect do |string|
+            string.start_with?("%r{") && string.end_with?("}") ? eval(string) : string
+          end
+        end
+
+
+        private
+        def convert_value(value)
+          value.start_with?("%r{") && value.end_with?("}") ? eval(value) : value
+        end
+      end
+    end
+  end
+end

data/server/mock_response.rb

@@ -0,0 +1,242 @@
+require 'binary_data_checker'
+
+require 'hashie/mash'
+module Mirage
+  class ServerResponseNotFound < Exception
+
+  end
+
+  class MalformedResponse < Exception
+
+  end
+
+  class MockResponse
+    class << self
+
+      def find_by_id(id)
+        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 } }
+        end
+      end
+
+      def delete_all
+        responses.clear
+        @next_id = 0
+      end
+
+      #TODO - this is flakey, make a proper copy
+      def backup
+        snapshot.clear and snapshot.replace(responses.deep_clone)
+      end
+
+      def revert
+        delete_all and responses.replace(snapshot.deep_clone)
+      end
+
+      def all
+        responses.values.collect do |response_set|
+          response_set.values
+        end.flatten
+      end
+
+      def find_default(options)
+        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]
+          end
+        end.flatten.compact
+
+        default_responses.find { |response| match?(options, response) } || raise(ServerResponseNotFound)
+      end
+
+      def subdomains(name)
+        domains=[]
+        name.split("/").each do |part|
+          domains << (domains.last ? "#{domains.last}/#{part}" : part)
+        end
+        domains.reverse
+      end
+
+      def find(options)
+        options[:response_set] = responses[options[:endpoint]]
+        find_in_response_set(options) || raise(ServerResponseNotFound)
+      end
+
+      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 }
+        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
+        else
+          new_response.response_id = next_id
+        end
+        method_specific_responses<<new_response
+      end
+
+      private
+      def find_in_response_set(options)
+        response_set = options.delete(:response_set)
+        return unless response_set
+
+        responses_for_http_method = response_set[options[:http_method].upcase] || []
+
+        responses = responses_for_http_method.find_all do |stored_response|
+          match?(options, stored_response)
+        end
+
+        responses.sort { |a, b| b.score <=> a.score }.first
+
+      end
+
+      def match?(options, stored_response)
+        parameters = options[:params]
+        headers = Hash[options[:headers].collect { |key, value| [key.downcase, value] }]
+
+        request_spec = stored_response.request_spec
+
+        match = true
+
+        {request_spec['parameters'] => parameters,
+         request_spec['headers'] => headers}.each do |spec, actual|
+          spec.each do |key, value|
+            value = interpret_value(value)
+            if value.is_a? Regexp
+              match = false unless value.match(actual[key])
+            else
+              match = false unless value == actual[key]
+            end
+          end
+        end
+
+        request_spec['body_content'].each do |value|
+          value = interpret_value(value)
+          if value.is_a? Regexp
+            match = false unless options[:body] =~ value
+          else
+            match = false unless options[:body].include?(value)
+          end
+        end
+
+        match
+      end
+
+      def interpret_value(value)
+        value.start_with?("%r{") && value.end_with?("}") ? eval(value) : value
+      end
+
+      def responses_for_endpoint(response)
+        name = response.name
+        name = %r{#{name.gsub('*', '.*')}} if name =~ /\*/
+        responses[name]||={}
+      end
+
+      def responses
+        @responses ||={}
+      end
+
+      def snapshot
+        @snapshot ||={}
+      end
+
+      def next_id
+        @next_id||= 0
+        @next_id+=1
+      end
+    end
+
+    attr_reader :name, :request_spec, :response_spec
+    attr_accessor :response_id, :requests_url
+
+    def initialize name, spec={}
+
+      request_defaults = JSON.parse({:parameters => {},
+                                     :body_content => [],
+                                     :http_method => 'get',
+                                     :headers => {}}.to_json)
+      response_defaults = JSON.parse({:default => false,
+                                      :body => Base64.encode64(''),
+                                      :delay => 0,
+                                      :content_type => "text/plain",
+                                      :status => 200}.to_json)
+
+      @name = name
+      @spec = spec
+
+      @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 }
+      @binary = BinaryDataChecker.contains_binary_data? @response_spec['body']
+
+      MockResponse.add self
+    end
+
+    def headers
+      @response_spec['headers']
+    end
+
+    def default?
+      @response_spec["default"]
+    end
+
+    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 }
+      end
+    end
+
+    def value(request_body='', request_parameters={}, query_string='')
+      body = Base64.decode64(response_spec['body'])
+      return body if @binary
+
+      value = body.dup
+      value.scan(/\$\{([^\}]*)\}/).flatten.each do |pattern|
+
+        if (parameter_match = request_parameters[pattern])
+          value = value.gsub("${#{pattern}}", parameter_match)
+        end
+
+        [request_body, query_string].each do |string|
+          if (string_match = find_match(string, pattern))
+            value = value.gsub("${#{pattern}}", string_match)
+          end
+        end
+
+      end
+      value
+    end
+
+    def == response
+      response.is_a?(MockResponse) && @name == response.send(:eval, "@name") && @request_spec == response.send(:eval, "@request_spec") && @response_spec == response.send(:eval, "@response_spec")
+    end
+
+    def raw
+      {:id => response_id, :endpoint => @name, :requests_url => requests_url, :response => @response_spec, :request => @request_spec}.to_json
+    end
+
+    def binary?
+      @binary
+    end
+
+    private
+    def find_match(string, regex)
+      string.scan(/#{regex}/).flatten.first
+    end
+
+    def interpret_value(value)
+      value.start_with?("%r{") && value.end_with?("}") ? eval(value) : value
+    end
+
+
+  end
+end