rack-rabbit 0.5.0

data/test/unit/test_handler.rb

@@ -0,0 +1,92 @@
+require_relative '../test_case'
+
+module RackRabbit
+  class TestHandler < TestCase
+
+    #--------------------------------------------------------------------------
+
+    def test_handle_message
+
+      handler = build_handler
+      message = build_message
+
+      response = handler.handle(message)
+
+      assert_equal(200,           response.status)
+      assert_equal({},            response.headers)
+      assert_equal("Hello World", response.body)
+      
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_handle_GET
+
+      handler = build_handler(:rack_file => MIRROR_RACK_APP)
+      message = build_message(:method => :GET, :path => "/my/path?foo=bar", :body => "hello")
+
+      response = handler.handle(message)
+      mirror   = JSON.parse(response.body)
+
+      assert_equal(200,        response.status)
+      assert_equal("GET",      mirror["method"])
+      assert_equal("/my/path", mirror["path"])
+      assert_equal("bar",      mirror["params"]["foo"])
+      assert_equal("hello",    mirror["body"])
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_handle_POST
+
+      handler  = build_handler(:rack_file => MIRROR_RACK_APP)
+      message  = build_message(:method => :POST, :path => "/my/path?foo=bar", :body => "hello")
+
+      response = handler.handle(message)
+      mirror   = JSON.parse(response.body)
+
+      assert_equal(200,        response.status)
+      assert_equal("POST",     mirror["method"])
+      assert_equal("/my/path", mirror["path"])
+      assert_equal("bar",      mirror["params"]["foo"])
+      assert_equal("hello",    mirror["body"])
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_handle_POST_form_data
+
+      handler  = build_handler(:rack_file => MIRROR_RACK_APP)
+      message  = build_message(:method => :POST, :path => "/my/path", :body => "foo=bar", :content_type => CONTENT::FORM_URLENCODED)
+
+      response = handler.handle(message)
+      mirror   = JSON.parse(response.body)
+
+      assert_equal(200,        response.status)
+      assert_equal("POST",     mirror["method"])
+      assert_equal("/my/path", mirror["path"])
+      assert_equal("bar",      mirror["params"]["foo"])
+      assert_equal("foo=bar",  mirror["body"])
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_handle_message_that_causes_rack_app_to_raise_an_exception
+
+      handler  = build_handler(:rack_file => ERROR_RACK_APP)
+      message  = build_message
+      response = handler.handle(message)
+
+      assert_equal(500,                     response.status)
+      assert_equal("Internal Server Error", response.body)
+      assert_equal({},                      response.headers)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class TestHandler
+end # module RackRabbit

data/test/unit/test_message.rb

