thrift_server 0.1.1 → 1.0.0

data/test/processor_test.rb

@@ -0,0 +1,189 @@
+require_relative 'test_helper'
+
+class ProcessorTest < MiniTest::Unit::TestCase
+  attr_reader :service
+
+  def setup
+    @service = TestService
+  end
+
+  def wrap(service, &block)
+    ThriftServer.wrap service, &block
+  end
+
+  def test_wrap_accepts_processor_itself
+    handler = stub
+    handler.expects(:getItems).with(:request).returns(:response)
+
+    stack = wrap(TestService::Processor).new(handler)
+
+    assert_equal :response, stack.process_getItems(:request)
+  end
+
+  def test_wraps_methods_defined_by_the_protocol
+    handler = stub
+    handler.expects(:getItems).with(:request).returns(:response)
+
+    stack = wrap(service).new(handler)
+
+    assert_equal :response, stack.process_getItems(:request)
+  end
+
+  def test_can_add_new_middleware_after_building
+    handler = mock
+    handler.expects(:getItems).with(:modified_args)
+
+    stack = wrap(service).new(handler)
+
+    test_middleware = Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env.args = :modified_args
+        @app.call env
+      end
+    end
+
+    stack.use test_middleware
+
+    stack.process_getItems :request
+  end
+
+  def test_correctly_detects_protocol_exceptions
+    stack = wrap(service).new(stub)
+
+    test_middleware = Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(rpc)
+        if rpc.exceptions[:getItems_test] == TestException
+          :ok
+        else
+          :missing_exception
+        end
+      end
+    end
+
+    stack.use test_middleware
+
+    assert_equal :ok, stack.process_getItems(:request)
+  end
+
+  def test_correctly_detects_protocol_exceptions_from_inherited_service_in_other_namespace
+    stack = wrap(service).new(stub)
+
+    test_middleware = Class.new do
+      def initialize(app)
+        @app = app
+      end
+
+      def call(rpc)
+        if rpc.exceptions[:ping_test] == TestException
+          :ok
+        else
+          :missing_exception
+        end
+      end
+    end
+
+    stack.use test_middleware
+
+    assert_equal :ok, stack.process_ping(:request)
+  end
+
+  def test_cannot_add_middleware_to_stack_after_first_rpc
+    handler = stub getItems: :response
+
+    stack = wrap(service).new(handler)
+
+    stack.process_getItems :request
+
+    ex = assert_raises RuntimeError do
+      stack.use ->(rpc) { rpc }
+    end
+
+    assert_match /frozen/, ex.to_s
+  end
+
+  def test_subscribers_receive_incoming_rpcs
+    handler = stub
+    handler.expects(:getItems).with(:request).returns(:response)
+
+    subscriber = stub
+    processor = wrap(service).new handler
+
+    processor.subscribe subscriber
+
+    subscriber.expects(:rpc_incoming).with do |request, meta|
+      request.name == :getItems
+    end
+
+    processor.process_getItems(:request)
+  end
+
+  def test_subscribers_receive_successful_rpcs
+    handler = stub
+    handler.expects(:getItems).with(:request).returns(:response)
+
+    subscriber = stub
+    processor = wrap(service).new handler
+
+    processor.subscribe subscriber
+
+    subscriber.expects(:rpc_ok).with do |request, response, meta|
+      request.name == :getItems &&
+        response == :response &&
+        meta.fetch(:latency).is_a?(Float)
+    end
+
+    processor.process_getItems(:request)
+  end
+
+  def test_subscribers_receive_rpc_errors
+    error = StandardError.new
+
+    handler = stub
+    handler.expects(:getItems).with(:request).raises(error)
+
+    subscriber = stub
+    processor = wrap(service).new handler
+
+    processor.subscribe subscriber
+
+    subscriber.expects(:rpc_error).with do |request, ex, meta|
+      request.name == :getItems &&
+        ex == error &&
+        meta.fetch(:latency).is_a?(Float)
+    end
+
+    assert_raises StandardError do
+      processor.process_getItems :request
+    end
+  end
+
+  def test_subscribers_receive_documented_rpc_protocol_exceptions
+    error = TestException.new :placeholder
+
+    handler = stub
+    handler.expects(:getItems).with(:request).raises(error)
+
+    subscriber = stub
+    processor = wrap(service).new handler
+
+    processor.subscribe subscriber
+
+    subscriber.expects(:rpc_exception).with do |request, ex, meta|
+      request.name == :getItems &&
+        ex == error &&
+        meta.fetch(:latency).is_a?(Float)
+    end
+
+    assert_raises TestException do
+      processor.process_getItems :request
+    end
+  end
+end

