sanford 0.15.1 → 0.16.0

data/test/unit/service_handler_tests.rb

@@ -1,12 +1,16 @@
 require 'assert'
 require 'sanford/service_handler'
 
+require 'much-plugin'
 require 'sanford/template_engine'
 require 'sanford/template_source'
+require 'sanford/test_runner'
 
 module Sanford::ServiceHandler
 
   class UnitTests < Assert::Context
+    include Sanford::ServiceHandler::TestHelpers
+
     desc "Sanford::ServiceHandler"
     setup do
       @handler_class = Class.new{ include Sanford::ServiceHandler }
@@ -23,6 +27,10 @@ module Sanford::ServiceHandler
     should have_imeths :prepend_before_init, :prepend_after_init
     should have_imeths :prepend_before_run,  :prepend_after_run
 
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Sanford::ServiceHandler
+    end
+
     should "return an empty array by default using `before_callbacks`" do
       assert_equal [], subject.before_callbacks
     end
@@ -136,21 +144,15 @@ module Sanford::ServiceHandler
   class InitTests < UnitTests
     desc "when init"
     setup do
-      @runner = FakeRunner.new
-      @handler = TestServiceHandler.new(@runner)
+      @runner  = test_runner(TestServiceHandler)
+      @handler = @runner.handler
     end
     subject{ @handler }
 
-    should have_imeths :init, :init!, :run, :run!
-
-    should "know its request, params and logger" do
-      assert_equal @runner.request, subject.public_request
-      assert_equal @runner.params,  subject.public_params
-      assert_equal @runner.logger,  subject.public_logger
-    end
+    should have_imeths :sanford_init, :init!, :sanford_run, :run!
+    should have_imeths :sanford_run_callback
 
-    should "call `init!` and its before/after init callbacks using `init`" do
-      subject.init
+    should "have called `init!` and its before/after init callbacks" do
       assert_equal 1, subject.first_before_init_call_order
       assert_equal 2, subject.second_before_init_call_order
       assert_equal 3, subject.init_call_order
@@ -158,37 +160,138 @@ module Sanford::ServiceHandler
       assert_equal 5, subject.second_after_init_call_order
     end
 
-    should "call `run!` and its before/after run callbacks using `run`" do
-      subject.run
-      assert_equal 1, subject.first_before_run_call_order
-      assert_equal 2, subject.second_before_run_call_order
-      assert_equal 3, subject.run_call_order
-      assert_equal 4, subject.first_after_run_call_order
-      assert_equal 5, subject.second_after_run_call_order
+    should "not have called `run!` and its before/after run callbacks" do
+      assert_nil subject.first_before_run_call_order
+      assert_nil subject.second_before_run_call_order
+      assert_nil subject.run_call_order
+      assert_nil subject.first_after_run_call_order
+      assert_nil subject.second_after_run_call_order
     end
 
-    should "have a custom inspect" do
-      reference = '0x0%x' % (subject.object_id << 1)
-      expected = "#<#{subject.class}:#{reference} " \
-                 "@request=#{@runner.request.inspect}>"
-      assert_equal expected, subject.inspect
+    should "run its callbacks with `sanford_run_callback`" do
+      subject.sanford_run_callback 'before_run'
+      assert_equal 6, subject.first_before_run_call_order
+      assert_equal 7, subject.second_before_run_call_order
     end
 
-    should "delegate its runner's `render` method" do
-      path = Factory.file_path
-      locals = { 'something' => Factory.string }
-      result = subject.render(path, locals)
-      assert_equal [path, locals], @runner.render_calls.last
+    should "know if it is equal to another service handler" do
+      handler = test_handler(TestServiceHandler)
+      assert_equal handler, subject
+
+      handler = test_handler(Class.new{ include Sanford::ServiceHandler })
+      assert_not_equal handler, subject
     end
 
-    should "delegate its runner's `halt` method" do
-      code = Factory.integer
-      result = subject.halt(code)
-      assert_equal [code], @runner.halt_calls.last
+  end
+
+  class RunTests < InitTests
+    desc "and run"
+    setup do
+      @handler.sanford_run
     end
 
