bane 0.3.0 → 0.4.0

data/test/bane/arguments_parser_test.rb

@@ -0,0 +1,76 @@
+require_relative '../test_helper'
+
+class ArgumentsParserTest < Test::Unit::TestCase
+  include Bane
+
+  # Parsing arguments (uses the isolated ArgumentsParser object)
+
+  def test_parses_the_port
+    config = parse(["3000", IRRELEVANT_BEHAVIOR])
+    assert_equal 3000, config.port
+  end
+
+  def test_parses_the_behaviors
+    config = parse([IRRELEVANT_PORT, 'NeverRespond', 'EchoResponse'])
+    assert_equal ['NeverRespond', 'EchoResponse'], config.behaviors
+  end
+
+  def test_host_defaults_to_localhost_if_not_specified
+    config = parse([IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+    assert_equal '127.0.0.1', config.host
+  end
+
+  def test_dash_l_option_sets_listen_host_to_localhost
+    assert_parses_host(Behaviors::Servers::LOCALHOST, ['-l', IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_listen_on_localhost_sets_listen_host_to_localhost
+    assert_parses_host(Behaviors::Servers::LOCALHOST, ['--listen-on-localhost', IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_dash_a_option_sets_listen_host_to_all_interfaces
+    assert_parses_host(Behaviors::Servers::ALL_INTERFACES, ['-a', IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_listen_on_all_hosts_option_sets_listen_host_to_all_interfaces
+    assert_parses_host(Behaviors::Servers::ALL_INTERFACES, ['--listen-on-all-hosts', IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  end
+
+  def test_usage_message_includes_known_makeables_in_alphabetical_order
+    usage = ArgumentsParser.new(['makeable2', 'makeable1']).usage
+    assert_match /makeable1/i, usage, 'Should have included all known makeables'
+    assert_match /makeable2/i, usage, 'Should have included all known makeables'
+    assert_match /makeable1\W+makeable2/i, usage, 'Should have been in alphabetical order'
+  end
+
+  def test_no_arguments_fail_with
+    assert_invalid_arguments_fail_matching_message([], /missing arguments/i)
+  end
+
+  def test_non_integer_port_fails_with_error_message
+    assert_invalid_arguments_fail_matching_message(['text_instead_of_an_integer'], /Invalid Port Number/i)
+  end
+
+  def test_invalid_option_fails_with_error_message
+    assert_invalid_arguments_fail_matching_message(['--unknown-option', IRRELEVANT_PORT], /Invalid Option/i)
+  end
+
+  def parse(arguments)
+    ArgumentsParser.new(["makeable1", "makeable2"]).parse(arguments)
+  end
+
+  def assert_parses_host(expected_host, arguments)
+    config = parse(arguments)
+    assert_equal expected_host, config.host
+  end
+
+  def assert_invalid_arguments_fail_matching_message(arguments, message_matcher)
+    begin
+      parse(arguments)
+      flunk "Should have thrown an error"
+    rescue ConfigurationError => ce
+      assert_match message_matcher, ce.message
+    end
+  end
+
+end

data/test/bane/bane_test.rb

@@ -0,0 +1,12 @@
+require_relative '../test_helper'
+
+class BaneTest < Test::Unit::TestCase
+
+  def test_includes_responders_and_servers_in_all_makeables
+    all_names = Bane.find_makeables.keys
+
+    assert all_names.include?('NeverRespond'), "Expected 'NeverRespond' responder to be in #{all_names}"
+    assert all_names.include?('TimeoutInListenQueue'), "Expected 'TimeoutInListenQueue' server to be in #{all_names}"
+  end
+
+end

data/test/bane/behaviors/responders/close_after_pause_test.rb

@@ -0,0 +1,30 @@
+require_relative '../../../test_helper'
+require 'mocha/setup'
+
+class CloseAfterPauseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sleeps_30_seconds_by_default
+    server = CloseAfterPause.new
+    server.expects(:sleep).with(30)
+
+    query_server(server)
+  end
+
+  def test_sleeps_specified_number_of_seconds
+    server = CloseAfterPause.new(duration: 1)
+    server.expects(:sleep).with(1)
+
+    query_server(server)
+  end
+
+  def test_sends_nothing
+    server = CloseAfterPause.new
+    server.stubs(:sleep)
+
+    query_server(server)
+  end
+
+end

data/test/bane/behaviors/responders/close_immediately_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../../test_helper'
+
+class CloseImmediatelyTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sends_no_response
+    query_server(CloseImmediately.new)
+
+    assert_empty_response
+  end
+
+end

data/test/bane/behaviors/responders/deluge_response_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../../test_helper'
+
+class DelugeResponseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sends_one_million_bytes_by_default
+    query_server(DelugeResponse.new)
+
+    assert_response_length 1_000_000
+  end
+
+  def test_sends_the_specified_number_of_bytes
+    query_server(DelugeResponse.new(length: 1))
+
+    assert_response_length 1
+  end
+
+end

data/test/bane/behaviors/responders/echo_response_test.rb

@@ -0,0 +1,16 @@
+require_relative '../../../test_helper'
+
+class EchoResponseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_returns_received_characters
+    fake_connection.will_send("Hello, echo!")
+
+    query_server(EchoResponse.new)
+
+    assert_equal "Hello, echo!", response
+  end
+
+end

data/test/bane/behaviors/responders/fixed_response_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../../test_helper'
+
+class FixedResponseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sends_the_specified_message
+    query_server(FixedResponse.new(message: "Test Message"))
+
+    assert_equal "Test Message", response
+  end
+
+end

data/test/bane/behaviors/responders/for_each_line_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../../test_helper'
+require 'mocha/setup'
+
+class ForEachLineTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_reads_a_line_before_responding_with_parent_behavior
+    server = SayHelloForEachLineBehavior.new
+
+    fake_connection.will_send "irrelevant\n"
+
+    query_server(server)
+    assert_equal "Hello", response
+
+    assert fake_connection.read_all_queries?
+  end
+
+  class SayHelloBehavior
+    def serve(io)
+      io.write('Hello')
+    end
+  end
+
+  class SayHelloForEachLineBehavior < SayHelloBehavior
+    include Bane::Behaviors::Responders::ForEachLine
+  end
+end

data/test/bane/behaviors/responders/http_refuse_all_credentials_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../../test_helper'
+
+class HttpRefuseAllCredentialsTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sends_401_response_code
+    fake_connection.will_send("GET /some/irrelevant/path HTTP/1.1")
+
+    server = HttpRefuseAllCredentials.new
+    query_server(server)
+
+    assert fake_connection.read_all_queries?, "Should have read the HTTP query before sending response"
+    assert_match /HTTP\/1.1 401 Unauthorized/, response, 'Should have responded with the 401 response code'
+  end
+
+end

data/test/bane/behaviors/responders/never_respond_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../../test_helper'
+
+class NeverRespondTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+  include ServerTestHelpers
+
+  LONG_MESSAGE = 'x'*(1024*5)
+
+  def test_does_not_send_a_response
+    server = NeverRespond.new
+
+    query_server(server)
+    assert_empty_response
+  end
+
+  def test_disconnects_after_client_closes_connection
+    run_server(Bane::Behaviors::Servers::ResponderServer.new(0, NeverRespond.new)) do |server|
+      client = TCPSocket.new('localhost', server.port)
+      sleep 3
+      client.write LONG_MESSAGE
+      client.close
+
+      sleep 0.1
+
+      assert_equal 0, server.connections
+    end
+  end
+
+end

data/test/bane/behaviors/responders/newline_response_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../../test_helper'
+
+class NewlineResponseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sends_only_a_newline_character
+    query_server(NewlineResponse.new)
+
+    assert_equal "\n", response
+  end
+
+end

data/test/bane/behaviors/responders/random_response_test.rb

@@ -0,0 +1,15 @@
+require_relative '../../../test_helper'
+
+class RandomResponseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_sends_a_nonempty_response
+    query_server(RandomResponse.new)
+
+    assert (!response.empty?), "Should have served a nonempty response"
+  end
+
+end
+

data/test/bane/behaviors/responders/slow_response_test.rb

@@ -0,0 +1,21 @@
+require_relative '../../../test_helper'
+require 'mocha/setup'
+
+class SlowResponseTest < Test::Unit::TestCase
+
+  include Bane::Behaviors::Responders
+  include BehaviorTestHelpers
+
+  def test_pauses_between_sending_each_character
+    message = "Hi!"
+    delay = 0.5
+
+    server = SlowResponse.new(pause_duration: delay, message: message)
+    server.expects(:sleep).with(delay).at_least(message.length)
+
+    query_server(server)
+
+    assert_equal message, response
+  end
+
+end

data/test/bane/behaviors/servers/responder_server_test.rb

@@ -0,0 +1,77 @@
+require_relative '../../../test_helper'
+require 'mocha/setup'
+
+class ResponderServerTest < Test::Unit::TestCase
+  include LaunchableRoleTests
+
+  include Bane
+  include Bane::Behaviors::Servers
+  
+  IRRELEVANT_IO_STREAM = nil
+  IRRELEVANT_OPTIONS = {}
+  IRRELEVANT_HOST = '1.1.1.1'
+
+  def setup
+    @object = ResponderServer.new(IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR)
+  end
+
+  def test_initializes_server_on_specified_port
+    server = ResponderServer.new(6000, IRRELEVANT_BEHAVIOR)
+    assert_equal 6000, server.port
+  end
+
+  def test_initializes_server_on_specified_hostname
+    server = ResponderServer.new(IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR, 'hostname')
+    assert_equal 'hostname', server.host
+  end
+
+  def test_delegates_serve_call_to_responder
+    io = mock
+    responder = mock
+    server = ResponderServer.new(IRRELEVANT_PORT, responder)
+
+    responder.expects(:serve).with(io)
+
+    server.serve(io)
+  end
+
+  def test_connection_log_messages_use_short_behavior_name_to_shorten_log_messages
+    [:connecting, :disconnecting].each do |method|
+      assert_log_message_uses_short_behavior_name_for(method) do |server|
+        server.send(method, stub_everything(peeraddr: [127, 0, 0, 1]))
+      end
+    end
+  end
+
+  def test_start_stop_log_messages_use_short_behavior_name_to_shorten_log_messages
+    [:starting, :stopping].each do |method|
+      assert_log_message_uses_short_behavior_name_for(method) do |server|
+        server.send(method)
+      end
+    end
+  end
+
+  def assert_log_message_uses_short_behavior_name_for(method)
+    logger = StringIO.new
+    server = ResponderServer.new(IRRELEVANT_PORT, Bane::Behaviors::Responders::SampleForTesting.new)
+    server.stdlog = logger
+    
+    yield server
+
+    assert_match /SampleForTesting/, logger.string, "Log for #{method} should contain class short name"
+    assert_no_match /Behaviors::Responders::SampleForTesting/, logger.string, "Log for #{method} should not contain expanded module name"
+  end
+
+end
+
+module Bane
+  module Behaviors
+    module Responders
+      class SampleForTesting
+        def serve(io)
+          io.puts('Hello')
+        end
+      end
+    end
+  end
+end

data/test/bane/behaviors/servers/timeout_in_listen_queue_test.rb

@@ -0,0 +1,23 @@
+require_relative '../../../test_helper'
+require 'socket'
+
+class TimeoutInListenQueueTest < Test::Unit::TestCase
+
+  include LaunchableRoleTests
+  include ServerTestHelpers
+
+  def setup
+    @object = Bane::Behaviors::Servers::TimeoutInListenQueue.make(IRRELEVANT_PORT, Bane::Behaviors::Servers::LOCALHOST)
+  end
+
+  def test_never_connects
+    run_server(Bane::Behaviors::Servers::TimeoutInListenQueue.make(port, Bane::Behaviors::Servers::LOCALHOST)) do
+      assert_raise(Errno::ECONNREFUSED) { TCPSocket.new('localhost', port) }
+    end
+  end
+
+  def port
+    4001
+  end
+
+end

data/test/bane/command_line_configuration_test.rb

@@ -1,100 +1,82 @@
-require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
-require 'mocha'
+require_relative '../test_helper'
+require 'mocha/setup'
 
 class CommandLineConfigurationTest < Test::Unit::TestCase
   include Bane
 
-  IRRELEVANT_BEHAVIOR = "CloseImmediately"
+  # Creation tests (uses a cluster of objects starting at the top-level CommandLineConfiguration)
 
-  def test_creates_specified_behavior_on_given_port
-    expect_server_created_with(:port => 3000, :behavior => Behaviors::CloseImmediately)
-
-    create_configuration_for([3000, "CloseImmediately"])
-  end
-
-  def test_creates_all_known_behavior_if_only_port_specified
-    expect_server_created_with :port => 4000, :behavior => Behaviors::CloseImmediately
-    expect_server_created_with :port => 4001, :behavior => Behaviors::NeverRespond
-
-    ServiceRegistry.stubs(:all_servers).returns([Behaviors::CloseImmediately, Behaviors::NeverRespond])
-
-    create_configuration_for([4000])
+  def test_creates_specified_makeable_on_given_port
+    behaviors = process arguments: [3000, 'ThingA'],
+                       configuration: { 'ThingA' => SimpleMaker.new('ThingA'),
+                                        'ThingB' => SimpleMaker.new('ThingB') }
+    assert_equal 1, behaviors.size, "Wrong number of behaviors, got #{behaviors}"
+    assert_makeable_created(behaviors.first, port: 3000, name: 'ThingA')
   end
 
-  def test_creates_multiple_behaviors_starting_on_given_port
-    expect_server_created_with :port => 3000, :behavior => Behaviors::CloseImmediately
-    expect_server_created_with :port => 3001, :behavior => Behaviors::CloseAfterPause
+  def test_creates_multiple_makeables_on_increasing_ports
+    behaviors = process arguments: [4000, 'ThingA', 'ThingB'],
+                       configuration: {'ThingA' => SimpleMaker.new('ThingA'),
+                                       'ThingB' => SimpleMaker.new('ThingB') }
 
-    create_configuration_for([3000, "CloseImmediately", "CloseAfterPause"])
+    assert_equal 2, behaviors.size, "Wrong number of behaviors, got #{behaviors}"
+    assert_makeable_created(behaviors.first, port: 4000, name: 'ThingA')
+    assert_makeable_created(behaviors.last, port: 4000 + 1, name: 'ThingB')
   end
 
-  def test_dash_l_option_sets_listen_host_to_localhost
-    expect_server_created_with :host => BehaviorServer::DEFAULT_HOST
+  def test_creates_all_known_makeables_in_alphabetical_order_if_only_port_specified
+    behaviors = process arguments: [4000],
+                       configuration: { 'ThingB' => SimpleMaker.new('ThingB'),
+                                        'ThingC' => SimpleMaker.new('ThingC'),
+                                        'ThingA' => SimpleMaker.new('ThingA') }
 
-    create_configuration_for(["-l", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+    assert_equal 3, behaviors.size, "Wrong number of behaviors created, got #{behaviors}"
+    assert_equal 'ThingA', behaviors[0].name
+    assert_equal 'ThingB', behaviors[1].name
+    assert_equal 'ThingC', behaviors[2].name
   end
 
-  def test_listen_on_localhost_sets_listen_host_to_localhost
-    expect_server_created_with :host => BehaviorServer::DEFAULT_HOST
-
-    create_configuration_for(["--listen-on-localhost", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  def process(options)
+    arguments = options.fetch(:arguments)
+    makeables = options.fetch(:configuration)
+    CommandLineConfiguration.new(makeables).process(arguments) { |errors| raise errors }
   end
 
-  def test_dash_a_option_sets_listen_host_to_all_interfaces
-    expect_server_created_with :host => BehaviorServer::ALL_INTERFACES
-
-    create_configuration_for(["-a", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
-  end
-
-  def test_listen_on_all_hosts_option_sets_listen_host_to_all_interfaces
-    expect_server_created_with :host => BehaviorServer::ALL_INTERFACES
-
-    create_configuration_for(["--listen-on-all-hosts", IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR])
+  def assert_makeable_created(behaviors, parameters)
+    assert_equal parameters.fetch(:port), behaviors.port
+    assert_equal parameters.fetch(:name), behaviors.name
   end
 
-  def test_no_arguments_returns_empty_configuration
-    assert(create_configuration_for([]).empty?,
-      "Should have returned no configurations for empty arguments")
+  class SimpleMaker
+    attr_reader :name, :port, :host
+    def initialize(name)
+      @name = name
+    end
+
+    def make(port, host)
+      @port = port
+      @host = host
+      self
+    end
   end
 
-  def test_non_integer_port_fails_with_error_message
-    assert_invaild_arguments_fail_matching_message(["text_instead_of_an_integer"], /Invalid Port Number/i,
-      "Should have indicated the port was invalid.")
-  end
+  # Failure tests (uses a cluster of objects starting at the top-level CommandLineConfiguration)
 
-  def test_unknown_behavior_fails_with_unknown_behavior_message
-    assert_invaild_arguments_fail_matching_message([IRRELEVANT_PORT, "AnUknownBehavior"], /Unknown Behavior/i,
-      "Should have indicated the given behavior is unknown.")
+  def test_unknown_behavior_fails_with_message
+    assert_invalid_arguments_fail_matching_message([IRRELEVANT_PORT, 'AnUnknownBehavior'], /Unknown Behavior/i)
   end
 
   def test_invalid_option_fails_with_error_message
-    assert_invaild_arguments_fail_matching_message(["--unknown-option", IRRELEVANT_PORT], /Invalid Option/i,
-      "Should have indicated the --uknown-option switch was unknown.")
-  end
-
-
-  private
-
-  def create_configuration_for(array)
-    CommandLineConfiguration.new().parse(array)
+    assert_invalid_arguments_fail_matching_message(['--unknown-option', IRRELEVANT_PORT], /Invalid Option/i)
   end
 
-  def unique_behavior
-    Class.new
+  def assert_invalid_arguments_fail_matching_message(arguments, message_matcher)
+    block_called = false
+    CommandLineConfiguration.new({}).process(arguments) do |error_message|
+      block_called = true
+      assert_match message_matcher, error_message
+    end
+    assert block_called, "Expected invalid arguments to invoke the failure block"
   end
 
-  def expect_server_created_with(arguments)
-    arguments = { :port => anything(), :host => anything() }.merge(arguments)
-    behavior_matcher = arguments[:behavior] ? instance_of(arguments[:behavior]) : anything()
-    BehaviorServer.expects(:new).with(arguments[:port], behavior_matcher, arguments[:host])
-  end
-
-  def assert_invaild_arguments_fail_matching_message(arguments, message_matcher, assertion_failure_message)
-    create_configuration_for(arguments)
-    fail "Should have failed"
-    rescue ConfigurationError => ce
-      assert_match(message_matcher, ce.message, assertion_failure_message)
-  end
-
-
 end