spoofer 0.1.0

data/lib/spoofer/api.rb

@@ -0,0 +1,50 @@
+require 'spoofer'
+
+module Spoofer
+  class API < Sinatra::Base
+    class << self
+      attr_accessor :host
+    end
+
+    def host
+      self.class.host
+    end
+
+    %w{get post put delete head}.each do |verb|
+      post "/#{verb}" do
+        api_request = APIRequest.from_request(request, verb)
+        api_request.setup_stubs_on(host)
+        [201, {"Content-Type" => api_request.request_content_type}, api_request.response]
+      end
+    end
+
+    post "/multi" do
+      api_request = APIRequest.from_request(request)
+      api_request.setup_stubs_on(host)
+      [201, {"Content-Type" => api_request.request_content_type}, api_request.response]
+    end
+
+    post "/clear" do
+      response_body = self.host.inspect
+      self.host.clear
+      [200, {}, "Cleared stubs: #{response_body}"]
+    end
+
+    get "/ping" do
+      [200, {}, "OK"]
+    end
+
+    get "/debug" do
+      [200, {}, self.host.inspect]
+    end
+
+    get "/requests" do
+      [200, {"Content-Type" => "application/json"}, {"requests" => host.received_requests.map(&:to_hash)}.to_json]
+    end
+
+  private
+
+    autoload :ApiRequest, 'spoofer/api/api_request'
+    autoload :Stub, 'spoofer/api/stub'
+  end
+end

data/lib/spoofer/api/api_request.rb

@@ -0,0 +1,49 @@
+require 'spoofer'
+
+module Spoofer
+  class API::APIRequest
+    attr_reader :request_content_type
+
+    def self.from_request(request, method = nil)
+      case request.content_type
+        when /json/
+          data = JSON.parse(request.body.string)
+        when /plist/
+          data = Plist.parse_xml(request.body.string)
+        else
+          data = JSON.parse(request.body.string)
+      end
+      new(data, method, request.content_type)
+    end
+
+    def initialize(data, method = nil, request_content_type = '')
+      @data = data
+      @method = (method || "GET")
+      @stubs = []
+      @request_content_type = request_content_type
+    end
+
+    def to_s
+      @data.inspect
+    end
+
+    def response
+      response = {"stubs" => @stubs.map(&:to_hash)}
+
+      case request_content_type
+      when /json/
+        response.to_json
+      when /plist/
+        response.to_plist
+      else
+        response.to_json
+      end
+    end
+
+    def setup_stubs_on(host)
+      (@data["stubs"] || [@data]).each do |stub_data|
+        @stubs << Stub.new(stub_data, stub_data['method'] || @method).on(host)
+      end
+    end
+  end
+end

data/lib/spoofer/api/stub.rb

@@ -0,0 +1,39 @@
+module Spoofer
+  class API::Stub
+    def initialize(data, method = nil)
+      @data = data
+      @method = method
+    end
+
+    def on(host)
+      host.send(@method.downcase.to_sym, path).returning(body, code, headers).tap do |stub|
+        stub.with_query_parameters(params)
+        stub.echo_request!(echo_format)
+      end
+    end
+
+    def echo_format
+      @data['echo'].to_sym rescue nil
+    end
+
+    def path
+      @data['path'] || '/'
+    end
+
+    def body
+      @data['body'] || ''
+    end
+
+    def code
+      @data['code'] || 200
+    end
+
+    def headers
+      @data['headers'] || {}
+    end
+
+    def params
+      @data['params'] || {}
+    end
+  end
+end

data/lib/spoofer/fake_host.rb