@@ -0,0 +1,213 @@
+require_relative '../test_case'
+
+module RackRabbit
+  class TestMessage < TestCase
+
+    #--------------------------------------------------------------------------
+
+    def test_default_message
+
+      message = build_message
+
+      assert_equal(nil,   message.delivery_tag)
+      assert_equal(nil,   message.reply_to)
+      assert_equal(nil,   message.correlation_id)
+      assert_equal(nil,   message.body)
+      assert_equal({},    message.headers)
+      assert_equal(:GET,  message.method)
+      assert_equal("",    message.uri)
+      assert_equal(nil,   message.status)
+      assert_equal(nil,   message.path)
+      assert_equal(nil,   message.query)
+      assert_equal(nil,   message.content_type)
+      assert_equal(nil,   message.content_encoding)
+      assert_equal(0,     message.content_length)
+      assert_equal(false, message.should_reply?)
+      assert_equal(false, message.acknowledged?)
+      assert_equal(false, message.rejected?)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_populated_message
+
+      headers = { "additional" => "header" }
+
+      message = build_message({
+        :delivery_tag     => DELIVERY_TAG,
+        :reply_to         => REPLY_TO,
+        :correlation_id   => CORRELATION_ID,
+        :content_type     => CONTENT::PLAIN_TEXT,
+        :content_encoding => CONTENT::UTF8,
+        :method           => :POST,
+        :path             => URI,
+        :status           => 200,
+        :headers          => headers,
+        :body             => BODY
+      })
+
+      assert_equal(DELIVERY_TAG,        message.delivery_tag)
+      assert_equal(REPLY_TO,            message.reply_to)
+      assert_equal(CORRELATION_ID,      message.correlation_id)
+      assert_equal(BODY,                message.body)
+      assert_equal(headers,             message.headers)
+      assert_equal(:POST,               message.method)
+      assert_equal(URI,                 message.uri)
+      assert_equal(200,                 message.status)
+      assert_equal(PATH,                message.path)
+      assert_equal(QUERY,               message.query)
+      assert_equal(CONTENT::PLAIN_TEXT, message.content_type)
+      assert_equal(CONTENT::UTF8,       message.content_encoding)
+      assert_equal(BODY.length,         message.content_length)
+      assert_equal(true,                message.should_reply?)
+      assert_equal(false,               message.acknowledged?)
+      assert_equal(false,               message.rejected?)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_get_rack_env
+
+      config = build_config(:app_id => APP_ID)
+
+      message = build_message({
+        :method           => :GET,
+        :path             => URI,
+        :body             => BODY,
+        :content_type     => CONTENT::PLAIN_TEXT,
+        :content_encoding => CONTENT::UTF8,
+        :headers          => { "additional" => "header" }
+      })
+
+      env = message.get_rack_env(config.rack_env)
+
+      assert_equal(message,                  env['rabbit.message'])
+      assert_equal(BODY,                     env['rack.input'].read)
+      assert_equal(:GET,                     env['REQUEST_METHOD'])
+      assert_equal(URI,                      env['REQUEST_PATH'])
+      assert_equal(PATH,                     env['PATH_INFO'])
+      assert_equal(QUERY,                    env['QUERY_STRING'])
+      assert_equal(CONTENT::PLAIN_TEXT_UTF8, env['CONTENT_TYPE'])
+      assert_equal(BODY.length,              env['CONTENT_LENGTH'])
+      assert_equal(Rack::VERSION,            env['rack.version'])
+      assert_equal(config.logger,            env['rack.logger'])
+      assert_equal($stderr,                  env['rack.errors'])
+      assert_equal(false,                    env['rack.multithread'])
+      assert_equal(true,                     env['rack.multiprocess'])
+      assert_equal(false,                    env['rack.run_once'])
+      assert_equal('http',                   env['rack.url_scheme'])
+      assert_equal(APP_ID,                   env['SERVER_NAME'])
+      assert_equal("header",                 env["additional"])
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_get_rack_env_content_type_and_encoding_sensible_defaults
+
+      m1 = build_message({ :content_type => nil,    :content_encoding => nil })
+      m2 = build_message({ :content_type => "TYPE", :content_encoding => nil })
+      m3 = build_message({ :content_type => nil,    :content_encoding => "ENCODING" })
+      m4 = build_message({ :content_type => "TYPE", :content_encoding => "ENCODING" })
+
+      assert_equal("text/plain; charset=\"utf-8\"",     m1.get_rack_env['CONTENT_TYPE'])
+      assert_equal(      "TYPE; charset=\"utf-8\"",     m2.get_rack_env['CONTENT_TYPE'])
+      assert_equal("text/plain; charset=\"ENCODING\"",  m3.get_rack_env['CONTENT_TYPE'])
+      assert_equal(      "TYPE; charset=\"ENCODING\"",  m4.get_rack_env['CONTENT_TYPE'])
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_should_reply?
+      m1 = build_message(:reply_to => nil)
+      m2 = build_message(:reply_to => REPLY_TO)
+      assert_equal(false, m1.should_reply?)
+      assert_equal(true,  m2.should_reply?)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_get_reply_properties
+
+      config = build_config(:app_id => APP_ID)
+
+      message = build_message({
+        :reply_to         => REPLY_TO,
+        :correlation_id   => CORRELATION_ID,
+        :content_type     => "request.content.type",
+        :content_encoding => "request.content.encoding",
+        :method           => "request.method",
+        :path             => "request.path",
+        :body             => "request.body"
+      })
+
+      response = build_response(200, "response.body", {
+        :content_type     => "response.content.type",
+        :content_encoding => "response.content.encoding",
+        "additional"      => "header"
+      })
+
+      Timecop.freeze do
+
+        properties = message.get_reply_properties(response, config)
+
+        assert_equal(APP_ID,                      properties[:app_id])
+        assert_equal(REPLY_TO,                    properties[:routing_key])
+        assert_equal(CORRELATION_ID,              properties[:correlation_id])
+        assert_equal(Time.now.to_i,               properties[:timestamp])
+        assert_equal("response.content.type",     properties[:content_type])
+        assert_equal("response.content.encoding", properties[:content_encoding])
+        assert_equal("header",                    properties[:headers]["additional"])
+
+      end
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_ack
+
+      message = build_message(:delivery_tag => DELIVERY_TAG)
+
+      assert_equal(false, message.acknowledged?)
+      assert_equal(false, message.rejected?)
+      assert_equal([],    message.rabbit.acked_messages)
+      assert_equal([],    message.rabbit.rejected_messages)
+
+      message.ack
+
+      assert_equal(true,           message.acknowledged?)
+      assert_equal(false,          message.rejected?)
+      assert_equal([DELIVERY_TAG], message.rabbit.acked_messages)
+      assert_equal([],             message.rabbit.rejected_messages)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_reject
+
+      message = build_message(:delivery_tag => DELIVERY_TAG)
+
+      assert_equal(false, message.acknowledged?)
+      assert_equal(false, message.rejected?)
+      assert_equal([],    message.rabbit.acked_messages)
+      assert_equal([],    message.rabbit.rejected_messages)
+
+      message.reject
+
+      assert_equal(false,          message.acknowledged?)
+      assert_equal(true,           message.rejected?)
+      assert_equal([],             message.rabbit.acked_messages)
+      assert_equal([DELIVERY_TAG], message.rabbit.rejected_messages)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class TestMessage
+end # module RackRabbit
+

