moxy 0.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,3 @@
+source :gemcutter
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    moxy (0.0.1)
+      fakefs
+      rack-flash
+      sinatra
+      webmock
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    backports (2.3.0)
+    crack (0.3.1)
+    fakefs (0.4.0)
+    monkey-lib (0.5.4)
+      backports
+    multi_json (1.0.3)
+    rack (1.3.4)
+    rack-flash (0.1.2)
+      rack
+    rack-protection (1.1.4)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rr (1.0.4)
+    simplecov (0.5.4)
+      multi_json (~> 1.0.3)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    sinatra (1.3.1)
+      rack (>= 1.3.4, ~> 1.3)
+      rack-protection (>= 1.1.2, ~> 1.1)
+      tilt (>= 1.3.3, ~> 1.3)
+    sinatra-advanced-routes (0.5.1)
+      monkey-lib (~> 0.5.0)
+      sinatra (~> 1.0)
+      sinatra-sugar (~> 0.5.0)
+    sinatra-reloader (0.5.0)
+      sinatra (~> 1.0)
+      sinatra-advanced-routes (~> 0.5.0)
+    sinatra-sugar (0.5.1)
+      monkey-lib (~> 0.5.0)
+      sinatra (~> 1.0)
+    tilt (1.3.3)
+    watchr (0.7)
+    webmock (1.7.6)
+      addressable (> 2.2.5, ~> 2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  moxy!
+  rack-test
+  rr
+  simplecov
+  simplecov-html
+  sinatra-reloader
+  watchr

data/README.md

@@ -0,0 +1,84 @@
+# Moxy
+
+Moxy (or `moxy`) is a programmable mock proxy. It is an HTTP proxy exposing web hooks that you can use in order to tell it what to do, and when to do it.
+
+For example, you might want to set up that a request to `http://google.com` will return the text `boo hoo`. Thats easy:
+
+  $ curl -d "mock_text=stub_request(:get, 'http://google.com').to_return(:body=>'boo hoo')" http://localhost:9292/__setup__ 
+
+However, moxy was not made just for one-offs. It was made in order to allow you to use such things in automated integration tests.
+
+Here is an example in Ruby:
+
+	it "should handle google crashes" do
+		# setup responses at moxie.
+		HTTParty.post('http://localhost:9292/__setup__', 
+		          :body=>{
+		            :mock_text=>'stub_request(:get, "http://google.com?q=moxie").to_return(:status=>401)'
+		          })
+
+		r = Google.get("http://google.com?q=moxie")
+
+		r.code.must_equal 401
+	end
+
+See more languages and use cases in `/examples`.  
+
+
+But these kind of things can already be done using `rack-test`, and other abstraction/mocking frameworks in other languages. Moxy can be an **extremely fitting** answer to your problems when:
+
+* The juice is not worth the squeeze. You need to integration test but you don't want/need to invest effort in convoluted HTTP abstracting test code and helpers. Just set up a real response and go.
+
+* The language / platform is not worth the squeeze. Some platforms and languages just aren't as great as Ruby. In .NET, for example, some parts of the framework don't allow for (real) testing. Using moxy clears this up pretty easily!.
+
+* You need a proxy which is programmable. Reply with pre-programmed responses, send back files, or just pre-program to return all sorts of errors that blow in your face.
+
+
+
+
+## Getting Started
+
+Run `gem install moxy`
+
+
+### As a system executable
+
+	$ moxy  # no arguments, default to localhost, 9292
+	$ moxy integration-notifier.dev.com 3000 
+
+### As a Web app
+
+	$ git clone https://github.com/jondot/moxy
+	$ cd moxy; rackup
+
+A web app is great for a dedicated integration server. Moxy will run on any rack handler.
+
+
+
+## Using Moxy
+
+1. Set `http://moxy-host:port` as a system proxy, or a proxy in your HTTP library in your code.
+2. Issue any number of POSTs to your `http://moxy-host:port/__setup__` endpoint with a POST variable named `mock_text`.
+
+Below are some examples of `mock_text` (in each, second line describes result).
+
+  stub_request :get, "http://google.com"
+  (Returns an empty content with 200 HTTP status code)
+
+
+  stub_request(:get, "http://google.com").to_return(:body => "boo hoo!")
+  (Returns boo hoo! as content)
+
+
+  stub_request(:get, "http://google.com").to_return(:body => "boo hoo!", :code => 500)
+  (Returns boo hoo! as content)
+
+
+## Contributing
+
+Fork, implement, add tests, pull request, get my everlasting thanks and a respectable place here :).
+
+
+## Copyright
+
+Copyright (c) 2011 [Dotan Nahum](http://gplus.to/dotan) [@jondot](http://twitter.com/jondot). See MIT-LICENSE for further details.

data/Rakefile

@@ -0,0 +1,16 @@
+$: << '.'
+$: << File.expand_path('lib', File.dirname(__FILE__))
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require "bundler/gem_tasks"
+
+require 'moxy'
+
+
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end

data/bin/moxy

@@ -0,0 +1,6 @@
+require 'bundler/setup'
+require 'sinatra' # not requiring rack to avoid gem conflicts.
+
+Rack::Server.start :config => File.expand_path('../config.ru', File.dirname(__FILE__)), 
+				   :Host => ARGV[0] || "0.0.0.0",
+				   :Port => ARGV[1] || 9292 

data/config.ru

@@ -0,0 +1,14 @@
+$: << '.'
+$: << File.expand_path('lib', File.dirname(__FILE__))
+require 'bundler/setup'
+require 'moxy'
+require 'moxy/app'
+
+
+map "/" do
+  run Moxy::WebMockHandler.new
+end
+
+map "/__setup__" do
+  run Moxy::App
+end

data/examples/testing_with_minitest.rb

@@ -0,0 +1,28 @@
+require 'httparty'
+require 'minitest/autorun'
+
+class Google
+  include HTTParty
+  format :html
+end
+
+# globally set to our moxie instance.
+Google.http_proxy 'localhost', 9292
+
+
+describe Google do
+  it "should handle google crashes" do
+    # setup responses at moxie.
+    HTTParty.post('http://localhost:9292/__setup__', 
+                  :body=>{
+                    :mock_text=>'stub_request(:get, "http://google.com?q=moxie").to_return(:status=>401)'
+                  })
+
+    r = Google.get("http://google.com?q=moxie")
+
+    # betcha didn't expect that one from google Search!
+    r.code.must_equal 401
+  end
+end
+
+

data/examples/testing_with_pyunit.py

@@ -0,0 +1,18 @@
+import urllib
+import unittest
+
+# Pythonistas, set up a global proxy.
+# i'm doing it with: 
+#
+#   $ export http_proxy="http://localhost:9292"
+#
+# before test run.
+
+class TestGoogle(unittest.TestCase):
+    def test_google_unauthorized(self): # passing self, heh.
+        params = urllib.urlencode({'mock_text': 'stub_request(:get, "http://google.com?q=moxie").to_return(:status=>401)'})
+        urllib.urlopen("http://google.com/__setup__",params).read()
+        self.assertRaises(IOError, urllib.urlopen, "http://google.com/?q=moxie") # seriously, python.
+
+if __name__ == '__main__':
+    unittest.main()

data/lib/moxy.rb

@@ -0,0 +1,8 @@
+require 'webmock'
+require 'moxy/version'
+require 'moxy/webmock_handler'
+require 'moxy/app'
+
+module Moxy
+
+end

data/lib/moxy/app.rb

@@ -0,0 +1,70 @@
+require 'sinatra'
+require 'rack-flash'
+require 'sinatra/reloader'
+require 'moxy/sandbox_eval'
+
+
+module Moxy
+  class App < Sinatra::Base
+    filedir = File.dirname(__FILE__)
+    set :public_folder, File.expand_path("../../public", filedir)
+    set :views, File.expand_path("../../views", filedir)
+    enable :sessions
+    use Rack::Flash
+
+    configure(:development) do
+      register Sinatra::Reloader
+    end
+
+    helpers do
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      def current_section
+        url_path request.path_info.sub('/','').split('/')[0].downcase
+      end
+
+      def current_page
+        url_path request.path_info.sub('/','')
+      end
+
+      def url_path(*path_parts)
+        [ path_prefix, path_parts ].join("/").squeeze('/')
+      end
+      alias_method :u, :url_path
+
+      def path_prefix
+        request.env['SCRIPT_NAME']
+      end
+    end
+
+    get '/reset' do
+      WebMock.reset!
+      redirect path_prefix
+    end
+
+    get '/current' do
+      @reqs = WebMock::StubRegistry.instance.request_stubs.each { |r| r.to_s } || []
+      erb :current
+    end
+
+    get '/' do
+      @numreqs = WebMock::StubRegistry.instance.request_stubs.size
+      erb :editor
+    end
+
+    post '/' do
+      flag, res = SandboxEval.new(development?).evaluate(params[:mock_text]) if params[:mock_text]
+      
+      if(flag == :ok)
+        flash[:notice] = "Your request #{res} have been registered."
+      elsif
+        flash[:error]  = "Error registering this request: #{res}"
+        headers 'x-moxy-errors' => "#{flag}: #{res}"
+      end
+      redirect path_prefix
+    end
+  end
+end
+
+

data/lib/moxy/sandbox_eval.rb

@@ -0,0 +1,45 @@
+require 'fakefs/safe'
+
+module Moxy
+  class SandboxEval
+    def initialize(verbose=false)
+      @verbose = verbose
+    end
+    def setup_code
+      "include WebMock::API"
+    end
+
+    def evaluate(unsafe_code)
+      # run something
+
+      begin
+        FakeFS.activate!
+        cmd = <<-EOF
+        #{setup_code}
+        FakeFS::FileSystem.clear
+        $SAFE = 3
+        $stdout = StringIO.new
+        begin
+          #{unsafe_code}
+        end
+        EOF
+        puts "evaling:\n-------->>\n#{cmd}\n-------->>" if @verbose
+
+        stdout_id = $stdout.to_i
+        $stdout = StringIO.new
+
+        result = Thread.new { eval cmd, TOPLEVEL_BINDING }.value
+        [:ok, result]
+      rescue SecurityError => e
+        return [:illegal, e]
+      rescue Exception => e
+        return [:error, e]
+      ensure
+        $stdout = IO.new(stdout_id)
+        FakeFS.deactivate!
+      end
+    end
+
+  
+  end
+end

data/lib/moxy/version.rb

@@ -0,0 +1,3 @@
+module Moxy
+  VERSION = "0.0.1"
+end

data/lib/moxy/webmock_handler.rb

@@ -0,0 +1,72 @@
+module Moxy
+  class WebMockHandler
+    def self.build_request_signature(req)
+      uri = WebMock::Util::URI.heuristic_parse(req.url)
+      uri.path = uri.normalized_path.gsub("[^:]//","/")
+
+      #todo: authorization, see #https://github.com/bblimke/webmock/blob/master/lib/webmock/http_lib_adapters/net_http.rb
+      client_headers = {}
+      req.env.keys.grep(/^HTTP_/).each do |k|
+        client_headers[k[5..-1]] = req.env[k]   #remove client headers prefix 'http_'
+      end
+
+      request_signature = WebMock::RequestSignature.new(
+        req.request_method.downcase.to_sym,
+        uri.to_s,
+        :body => req.body.read,
+        :headers => client_headers
+      )
+      request_signature
+    end
+
+    def self.build_rack_response(webmock_response)
+      webmock_response.raise_error_if_any
+      [webmock_response.status[0], webmock_response.headers || {}, bodify(webmock_response.body)]
+    end
+
+    def self.bodify(body)
+      body.respond_to?(:each) ? body : [body]
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+
+      request_signature = Moxy::WebMockHandler.build_request_signature(req)
+      WebMock::RequestRegistry.instance.requested_signatures.put(request_signature)
+
+      begin
+        if WebMock::StubRegistry.instance.registered_request?(request_signature)
+          webmock_response = WebMock::StubRegistry.instance.response_for_request(request_signature)
+          # todo - originally 'handle file name' in patron. why?
+          # WebMock::HttpLibAdapters::PatronAdapter.handle_file_name(req, webmock_response)
+          res = Moxy::WebMockHandler.build_rack_response(webmock_response)
+          WebMock::CallbackRegistry.invoke_callbacks({:lib => :patron}, request_signature, webmock_response)
+        elsif WebMock.net_connect_allowed?(request_signature.uri)
+          res = handle_request_without_webmock(req)
+          if WebMock::CallbackRegistry.any_callbacks?
+            webmock_response = WebMock::HttpLibAdapters::PatronAdapter.
+            build_webmock_response(res)
+            WebMock::CallbackRegistry.invoke_callbacks({:lib => :patron, :real_request => true}, request_signature, webmock_response)
+          end
+        else
+          raise WebMock::NetConnectNotAllowedError.new(request_signature)
+        end
+
+
+
+
+        res[1]['content-type'] ||= 'text/html' #passing rack-lint, see http://rack.rubyforge.org/doc/SPEC.html
+      #todo - what about content-length when it doesn't come from
+      #webmock? does it get calculated automatically be webmock?
+
+       return res
+
+      rescue WebMock::NetConnectNotAllowedError => ex
+        return [500, 
+                {"content-type" => "text/plain", 
+                 "content-length" => ex.message.length.to_s},
+                Moxy::WebMockHandler.bodify(ex.message.to_s)]
+      end
+    end
+  end
+end