@@ -0,0 +1,102 @@
+require 'spoofer'
+
+module Spoofer
+  class FakeHost
+    autoload :Helpers, 'spoofer/fake_host/helpers'
+    autoload :RequestEcho, 'spoofer/fake_host/request_echo'
+    autoload :StubbedRequest, 'spoofer/fake_host/stubbed_request'
+
+    attr_reader :hostname, :url_map
+    attr_accessor :log
+
+    def initialize(options = {})
+      @hostname = options[:hostname]
+      @remote_configuration_path = options[:remote_configuration_path]
+      @log = options[:log]
+      @imports = []
+      clear
+      build_url_map!
+    end
+
+    def received_requests
+      @stubs.select { |s| s.received }
+    end
+
+    def get(path, &block)
+      request("GET", path, &block)
+    end
+
+    def post(path, &block)
+      request("POST", path, &block)
+    end
+
+    def put(path, &block)
+      request("PUT", path, &block)
+    end
+
+    def delete(path, &block)
+      request("DELETE", path, &block)
+    end
+
+    def head(path, &block)
+      request("HEAD", path, &block)
+    end
+
+    def import(path)
+      if File.exists?(path)
+        @imports << path unless @imports.include?(path)
+        instance_eval(File.read(path))
+      else
+        raise "Could not locate file for stub import: #{path}"
+      end
+    end
+
+    def call(env)
+      @stubs.each(&:build)
+      @app.call(env)
+    end
+
+    def clear
+      @stubs = []
+      @app = Sinatra.new
+      @app.use(Rack::CommonLogger, self.log) if self.log
+      @app.not_found do
+        [404, {}, ""]
+      end
+      @app.helpers do
+        include Helpers
+      end
+      @imports.each { |file| import(file) }
+    end
+
+    def inspect
+      @stubs.inspect
+    end
+
+  private
+
+    def method_missing(method, *args, &block)
+      @app.send(method, *args, &block)
+    end
+
+    def request(method, path, &block)
+      if block_given?
+        @app.send(method.downcase, path, &block)
+      else
+        @stubs << StubbedRequest.new(@app, method, path)
+        @stubs.last
+      end
+    end
+
+    def build_url_map!
+      routes = {'/' => self}
+
+      if @remote_configuration_path
+        API.host = self
+        routes[@remote_configuration_path] = API
+      end
+
+      @url_map = Rack::URLMap.new(routes)
+    end
+  end
+end

data/lib/spoofer/fake_host/helpers.rb

@@ -0,0 +1,11 @@
+require 'spoofer'
+
+module Spoofer
+  module FakeHost::Helpers
+    def echo_request!(format)
+      RequestEcho.new(request).response_as(format)
+    end
+  end
+end
+
+

data/lib/spoofer/fake_host/request_echo.rb

@@ -0,0 +1,42 @@
+module Spoofer
+  class FakeHost::RequestEcho
+    def initialize(request)
+      @request = request
+    end
+
+    def response_as(format)
+      content_type = case format
+      when :json, :plist
+        "application/#{format.to_s.downcase}"
+      else
+        "text/plain"
+      end
+      [200, {"Content-Type" => content_type}, to_s(format)]
+    end
+
+    def to_s(format)
+      case format
+        when :json
+          to_hash.to_json
+        when :plist
+          to_hash.to_plist
+        when :text
+          to_hash.inspect
+      end
+    end
+
+    def to_hash
+      {"echo" => {
+        "params" => @request.params,
+        "env"    => env_without_rack_and_async_env,
+        "body"   => @request.body.read
+      }}
+    end
+
+  private
+
+    def env_without_rack_and_async_env
+      Hash[*@request.env.select { |key, value| key !~ /^(rack|async)/i }.flatten]
+    end
+  end
+end

data/lib/spoofer/fake_host/stubbed_request.rb

@@ -0,0 +1,73 @@
+require 'spoofer'
+
+module Spoofer
+  class FakeHost::StubbedRequest
+    attr_accessor :received
+
+    def initialize(app, method, path)
+      @method, @path = method, path
+      @code = 200
+      @headers = {}
+      @params = {}
+      @body = ""
+      @app = app
+      @received = false
+    end
+
+    def to_hash
+      token = "#{@method} #{@path}"
+      Digest::MD5.hexdigest(token)
+    end
+
+    def returning(body, code=200, headers={})
+      tap do
+        @body = body
+        @code = code
+        @headers = headers
+      end
+    end
+
+    def with_query_parameters(params)
+      tap do
+        @params = params
+      end
+    end
+
+    def echo_request!(format=:json)
+      @echo_request_format = format
+    end
+
+    def matches?(request)
+      if @params.any?
+        request.params == @params
+      else
+        true
+      end
+    end
+
+    def matched_response
+      [@code, @headers, @body]
+    end
+
+    def unmatched_response
+      [404, "", {}]
+    end
+
+    def response_for_request(request)
+      if @echo_request_format
+        @body = RequestEcho.new(request).to_s(@echo_request_format)
+      end
+
+      matches?(request) ? matched_response : unmatched_response
+    end
+
+    def build
+      stub = self
+
+      @app.send(@method.downcase, @path) do
+        stub.received = true
+        stub.response_for_request(request)
+      end
+    end
+  end
+end