data/test/rpc_metrics_subscriber_test.rb

@@ -0,0 +1,44 @@
+require_relative 'test_helper'
+
+class RpcMetricsSubscriberTest < MiniTest::Unit::TestCase
+  TestError = Class.new StandardError
+
+  attr_reader :subscriber, :rpc, :statsd
+
+  def setup
+    @statsd = mock
+    @subscriber = ThriftServer::RpcMetricsSubscriber.new statsd
+
+    @rpc = ThriftServer::RPC.new :foo, :bar
+  end
+
+  def test_rpc_incoming
+    statsd.expects(:increment).with('rpc.foo.incoming')
+
+    subscriber.rpc_incoming rpc
+  end
+
+  def test_rpc_ok
+    statsd.expects(:increment).with('rpc.foo.success')
+    statsd.expects(:timing).with('rpc.foo.latency', 5)
+
+    subscriber.rpc_ok rpc, :response, latency: 5
+  end
+
+  def test_rpc_exception
+    rpc.exceptions = { test: TestException }
+
+    statsd.expects(:increment).with('rpc.foo.exception')
+    statsd.expects(:increment).with('rpc.foo.exception.test')
+    statsd.expects(:timing).with('rpc.foo.latency', 5)
+
+    subscriber.rpc_exception rpc, TestException.new(:placeholder), latency: 5
+  end
+
+  def test_rpc_error
+    statsd.expects(:increment).with('rpc.foo.error')
+    statsd.expects(:timing).with('rpc.foo.latency', 5)
+
+    subscriber.rpc_error rpc, :response, latency: 5
+  end
+end

data/test/server_metrics_subscriber_test.rb

@@ -0,0 +1,51 @@
+require_relative 'test_helper'
+
+class ServerMetricsSubscriberTest < MiniTest::Unit::TestCase
+  TestError = Class.new StandardError
+
+  attr_reader :subscriber, :rpc, :statsd
+
+  def setup
+    @statsd = mock
+    @subscriber = ThriftServer::ServerMetricsSubscriber.new statsd
+
+    @rpc = ThriftServer::RPC.new :foo, :bar
+  end
+
+  def test_server_connection_opened
+    statsd.expects(:gauge).with('server.connection.active', '+1')
+    subscriber.server_connection_opened :addr
+  end
+
+  def test_server_connection_closed
+    statsd.expects(:gauge).with('server.connection.active', '-1')
+    subscriber.server_connection_closed :addr
+  end
+
+  def test_rpc_incoming
+    statsd.expects(:increment).with('rpc.incoming')
+
+    subscriber.rpc_incoming rpc
+  end
+
+  def test_rpc_ok
+    statsd.expects(:increment).with('rpc.success')
+    statsd.expects(:timing).with('rpc.latency', 5)
+
+    subscriber.rpc_ok rpc, :response, latency: 5
+  end
+
+  def test_exception
+    statsd.expects(:increment).with('rpc.exception')
+    statsd.expects(:timing).with('rpc.latency', 5)
+
+    subscriber.rpc_exception rpc, :response, latency: 5
+  end
+
+  def test_error
+    statsd.expects(:increment).with('rpc.error')
+    statsd.expects(:timing).with('rpc.latency', 5)
+
+    subscriber.rpc_error rpc, :response, latency: 5
+  end
+end

data/test/support/log_yielder.rb

@@ -0,0 +1,32 @@
+# Make it easy to assert on a string line generated through the standard lib
+# progname & block syntax. This class will automatically yield the block and
+# concat it the mock receives a single line. This also ensures the block
+# is always executed, making sure it's free of errors
+class LogYielder
+  include Concord.new(:log)
+
+  def info(msg)
+    if msg && block_given?
+      log.info "#{msg} #{yield}"
+    else
+      log.info msg
+    end
+  end
+
+  def error(msg)
+    if msg && block_given?
+      log.error "#{msg} #{yield}"
+    else
+      log.error msg
+    end
+  end
+
+  def debug(msg)
+    if msg && block_given?
+      log.debug "#{msg} #{yield}"
+    else
+      log.debug msg
+    end
+  end
+end
+

