m2r 0.0.3 → 1.0.0

data/test/acceptance/examples_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module M2R
+  class ExamplesTest < MiniTest::Unit::TestCase
+    include MongrelHelper
+
+    def test_rack_example
+      user = TestUser.new
+      user.visit("/handler")
+      user.see!("SENDER", "PATH", "HEADERS", "x-forwarded-for", "x-forwarded-for", "BODY")
+    end
+
+    def test_handler_example
+      user = TestUser.new
+      user.visit("/rack")
+      assert user.find("pre").text.include?(" {{{{{{ { ( ( (  (   (-----:=")
+      user.click_on("flip!")
+      assert user.find("pre").text.include?("=:-----(   (  ( ( ( { {{{{{{")
+    end
+
+    def test_handler_async_uploading
+      Dir.glob('example/tmp/upload*') {|p| File.delete(p) }
+      user = TestUser.new
+      user.visit("/uploading")
+      user.attach_and_submit_first_file('uploading_form', user.generate_file)
+      user.visit("/uploading")
+      user.see!("Last submitted file was of size: 10240")
+      assert_equal 0, Dir.glob('example/tmp/upload*').size
+    end
+
+  end
+end

data/test/support/capybara.rb

@@ -0,0 +1,4 @@
+require 'capybara'
+require 'capybara/mechanize'
+
+Capybara.app_host = "http://localhost:6767/"

data/test/support/mongrel_helper.rb

@@ -0,0 +1,40 @@
+require 'timeout'
+
+module MongrelHelper
+  attr_accessor :pid
+
+  def setup
+    check_mongrel
+    `cd example && m2sh load -config mongrel2.conf --db config.sqlite`
+    self.pid = Process.spawn("bundle exec foreman start --procfile=example/Procfile", pgroup: 0, out: "/dev/null", err: "/dev/null")
+    wait_for_pid('example/tmp/mongrel2.pid')
+  end
+
+  def teardown
+    Process.kill("SIGTERM", pid) if pid
+    sleep 1
+  end
+
+  def check_mongrel
+    skip("You must install mongrel2 to run this test") if `which mongrel2`.empty?
+  end
+
+  def read_pid_from_file(pidfile)
+    pid = nil
+    Timeout.timeout(5) do
+      loop do
+        begin
+          pid = File.read(pidfile)
+          break unless pid.empty?
+        rescue Errno::ENOENT
+          sleep(0.25)
+          next
+        end
+      end
+      pid.to_i
+    end
+  rescue Timeout::Error
+    raise "Unable to read PID from file #{pidfile}."
+  end
+  alias :wait_for_pid :read_pid_from_file
+end

data/test/support/test_handler.rb

@@ -0,0 +1,51 @@
+require 'm2r/handler'
+
+class TestHandler < M2R::Handler
+  attr_reader :called_methods
+  def initialize(connection)
+    super
+    @called_methods = []
+  end
+
+  def on_wait()
+    unless @called_methods.empty?
+      stop
+      return
+    end
+    @called_methods << :wait
+  end
+
+  def on_request(request)
+    @called_methods << :request
+  end
+
+  def process(request)
+    @called_methods << :process
+    return "response"
+  end
+
+  def on_disconnect(request)
+    @called_methods << :disconnect
+  end
+
+  def on_upload_start(request)
+    @called_methods << :start
+  end
+
+  def on_upload_done(request)
+    @called_methods << :done
+  end
+
+  def after_process(request, response)
+    @called_methods << :after
+    return response
+  end
+
+  def after_reply(request, response)
+    @called_methods << :reply
+  end
+
+  def after_all(request, response)
+    @called_methods << :all
+  end
+end

data/test/support/test_user.rb

@@ -0,0 +1,37 @@
+require 'bbq/test'
+require 'bbq/test_user'
+require 'support/capybara'
+
+class TestUser < Bbq::TestUser
+  include MiniTest::Assertions
+
+  def initialize
+    super(:driver => :mechanize)
+  end
+
+  def see!(*args)
+    msg = "Expected to see %s but not found"
+    args.each { |arg| assert has_content?(arg), msg % arg }
+  end
+
+  def generate_file
+    File.open(@path = "./tmp/#{Time.now.to_i}", "w") do |f|
+      f.write SecureRandom.hex(5120)
+    end
+    file_path
+  end
+
+  def attach_first_file(form_id, file_path)
+    page.driver.browser.agent.current_page.form_with(id: form_id) do |form|
+      form.file_uploads.first.file_name = file_path
+    end
+  end
+
+  def attach_and_submit_first_file(form_id, file_path)
+    attach_first_file(form_id, file_path).submit
+  end
+
+  def file_path
+    @path
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+require 'mocha'
+require 'm2r'
+
+Dir[File.expand_path(File.join(__FILE__, '../support/*.rb'))].each { |m| require m }