-    should "raise a not implemented error when `run!` by default" do
-      assert_raises(NotImplementedError){ @handler_class.new(@runner).run! }
+    should "call `run!` and it's callbacks" do
+      assert_equal 6,  subject.first_before_run_call_order
+      assert_equal 7,  subject.second_before_run_call_order
+      assert_equal 8,  subject.run_call_order
+      assert_equal 9,  subject.first_after_run_call_order
+      assert_equal 10, subject.second_after_run_call_order
+    end
+
+  end
+
+  class PrivateHelpersTests < InitTests
+    setup do
+      @something = Factory.string
+      @args      = (Factory.integer(3)+1).times.map{ Factory.string }
+    end
+
+    should "call to the runner for its logger" do
+      stub_runner_with_something_for(:logger)
+      assert_equal @runner.logger, subject.instance_eval{ logger }
+    end
+
+    should "call to the runner for its request" do
+      stub_runner_with_something_for(:request)
+      assert_equal @runner.request, subject.instance_eval{ request }
+    end
+
+    should "call to the runner for its params" do
+      stub_runner_with_something_for(:params)
+      assert_equal @runner.params, subject.instance_eval{ params }
+    end
+
+    should "call to the runner for its status helper" do
+      capture_runner_meth_args_for(:status)
+      exp_args = @args
+      subject.instance_eval{ status(*exp_args) }
+
+      assert_equal exp_args, @meth_args
+      assert_nil @meth_block
+    end
+
+    should "call to the runner for its data helper" do
+      capture_runner_meth_args_for(:data)
+      exp_args = @args
+      subject.instance_eval{ data(*exp_args) }
+
+      assert_equal exp_args, @meth_args
+      assert_nil @meth_block
+    end
+
+    should "call to the runner for its halt helper" do
+      capture_runner_meth_args_for(:halt)
+      exp_args = @args
+      subject.instance_eval{ halt(*exp_args) }
+
+      assert_equal exp_args, @meth_args
+    end
+
+    should "call to the runner for its render helper" do
+      capture_runner_meth_args_for(:render)
+      exp_args = @args
+      subject.instance_eval{ render(*exp_args) }
+
+      assert_equal exp_args, @meth_args
+    end
+
+    private
+
+    def stub_runner_with_something_for(meth)
+      Assert.stub(@runner, meth){ @something }
+    end
+
+    def capture_runner_meth_args_for(meth)
+      Assert.stub(@runner, meth) do |*args|
+        @meth_args = args
+      end
+    end
+
+  end
+
+  class TestHelpersTests < UnitTests
+    desc "TestHelpers"
+    setup do
+      context_class = Class.new{ include Sanford::ServiceHandler::TestHelpers }
+      @context = context_class.new
+    end
+    subject{ @context }
+
+    should have_imeths :test_runner, :test_handler
+
+    should "build a test runner for a given handler class" do
+      runner  = subject.test_runner(@handler_class)
+
+      assert_kind_of ::Sanford::TestRunner, runner
+      assert_equal @handler_class, runner.handler_class
+    end
+
+    should "return an initialized handler instance" do
+      handler = subject.test_handler(@handler_class)
+      assert_kind_of @handler_class, handler
+
+      exp = subject.test_runner(@handler_class).handler
+      assert_equal exp, handler
     end
 
   end
@@ -202,11 +305,6 @@ module Sanford::ServiceHandler
     attr_reader :first_after_run_call_order, :second_after_run_call_order
     attr_reader :init_call_order, :run_call_order
 
-    # these methods are made public so they can be tested, they are being tested
-    # because they are used by classes that mixin this, essentially they are
-    # "public" to classes that use the mixin
-    public :render, :halt
-
     before_init{ @first_before_init_call_order = next_call_order }
     before_init{ @second_before_init_call_order = next_call_order }
 
@@ -227,38 +325,13 @@ module Sanford::ServiceHandler
       @run_call_order = next_call_order
     end
 
-    def public_request
-      request
-    end
-
-    def public_params
-      params
-    end
-
-    def public_logger
-      logger
-    end
-
     private
 
     def next_call_order
       @order ||= 0
       @order += 1
     end