data/test/unit/test_response.rb

@@ -0,0 +1,59 @@
+require_relative '../test_case'
+
+module RackRabbit
+  class TestResponse < TestCase
+
+    #--------------------------------------------------------------------------
+
+    def test_response
+
+      response = build_response(200, BODY, :foo => "bar")
+
+      assert_equal(200,   response.status)
+      assert_equal("bar", response.headers[:foo])
+      assert_equal(BODY,  response.body)
+      assert_equal(true,  response.succeeded?)
+      assert_equal(false, response.failed?)
+      assert_equal(BODY,  response.to_s)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_succeeded_and_failed
+
+      expected_success = [ 200, 201, 202 ]
+      expected_failure = [ 400, 404, 500 ]
+
+      expected_success.each do |status|
+        response = build_response(status, BODY)
+        assert_equal(true,  response.succeeded?, "status #{status} should be considered a success")
+        assert_equal(false, response.failed?,    "status #{status} should be considered a success")
+      end
+
+      expected_failure.each do |status|
+        response = build_response(status, BODY)
+        assert_equal(false, response.succeeded?, "status #{status} should be considered a failure")
+        assert_equal(true,  response.failed?,    "status #{status} should be considered a failure")
+      end
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_to_s
+      r1 = build_response(200, BODY)
+      r2 = build_response(400, BODY)
+      r3 = build_response(404, BODY)
+      r4 = build_response(500, BODY)
+      assert_equal(BODY,                        r1.to_s)
+      assert_equal("400 Bad Request",           r2.to_s)
+      assert_equal("404 Not Found",             r3.to_s)
+      assert_equal("500 Internal Server Error", r4.to_s)
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class TestResponse
+end # module RackRabbit
+

data/test/unit/test_signals.rb

@@ -0,0 +1,45 @@
+require_relative '../test_case'
+
+module RackRabbit
+  class TestSignals < TestCase
+
+    #--------------------------------------------------------------------------
+
+    def test_pop_is_fifo_queue
+      signals = Signals.new
+      signals.push(:TTIN)
+      signals.push(:TTOU)
+      signals.push(:QUIT)
+      assert_equal(:TTIN, signals.pop)
+      assert_equal(:TTOU, signals.pop)
+      assert_equal(:QUIT, signals.pop)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_pop_blocks_when_queue_is_empty
+      signals = Signals.new
+      thread  = Thread.new { sleep 0.1 ; signals.push :QUIT }
+      seconds = measure do
+        sig = signals.pop
+        assert_equal(:QUIT, sig)
+      end
+      assert_equal(true, seconds >= 0.1, 'verify we blocked for > 100ms')
+      thread.join
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_pop_blocking_can_be_timed_out
+      signals = Signals.new
+      seconds = measure do
+        sig = signals.pop(:timeout => 0.1)
+        assert_equal(:timeout, sig)
+      end
+      assert_equal(true, seconds >= 0.1, 'verify we blocked for > 100ms')
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class TestSignals
+end # module RackRabbit

data/test/unit/test_subscriber.rb