data/test/unit/connection_factory_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'securerandom'
+
+module M2R
+  class ConnectionFactoryTest < MiniTest::Unit::TestCase
+    def test_factory
+      sender_id = "sid"
+      request_addr = "req"
+      response_addr = "req"
+      request_parser = Object.new
+
+      pull    = stub(:pull)
+      pub     = stub(:pub)
+      context = stub(:context)
+
+      context.expects(:socket).with(ZMQ::PULL).returns(pull)
+      context.expects(:socket).with(ZMQ::PUB).returns(pub)
+
+      pull.expects(:connect).with(request_addr)
+
+      pub.expects(:connect).with(response_addr)
+      pub.expects(:setsockopt).with(ZMQ::IDENTITY, sender_id)
+
+      Connection.expects(:new).with(pull, pub, request_parser)
+      cf = ConnectionFactory.new sender_id, request_addr, response_addr, request_parser, context
+      cf.connection
+    end
+  end
+end

data/test/unit/connection_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'securerandom'
+
+module M2R
+  class ConnectionTest < MiniTest::Unit::TestCase
+
+    def setup
+      @request_addr  = "inproc://#{SecureRandom.hex}"
+      @response_addr = "inproc://#{SecureRandom.hex}"
+
+      @push = M2R.zmq_context.socket(ZMQ::PUSH)
+      assert_equal 0, @push.bind(@request_addr), "Could not bind push socket in tests"
+
+      @sub = M2R.zmq_context.socket(ZMQ::SUB)
+      assert_equal 0, @sub.bind(@response_addr), "Could not bind sub socket in tests"
+
+
+      @request_socket = M2R.zmq_context.socket(ZMQ::PULL)
+      @request_socket.connect(@request_addr)
+
+      @response_socket = M2R.zmq_context.socket(ZMQ::PUB)
+      @response_socket.connect(@response_addr)
+      @response_socket.setsockopt(ZMQ::IDENTITY, @sender_id = SecureRandom.uuid)
+    end
+
+    def teardown
+      @request_socket.close  if @request_socket
+      @response_socket.close if @response_socket
+      @push.close            if @push
+      @sub.close             if @sub
+    end
+
+    def test_receive_message
+      connection = Connection.new(@request_socket, @response_socket)
+      @push.send_string("1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NOBLOCK)
+      assert_instance_of Request, connection.receive
+    end
+
+    def test_different_parser
+      msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,"
+      parser = stub(:parser)
+      parser.expects(:parse).with(msg).returns(request = Object.new)
+      connection = Connection.new(@request_socket, @response_socket, parser)
+      @push.send_string(msg = "1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 2:{},0:,", ZMQ::NOBLOCK)
+      assert_equal request, connection.receive
+    end
+
+  end
+end

data/test/unit/handler_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module M2R
+  class HandlerTest < MiniTest::Unit::TestCase
+    def test_lifecycle_for_disconnect
+      connection = stub(:receive => disconnect_request)
+      connection.stubs(:connection).returns(connection)
+      h = TestHandler.new(connection)
+      h.listen
+      assert_equal [:wait, :request, :disconnect, :all], h.called_methods
+    end
+
+    def test_lifecycle_for_upload_start
+      connection = stub(:receive => upload_start_request)
+      connection.stubs(:connection).returns(connection)
+      h = TestHandler.new(connection)
+      h.listen
+      assert_equal [:wait, :request, :start, :all], h.called_methods
+    end
+
+    def test_lifecycle_for_upload_done
+      connection = stub(:receive => upload_done_request, :reply => nil)
+      connection.stubs(:connection).returns(connection)
+      h = TestHandler.new(connection)
+      h.listen
+      assert_equal [:wait, :request, :done, :process, :after, :reply, :all], h.called_methods
+    end
+
+    def disconnect_request
+      Request.new("sender", "conn_id", "/path", Headers.new({"METHOD" => "JSON"}), '{"type":"disconnect"}')
+    end
+
+    def upload_start_request
+      Request.new("sender", "conn_id", "/path", Headers.new({"x-mongrel2-upload-start" => "/tmp/file"}), '')
+    end
+
+    def upload_done_request
+      Request.new("sender", "conn_id", "/path", Headers.new({"x-mongrel2-upload-start" => "/tmp/file", "x-mongrel2-upload-done" => "/tmp/file"}), '')
+    end
+  end
+end

data/test/unit/headers_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module M2R
+  class HeadersTest < MiniTest::Unit::TestCase
+    def test_case_insensitivity
+      headers = Headers.new({"Content-Type" => "CT"})
+      assert_equal "CT", headers['content-type']
+      assert_equal "CT", headers['Content-Type']
+      assert_equal "CT", headers['Content-type']
+    end
+
+    def test_underscore
+      headers = Headers.new({"URL_SCHEME" => "https"})
+      assert_equal "https", headers['url_scheme']
+    end
+
+    def test_symbols_as_keys
+      headers = Headers.new({"type" => "Ty"})
+      assert_equal "Ty", headers[:type]
+    end
+
+    def test_rackify
+      headers = Headers.new({
+        "Content-Type" => "CT",
+        "type" => "Ty",
+        "Accept-Charset" => "utf8",
+        "cOnTenT-LeNgTh" => "123"
+      })
+      env = {"rack.version" => [1,1]}
+      headers.rackify(env)
+      assert_equal({
+        "rack.version" => [1,1],
+        "CONTENT_TYPE" => "CT",
+        "HTTP_TYPE"    => "Ty",
+        "HTTP_ACCEPT_CHARSET" => "utf8",
+        "CONTENT_LENGTH" => "123"
+      }, env)
+    end
+
+    def test_rackify_empty_headers
+      headers = Headers.new({})
+      env = {"rack.something" => "value"}
+      headers.rackify(env)
+      assert_equal({
+        "rack.something" => "value",
+      }, env)
+    end
+
+  end
+end

data/test/unit/m2r_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'timeout'
+
+module M2R
+  class ModuleTest < MiniTest::Unit::TestCase
+    def setup
+      if context = M2R.instance_variable_get(:@zmq_context)
+        context.send(:remove_finalizer) if context.respond_to?(:remove_finalizer)
+        M2R.instance_variable_set(:@zmq_context, nil)
+      end
+    end
+
+    def test_mongrel2_context_getter
+      assert_instance_of ZMQ::Context, M2R.zmq_context
+    end
+
+    def test_mongrel2_context_setter
+      ctx = ZMQ::Context.new(2)
+      M2R.zmq_context = ctx
+      assert_equal ctx, M2R.zmq_context
+    end
+
+    def test_only_1_context_created_when_race_condition
+      threads = nil
+      ZMQ::Context.expects(:new).returns(true).once
+
+      Thread.exclusive do
+        threads = 512.times.map do
+          Thread.new do
+            M2R.zmq_context
+          end
+        end
+      end
+      Timeout.timeout(5) do
+        threads.each(&:join)
+      end
+    end
+
+  end
+end

data/test/unit/rack_handler_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+require 'm2r/rack_handler'
+
+class HelloWorld
+  def call(env)
+    return [200, {'Content-Type' => 'text/plain'}, ["Hello world!"]]
+  end
+end
+
+module M2R
+  class RackHandlerTest < MiniTest::Unit::TestCase
+    def test_discoverability
+      handler = ::Rack::Handler.get(:mongrel2)
+      assert_equal ::Rack::Handler::Mongrel2, handler
+
+      handler = ::Rack::Handler.get('Mongrel2')
+      assert_equal ::Rack::Handler::Mongrel2, handler
+    end
+
+    def test_options
+      require 'rack/handler/mongrel2'
+      handler = ::Rack::Handler::Mongrel2
+      options = {
+        'recv_addr' => recv = 'tcp://1.2.3.4:1234',
+        'send_addr' => send = 'tcp://1.2.3.4:4321',
+        'sender_id' => id   = SecureRandom.uuid
+      }
+      cf = mock(:connection)
+      ConnectionFactory.expects(:new).with(id, recv, send).returns(cf)
+      RackHandler.any_instance.stubs(:stop? => true)
+      handler.run(HelloWorld.new, options)
+    end
+
+    def test_lint_rack_adapter
+      factory    = stub(:connection)
+      handler    = RackHandler.new(app, factory)
+      response   = handler.process(root_request)
+
+      assert_equal "Hello world!", response.body
+      assert_equal 200, response.status
+    end
+
+    def root_request
+      data = %q("1c5fd481-1121-49d8-a706-69127975db1a ebb407b2-49aa-48a5-9f96-9db121051484 / 96:{"PATH":"/","host":"127.0.0.1:6767","PATTERN":"/","METHOD":"GET","VERSION":"HTTP/1.1","URI":"/"},0:,)
+      Request.parse(data)
+    end
+
+    def app
+      Rack::Lint.new(HelloWorld.new)
+    end
+  end
+end