data/test/support/server_tests.rb

@@ -0,0 +1,87 @@
+module ServerTests
+  def test_defaults_to_port_9090
+    server = build service, stub
+    assert_equal 9090, server.port
+  end
+
+  def test_accepts_port_options
+    server = build(service, stub, {
+      port: 5000
+    })
+
+    assert_equal 5000, server.port
+  end
+
+  def test_creates_server_with_framed_transport
+    server = build service, stub
+
+    assert_instance_of Thrift::FramedTransportFactory, server.transport
+  end
+
+  def test_uses_server_socket_transport
+    server = build service, stub
+
+    assert_instance_of Thrift::ServerSocket, server.server_transport
+  end
+
+  def test_creates_server_with_binary_protocol
+    server = build service, stub
+
+    assert_instance_of Thrift::BinaryProtocolFactory, server.protocol
+  end
+
+  def test_subscribers_receive_server_start
+    subscriber = mock
+    subscriber.expects(:server_start)
+
+    server = build(service, stub) do |server|
+      server.subscribe subscriber
+    end
+
+    server.start dry_run: true
+  end
+
+  def test_shortcut_method_for_attaching_log_subscriber
+    ThriftServer::LogSubscriber.expects(:new).with(:stdout).returns(:generic)
+
+    server = build(service, stub) do |server|
+      server.log :stdout
+    end
+
+    assert_includes server.publisher, :generic
+  end
+
+  def test_shortcut_method_for_attaching_metrics
+    ThriftServer::ServerMetricsSubscriber.expects(:new).with(:statsd).returns(:server)
+    ThriftServer::RpcMetricsSubscriber.expects(:new).with(:statsd).returns(:rpc)
+
+    server = build(service, stub) do |server|
+      server.metrics :statsd
+    end
+
+    assert_includes server.publisher, :server
+    assert_includes server.publisher, :rpc
+  end
+
+  def test_attaching_subscribers_to_server
+    server = build(service, stub) do |server|
+      server.subscribe :tester
+    end
+
+    assert_includes server.publisher, :tester
+  end
+
+  def test_adding_middleware_to_server
+    test_middleware = Class.new do
+      include Concord.new(:app)
+
+      def call(env)
+        app.call env
+      end
+    end
+
+    server = build(service, stub) do |server|
+      server.use test_middleware
+    end
+  end
+end

data/test/test_helper.rb

@@ -7,6 +7,9 @@ require 'logger-better'
 require 'minitest/autorun'
 require 'mocha/mini_test'
 
+require_relative 'support/server_tests'
+require_relative 'support/log_yielder'
+
 TestError = Class.new StandardError
 
 class FakeStatsd
@@ -25,36 +28,42 @@ class NullErrorTracker
   end
 end
 
-def Processor(*rpcs)
-  Class.new do
-    def initialize(handler)
-      @handler = handler
-    end
+TestException = Class.new Thrift::Exception
+
+class SimulatedResult
+  FIELDS = {
+    'EXCEPTION' => { name: 'test', class: TestException }
+  }
+end
+
+module GenericService
+  class Processor
+    include Thrift::Processor
 
-    rpcs.each do |method_name|
-      define_method "process_#{method_name}" do |*args|
-        # nothing to do, this is just a stub to create objects inline
-        # with the generate thrift processors
-        @handler.send method_name, *args
-      end
+    def process_ping(*args)
+      @handler.ping(*args)
     end
   end
-end
 
-# Monkey patch attr readers to test various server settings
-module Thrift
-  class ServerSocket
-    attr_reader :port
+  class Ping_result
+    FIELDS = {
+      'EXCEPTION' => { name: 'ping_test', class: TestException }
+    }
   end
+end
 
-  class ThreadPoolServer
-    attr_reader :server_transport, :transport_factory, :protocol_factory
-    def threads
-      @thread_q.max
-    end
+module TestService
+  class Processor < GenericService::Processor
+    include Thrift::Processor
 
-    def port
-      server_transport.port
+    def process_getItems(*args)
+      @handler.getItems(*args)
     end
   end
+
+  class GetItems_result
+    FIELDS = {
+      'EXCEPTION' => { name: 'getItems_test', class: TestException }
+    }
+  end
 end