@@ -0,0 +1,140 @@
+require_relative '../test_case'
+
+module RackRabbit
+  class TestSubscriber < TestCase
+
+    #--------------------------------------------------------------------------
+
+    def test_subscribe_lifecycle
+
+      subscriber = build_subscriber
+      rabbit     = subscriber.rabbit
+
+      assert_equal(false, rabbit.started?)  
+      assert_equal(false, rabbit.connected?)
+
+      subscriber.subscribe
+      assert_equal(true, rabbit.started?)
+      assert_equal(true, rabbit.connected?)
+
+      subscriber.unsubscribe
+      assert_equal(false, rabbit.started?)
+      assert_equal(false, rabbit.connected?)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_subscribe_options
+      options    = { :queue => QUEUE, :exchange => EXCHANGE, :exchange_type => :fanout, :routing_key => ROUTE, :ack => true }
+      subscriber = build_subscriber(options)
+      rabbit     = subscriber.rabbit
+      subscriber.subscribe
+      assert_equal(options, rabbit.subscribe_options, "subscription options should be set as expected")
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_subscribe_handles_message
+
+      subscriber = build_subscriber(:app_id => APP_ID)
+      message    = build_message
+      rabbit     = subscriber.rabbit
+
+      prime(subscriber, message)
+
+      assert_equal([], rabbit.subscribed_messages, "preconditions")
+
+      subscriber.subscribe
+
+      assert_equal([message], rabbit.subscribed_messages)
+      assert_equal([],        rabbit.published_messages)
+      assert_equal([],        rabbit.acked_messages)
+      assert_equal([],        rabbit.rejected_messages)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_handle_message_that_expects_a_reply
+
+      subscriber = build_subscriber(:app_id => APP_ID) 
+      message    = build_message(:delivery_tag => DELIVERY_TAG, :reply_to => REPLY_TO, :correlation_id => CORRELATION_ID)
+      rabbit     = subscriber.rabbit
+
+      prime(subscriber, message)
+
+      subscriber.subscribe
+
+      assert_equal([message],      rabbit.subscribed_messages)
+      assert_equal([],             rabbit.acked_messages)
+      assert_equal([],             rabbit.rejected_messages)
+      assert_equal(1,              rabbit.published_messages.length)
+      assert_equal(APP_ID,         rabbit.published_messages[0][:app_id])
+      assert_equal(REPLY_TO,       rabbit.published_messages[0][:routing_key])
+      assert_equal(CORRELATION_ID, rabbit.published_messages[0][:correlation_id])
+      assert_equal(200,            rabbit.published_messages[0][:headers][RackRabbit::HEADER::STATUS])
+      assert_equal("ok",           rabbit.published_messages[0][:body])
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_successful_message_is_acked
+
+      rabbit     = build_rabbit
+      subscriber = build_subscriber(:ack => true, :rabbit => rabbit)
+      message    = build_message(:delivery_tag => DELIVERY_TAG, :rabbit => rabbit)
+
+      prime(subscriber, message)
+
+      subscriber.subscribe
+
+      assert_equal([message],      rabbit.subscribed_messages)
+      assert_equal([],             rabbit.published_messages)
+      assert_equal([DELIVERY_TAG], rabbit.acked_messages)
+      assert_equal([],             rabbit.rejected_messages)
+
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_failed_message_is_rejected
+
+      rabbit     = build_rabbit
+      subscriber = build_subscriber(:rack_file => ERROR_RACK_APP, :ack => true, :rabbit => rabbit)
+      message    = build_message(:delivery_tag => DELIVERY_TAG, :rabbit => rabbit)
+      response   = build_response(500, "uh oh")
+
+      prime(subscriber, [message, response])
+
+      subscriber.subscribe
+
+      assert_equal([message],               rabbit.subscribed_messages)
+      assert_equal([],                      rabbit.published_messages)
+      assert_equal([],                      rabbit.acked_messages)
+      assert_equal([DELIVERY_TAG],          rabbit.rejected_messages)
+
+    end
+
+    #==========================================================================
+    # PRIVATE IMPLEMTATION HELPERS
+    #==========================================================================
+
+    private
+
+    def prime(subscriber, *messages)
+      messages.each do |m|
+        m, r = m if m.is_a?(Array)
+        r ||= build_response(200, "ok")
+        subscriber.rabbit.prime(m)
+        subscriber.handler.expects(:handle).with(m).returns(r)
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+
+  end # class TestSubscriber
+end # module RackRabbit
+