-  end
-
-  class FakeRunner
-    attr_accessor :request, :params, :logger
-    attr_reader :render_calls, :halt_calls
-
-    def initialize
-      @request = Factory.string
-      @params = Factory.string
-      @logger = Factory.string
-    end
 
-    def render(*args); @render_calls ||= []; @render_calls << args; end
-    def halt(*args);   @halt_calls   ||= []; @halt_calls   << args; end
   end
 
 end

data/test/unit/test_runner_tests.rb

@@ -7,7 +7,7 @@ class Sanford::TestRunner
     desc "Sanford::TestRunner"
     setup do
       @handler_class = TestServiceHandler
-      @runner_class = Sanford::TestRunner
+      @runner_class  = Sanford::TestRunner
     end
     subject{ @runner_class }
 
@@ -22,11 +22,11 @@ class Sanford::TestRunner
     setup do
       @params = { Factory.string => Factory.integer }
       @args = {
-        :request         => Factory.string,
-        :params          => @params,
         :logger          => Factory.string,
         :router          => Factory.string,
         :template_source => Factory.string,
+        :request         => Factory.string,
+        :params          => @params,
         :custom_value    => Factory.integer
       }
       @original_args = @args.dup
@@ -35,43 +35,20 @@ class Sanford::TestRunner
     end
     subject{ @runner }
 
-    should have_readers :response
-    should have_imeths :run
+    should have_imeths :halted?, :run
 
-    should "know its standard attributes" do
-      assert_equal @args[:request],         subject.request
-      assert_equal @params,                 subject.params
+    should "raise an invalid error when passed a non service handler" do
+      assert_raises(Sanford::InvalidServiceHandlerError) do
+        @runner_class.new(Class.new)
+      end
+    end
+
+    should "know its standard args" do
       assert_equal @args[:logger],          subject.logger
       assert_equal @args[:router],          subject.router
       assert_equal @args[:template_source], subject.template_source
-    end
-
-    should "write any non-standard args to its handler" do
-      assert_equal @args[:custom_value], @handler.custom_value
-    end
-
-    should "not alter the args passed to it" do
-      assert_equal @original_args, @args
-    end
-
-    should "not call its service handlers before callbacks" do
-      assert_nil @handler.before_called
-    end
-
-    should "call its service handlers init" do
-      assert_true @handler.init_called
-    end
-
-    should "not run its service handler" do
-      assert_false @handler.run_called
-    end
-
-    should "not call its service handlers after callbacks" do
-      assert_nil @handler.after_called
-    end
-
-    should "not have a response by default" do
-      assert_nil @handler.response
+      assert_equal @args[:request],         subject.request
+      assert_equal @args[:params],          subject.params
     end
 
     should "normalize the params passed to it" do
@@ -85,94 +62,55 @@ class Sanford::TestRunner
       assert_equal exp, runner.params
     end
 
-    should "raise a serialization error if the params can't be serialized" do
+    should "complain if the params can't be serialized" do
       params = { Factory.string => Class.new }
       assert_raises(BSON::InvalidDocument) do
         @runner_class.new(@handler_class, :params => params)
       end
     end
 
-    should "raise an invalid error when passed a non service handler" do
-      assert_raises(Sanford::InvalidServiceHandlerError) do
-        @runner_class.new(Class.new)
-      end
-    end
-
-  end
-
-  class RunTests < InitTests
-    desc "and run"
-    setup do
-      @response = @runner.run
-    end
-    subject{ @response }
-
-    should "know its response" do
-      assert_equal subject, @runner.response
-      assert_instance_of Sanford::Protocol::Response, subject
+    should "write any non-standard args to its handler" do
+      assert_equal @args[:custom_value], subject.handler.custom_value
     end
 
-    should "run its service handler" do
-      assert_true @runner.handler.run_called
+    should "not alter the args passed to it" do
+      assert_equal @original_args, @args
     end
 
-    should "not call its service handler's after callbacks" do
-      assert_nil @runner.handler.after_called
+    should "not call its handler's before callbacks" do
+      assert_nil @handler.before_called
     end
 