data/lib/spoofer/version.rb

@@ -0,0 +1,3 @@
+module Spoofer
+  VERSION = '0.1.0'
+end

data/spec/fixtures/import_stubs.spoof

@@ -0,0 +1,3 @@
+get "/imported/path" do
+  [200, {}, ""]
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'spoofer'
+
+require 'rspec'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.tty = true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/spoofer/fake_host_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Spoofer::FakeHost do
+  let(:host) { described_class.new(:hostname => "www.example.com") }
+
+  it "should handle stubbed requests" do
+    host.get("/some/path")
+    host.call(request_for("/some/path")).should match_rack_response(200, {}, "")
+  end
+
+  it "should handle stubbed requests that return a response" do
+    host.get("/some/path").returning("hello world")
+    host.call(request_for("/some/path")).should match_rack_response(200, {}, "hello world")
+  end
+
+  it "should handle stubbed requests that return a specific HTTP code" do
+    host.get("/some/path").returning("redirecting", 301)
+    host.call(request_for("/some/path")).should match_rack_response(301, {}, "redirecting")
+  end
+
+  it "should handle stubbed requests that return specific headers" do
+    host.get("/some/path").returning("redirecting", 301, {"Location" => "http://somewhereelse.com"})
+    host.call(request_for("/some/path")).should match_rack_response(301, {"Location" => "http://somewhereelse.com"}, "redirecting")
+  end
+
+  it "should not recognize requests if they have the incorrect HTTP method" do
+    host.get("/some/path")
+    host.call(request_for("/some/path", :method => "POST")).should match_rack_response(404, {}, "")
+  end
+
+  it "should not handle multiple requests to a path with different HTTP methods" do
+    host.get("/some/path").returning("GET Request", 200)
+    host.post("/some/path").returning("POST Request", 201)
+    host.call(request_for("/some/path", :method => "GET")).should match_rack_response(200, {}, "GET Request")
+    host.call(request_for("/some/path", :method => "POST")).should match_rack_response(201, {}, "POST Request")
+  end
+
+  it "should handle requests with behaviour specified in a block using the Sinatra API" do
+    host.get("/some/path") do
+      content_type 'text/plain'
+      'bobby'
+    end
+    host.call(request_for("/some/path", :method => "GET")).should match_rack_response(200, {'Content-Type' => 'text/plain;charset=utf-8'}, 'bobby')
+  end
+
+  it "should allow stubs to be cleared" do
+    host.get("/some/path")
+    host.call(request_for("/some/path")).should match_rack_response(200, {}, "")
+    host.clear
+    host.call(request_for("/some/path")).should match_rack_response(404, {}, "")
+  end
+
+  it "should allow stubs to be imported from a file" do
+    host.import(File.join(File.dirname(__FILE__), *%w[.. fixtures import_stubs.spoof]))
+    host.call(request_for("/imported/path")).should match_rack_response(200, {}, "")
+  end
+
+  it "should not clear imported stubs" do
+    host.import(File.join(File.dirname(__FILE__), *%w[.. fixtures import_stubs.spoof]))
+    host.clear
+    host.call(request_for("/imported/path")).should match_rack_response(200, {}, "")
+  end
+
+  it "should raise if import file does not exist" do
+    proc {
+      host.import(File.join(File.dirname(__FILE__), *%w[.. fixtures doesnt_exist.spoof]))
+    }.should raise_error
+  end
+
+  it "returns a StubbedRequest" do
+    host.get("/some/path").should be_kind_of(Spoofer::FakeHost::StubbedRequest)
+  end
+
+end