-  end
-
-  class RunWithInvalidResponseTests < InitTests
-    desc "and run with an invalid response"
-    setup do
-      @runner.handler.response = Class.new
+    should "call its handler's init" do
+      assert_true @handler.init_called
     end
 
-    should "raise a serialization error" do
-      assert_raises(BSON::InvalidDocument){ subject.run }
+    should "not call its handler's run" do
+      assert_nil @handler.run_called
     end
 
-  end
-
-  class InitThatHaltsTests < UnitTests
-    desc "when init with a handler that halts in its init"
-    setup do
-      @runner = @runner_class.new(HaltServiceHandler)
+    should "not call its handler's after callbacks" do
+      assert_nil @handler.after_called
     end
-    subject{ @runner }
 
-    should "know the response from the init halting" do
-      assert_instance_of Sanford::Protocol::Response, subject.response
-      assert_equal subject.handler.response_code, subject.response.code
+    should "not be halted by default" do
+      assert_false subject.halted?
     end
 
-  end
-
-  class RunWithInitThatHaltsTests < InitThatHaltsTests
-    desc "is run"
-    setup do
-      @response = @runner.run
-    end
-    subject{ @response }
-
-    should "not call run on the service handler" do
-      assert_false @runner.handler.run_called
+    should "not call `run` on its handler if halted when run" do
+      catch(:halt){ subject.halt }
+      assert_true subject.halted?
+      subject.run
+      assert_nil @handler.run_called
     end
 
-    should "return the response from the init halting" do
-      assert_instance_of Sanford::Protocol::Response, subject
-      assert_equal @runner.handler.response_code, subject.code
+    should "return its `to_response` value on run" do
+      assert_equal subject.to_response, subject.run
     end
 
-  end
-
-  class RunWithInvalidResponseFromInitHaltTests < UnitTests
-    desc "when init with a handler that halts in its init an invalid response"
-
-    should "raise a serialization error" do
-      assert_raises(BSON::InvalidDocument) do
-        @runner_class.new(HaltServiceHandler, :response_data => Class.new)
-      end
+    should "complain if the respose value can't be encoded" do
+      subject.data(Class.new)
+      assert_raises(BSON::InvalidDocument){ subject.run }
     end
 
   end
@@ -189,13 +127,13 @@ class Sanford::TestRunner
 
     def init!
       @init_called = true
-      @run_called = false
     end
 
     def run!
       @run_called = true
       @response || Factory.boolean
     end
+
   end
 
   class HaltServiceHandler
@@ -214,6 +152,7 @@ class Sanford::TestRunner
     def run!
       @run_called = true
     end
+
   end
 
 end

data/test/unit/worker_tests.rb

@@ -0,0 +1,185 @@
+require 'assert'
+require 'sanford/worker'
+
+require 'dat-tcp/worker'
+require 'much-plugin'
+require 'sanford-protocol/fake_connection'
+require 'sanford/server_data'
+require 'test/support/fake_server_connection'
+
+module Sanford::Worker
+
+  class UnitTests < Assert::Context
+    include DatTCP::Worker::TestHelpers
+
+    desc "Sanford::Worker"
+    setup do
+      @worker_class = Class.new{ include Sanford::Worker }
+    end
+    subject{ @worker_class }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, Sanford::Worker
+    end
+
+    should "be a dat-tcp worker" do
+      assert_includes DatTCP::Worker, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @socket      = Factory.binary
+      @server_data = Sanford::ServerData.new
+
+      @connection = FakeServerConnection.new
+      Assert.stub(Connection, :new).with(@socket){ @connection }
+
+      @ch_spy = nil
+      Assert.stub(Sanford::ConnectionHandler, :new) do |*args|
+        @ch_spy = ConnectionHandlerSpy.new(*args)
+      end
+
+      @worker_params = {
+        :sanford_server_data => @server_data
+      }
+      @runner = test_runner(@worker_class, :params => @worker_params)
+    end
+    subject{ @runner }
+
+    should "build and run a connection handler when it processes a socket" do
+      Assert.stub(@server_data, :receives_keep_alive){ false }
+      @connection.read_data = Factory.string
+      subject.work(@socket)
+
+      assert_not_nil @ch_spy
+      assert_equal @server_data, @ch_spy.server_data
+      assert_equal @connection,  @ch_spy.connection
+      assert_true @ch_spy.run_called
+    end
+
+    should "not run a connection handler when it processes a " \
+           "keep-alive connection and its configured to expect them" do
+      Assert.stub(@server_data, :receives_keep_alive){ true }
+      @connection.read_data = nil # nothing to read makes it a keep-alive
+      subject.work(@socket)
+
+      assert_nil @ch_spy
+    end
+
+    should "run a connection handler when it processes a " \
+           "keep-alive connection and its not configured to expect them" do
+      Assert.stub(@server_data, :receives_keep_alive){ false }
+      @connection.read_data = nil # nothing to read makes it a keep-alive
+      subject.work(@socket)
+
+      assert_not_nil @ch_spy
+      assert_equal @server_data, @ch_spy.server_data
+      assert_equal @connection,  @ch_spy.connection
+      assert_true @ch_spy.run_called
+    end
+
+  end
+
+  class ConnectionTests < UnitTests
+    desc "Connection"
+    setup do
+      fake_socket = Factory.string
+      @protocol_conn = Sanford::Protocol::FakeConnection.new(Factory.binary)
+      Assert.stub(Sanford::Protocol::Connection, :new).with(fake_socket) do
+        @protocol_conn
+      end
+      @connection = Connection.new(fake_socket)
+    end
+    subject{ @connection }
+
+    should have_imeths :read_data, :write_data, :peek_data
+    should have_imeths :close_write
+
+    should "default its timeout" do
+      assert_equal 1.0, subject.timeout
+    end
+
+    should "allowing reading from the protocol connection" do
+      result = subject.read_data
+      assert_equal @protocol_conn.read_data, result
+      assert_equal @protocol_conn.read_timeout, subject.timeout
+    end
+
+    should "allowing writing to the protocol connection" do
+      data = Factory.binary
+      subject.write_data(data)
+      assert_equal @protocol_conn.write_data, data
+    end
+
+    should "allowing peeking from the protocol connection" do
+      result = subject.peek_data
+      assert_equal @protocol_conn.peek_data, result
+      assert_equal @protocol_conn.peek_timeout, subject.timeout
+    end
+
+    should "allow closing the write stream on the protocol connection" do
+      assert_false @protocol_conn.closed_write
+      subject.close_write
+      assert_true @protocol_conn.closed_write
+    end
+
+  end
+
+  class TCPCorkTests < UnitTests
+    desc "TCPCork"
+    subject{ TCPCork }
+
+    should have_imeths :apply, :remove
+
+  end
+
+  class TestHelpersTests < UnitTests
+    desc "TestHelpers"
+    setup do
+      @context_class = Class.new{ include TestHelpers }
+      @context = @context_class.new
+    end
+    subject{ @context }
+
+    should have_imeths :test_runner
+
+    should "mixin dat-tcp's worker test helpers" do
+      assert_includes DatTCP::Worker::TestHelpers, @context_class
+    end
+
+    should "super worker params needed to run a sanford worker" do
+      runner = @context.test_runner(@worker_class)
+      worker_params = runner.dwp_runner.worker_params
+
+      assert_instance_of Sanford::ServerData, worker_params[:sanford_server_data]
+    end
+
+    should "allow providing custom worker params for running a sanford worker" do
+      @params = {
+        :sanford_server_data => Factory.string,
+      }
+      runner = @context.test_runner(@worker_class, :params => @params)
+
+      assert_equal @params, runner.dwp_runner.worker_params
+    end
+
+  end
+
+  class ConnectionHandlerSpy
+    attr_reader :server_data, :connection, :run_called
+
+    def initialize(server_data, connection)
+      @server_data = server_data
+      @connection  = connection
+      @run_called  = false
+    end
+
+    def run
+      @run_called = true
+    end
+  end
+
+end