bane 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+desc "Run all tests"
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files =  FileList['test/**/*_test.rb']
+  test.verbose    =  true
+end

data/TODO

@@ -0,0 +1,13 @@
+- Remove some duplication / clarify the ConfigurationParser class as needed
+- Dynamically create new behaviors like "SlowResponseForEachLine" by using Module.const_missing
+- Use ActiveSupport or create simple extensions for time durations (seconds, minutes, etc.)
+- Write the bad TCP/IP behaviors - using something like C/C++.
+- Write the remaining bad HTTP behaviors.  In addition, we may want to replace the NaiveHttpResponse with something
+  from the standard Ruby library, so that there's less code in this project, and so we know that we're
+  following the HTTP protocol.
+- Log every request to the server/behavior, in addition to open, close.  For this to work, it would have to be the
+  behavior's responsibility, since GServer#serve gets called only once for the lifetime of the connection.
+
+Ideas:
+- Make the Launcher use a Factory to create the server given a dependency, rather than depending directly on the
+  DelegatingGServer class.  This would make it possible to swap the base server implementation more easily.

data/bin/bane

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'bane'
+
+if ARGV.empty?
+  puts "Usage: bane port_number <servers>"
+  puts
+  puts "All behaviors:"
+  behavior_names = Bane::ServiceRegistry.all_servers.map(&:simple_name)
+  behavior_names.sort.each { |behavior| puts " - #{behavior}" }
+else
+  launcher = Bane::Launcher.new(Configuration(*ARGV))
+  launcher.start
+  launcher.join
+end
+

data/examples/simple_port_and_class_as_constant.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'bane'
+
+include Bane
+
+launcher = Launcher.new(Configuration(3000, Behaviors::CloseImmediately, Behaviors::CloseAfterPause))
+launcher.start
+launcher.join
+# runs until interrupt...

data/examples/simple_port_and_class_as_string.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'bane'
+
+launcher = Bane::Launcher.new(Configuration(3000, "CloseImmediately"))
+launcher.start
+launcher.join
+# runs until interrupt...

data/examples/specify_behavior_options.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'bane'
+
+include Bane
+include Behaviors
+
+launcher = Launcher.new(Configuration(
+        10256 => {:behavior => CloseAfterPause, :duration => 3},
+        10593 => {:behavior => FixedResponse, :message => "Hey!"},
+        10689 => {:behavior => SlowResponse, :message => "Custom message", :pause_duration => 15},
+        11239 => CloseAfterPause # Use the defaults for this behavior, don't need a Hash
+      )
+)
+launcher.start
+launcher.join
+# runs until interrupt...

data/examples/specify_ports.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'bane'
+
+include Bane
+include Behaviors
+
+launcher = Launcher.new(Configuration(
+        10256 => CloseAfterPause,
+        10689 => CloseAfterPause, # severs may be repeated
+        11999 => CloseImmediately
+      )
+)
+launcher.start
+launcher.join
+# runs until interrupt...

data/lib/bane.rb

@@ -0,0 +1,8 @@
+require 'bane/compatibility'
+require 'bane/service_registry'
+require 'bane/behaviors'
+require 'bane/launcher'
+require 'bane/delegating_gserver'
+require 'bane/configuration'
+require 'bane/configuration_parser'
+require 'bane/naive_http_response'

data/lib/bane/behaviors.rb

@@ -0,0 +1,151 @@
+module Bane
+
+  module Behaviors
+
+    class BasicBehavior
+      def self.inherited(clazz)
+        ServiceRegistry.register(clazz)
+      end
+
+      def self.simple_name
+        self.name.split("::").last
+      end
+    end
+
+    # This module can be used to wrap another behavior with
+    # a "while(io.gets)" loop, which reads a line from the input and
+    # then performs the given behavior.
+    module ForEachLine
+      def serve(io, options)
+        while (io.gets)
+          super(io, options)
+        end
+      end
+    end
+
+    # Closes the connection immediately after a connection is made.
+    class CloseImmediately < BasicBehavior
+      def serve(io, options)
+        # do nothing
+      end
+    end
+
+    # Accepts a connection, pauses a fixed duration, then closes the connection.
+    #
+    # Options:
+    #   - duration: The number of seconds to wait before disconnect.  Default: 30
+    class CloseAfterPause < BasicBehavior
+      def serve(io, options)
+        options = {:duration => 30}.merge(options)
+
+        sleep(options[:duration])
+      end
+    end
+
+    # Sends a static response.
+    #
+    # Options:
+    #   - message: The response message to send. Default: "Hello, world!"
+    class FixedResponse < BasicBehavior
+      def serve(io, options)
+        options = {:message => "Hello, world!"}.merge(options)
+
+        io.write options[:message]
+      end
+    end
+
+    class FixedResponseForEachLine < FixedResponse
+      include ForEachLine
+    end
+
+    # Sends a random response.
+    class RandomResponse < BasicBehavior
+      def serve(io, options)
+        io.write random_string
+      end
+
+      private
+      def random_string
+        (1..rand(26)+1).map { |i| ('a'..'z').to_a[rand(26)] }.join
+      end
+
+    end
+
+    class RandomResponseForEachLine < RandomResponse
+      include ForEachLine
+    end
+
+    # Sends a fixed response chacter-by-character, pausing in between each character.
+    #
+    # Options:
+    #  - message: The response to send. Default: "Hello, world!"
+    #  - pause_duration: The number of seconds to pause between each character. Default: 10 seconds
+    class SlowResponse < BasicBehavior
+      def serve(io, options)
+        options = {:message => "Hello, world!", :pause_duration => 10}.merge(options)
+        message = options[:message]
+        pause_duration = options[:pause_duration]
+
+        message.each_char do |char|
+          io.write char
+          sleep pause_duration
+        end
+      end
+    end
+
+    class SlowResponseForEachLine < SlowResponse
+      include ForEachLine
+    end
+
+    # Accepts a connection and never sends a byte of data.  The connection is
+    # left open indefinitely.
+    class NeverRespond < BasicBehavior
+      def serve(io, options)
+        loop { sleep 1 }
+      end
+    end
+
+    # Sends a large response.  Response consists of a repeated 'x' character.
+    #
+    # Options
+    #  - length: The size in bytes of the response to send. Default: 1,000,000 bytes
+    class DelugeResponse < BasicBehavior
+      def serve(io, options)
+        options = {:length => 1_000_000}.merge(options)
+        length = options[:length]
+
+        length.times { io.write('x') }
+      end
+    end
+
+    class DelugeResponseForEachLine < DelugeResponse
+      include ForEachLine
+    end
+
+    # Sends an HTTP 401 response (Unauthorized) for every request.  This
+    # attempts to mimic an HTTP server by reading a line (the request)
+    # and then sending the response.  This behavior responds to all
+    # incoming request URLs on the running port. 
+    class HttpRefuseAllCredentials < BasicBehavior
+      UNAUTHORIZED_RESPONSE_BODY = <<EOF
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Bane Server</title>
+  </head>
+  <body>
+    <h1>Unauthorized</h1>
+  </body>
+</html>
+EOF
+
+      def serve(io, options)
+        io.gets # Read the request before responding
+        response = NaiveHttpResponse.new(401, "Unauthorized", "text/html", UNAUTHORIZED_RESPONSE_BODY)
+        io.write(response.to_s)
+      end
+    end
+
+  end
+end
+

data/lib/bane/compatibility.rb

@@ -0,0 +1,20 @@
+class String
+  unless "".respond_to?(:each_char)
+    # copied from jcode in Ruby 1.8.6
+    def each_char
+      if block_given?
+        scan(/./m) do |x|
+          yield x
+        end
+      else
+        scan(/./m)
+      end
+    end
+  end
+
+  unless "".respond_to?(:lines)
+    require "enumerator"
+
+    alias_method :lines, :to_a
+  end
+end

data/lib/bane/configuration.rb

@@ -0,0 +1,50 @@
+module Bane
+  
+  class Configuration
+
+    def initialize(configurations)
+      @configurations = configurations
+    end
+
+    def start(logger)
+      @configurations.map do |config|
+        config.start(logger)
+      end
+    end
+
+    class ConfigurationRecord
+
+      def initialize(port, behavior, options = {})
+        @port = port
+        @behavior = behavior
+        @options = options
+      end
+
+      def start(logger)
+        new_server = DelegatingGServer.new(@port, @behavior.new, @options, logger)
+        new_server.start
+        new_server
+      end
+    end
+
+  end
+
+  class ConfigurationError < RuntimeError; end
+
+  class UnknownBehaviorError < RuntimeError
+    def initialize(name)
+      super "Unknown behavior: #{name}"
+    end
+  end
+
+end
+
+# Helper method to easily create configuration.
+#
+# This should likely take the constructor block from the Configuration class
+# and then we can simplify this class so it's not so big.
+module Kernel
+  def Configuration(*args)
+    Bane::Configuration.new(Bane::ConfigurationParser.new(*args).configurations)
+  end
+end

data/lib/bane/configuration_parser.rb

@@ -0,0 +1,74 @@
+module Bane
+
+  class ConfigurationParser
+
+    attr_reader :configurations
+
+
+    def initialize(*args)
+      @configurations = []
+
+      @configurations = case args[0]
+        when String, Integer
+          map_integer_and_behavior_arguments(*args)
+        when Hash
+          map_hash_arguments(args[0])
+        else
+          raise ConfigurationError, "Unknown configuration arguments #{args.inspect}"
+      end
+    end
+
+    private
+
+    def map_integer_and_behavior_arguments(*args)
+      port = Integer(args.shift)
+
+      behavior_classes = args
+      behavior_classes = ServiceRegistry.all_servers if behavior_classes.empty?
+
+      setup_linear_ports(port, behavior_classes)
+    end
+
+    def setup_linear_ports(port, behavior_classes)
+      behavior_classes.each_with_index do |behavior, index|
+        @configurations << Bane::Configuration::ConfigurationRecord.new(port + index, find(behavior))
+      end
+      @configurations
+    end
+
+    def find(behavior)
+      case behavior
+        when String
+          raise UnknownBehaviorError.new(behavior) unless Behaviors.const_defined?(behavior.to_sym)
+          Behaviors.const_get(behavior)
+        when Module
+          behavior
+        else
+          raise UnknownBehaviorError.new(behavior)
+      end
+    end
+
+    def map_hash_arguments(options)
+      options.each_pair do |key, value|
+        @configurations << extract_configuration_from(key, value)
+      end
+      @configurations
+    end
+
+    def extract_configuration_from(port, value)
+      case value
+        when Module
+          behavior = value
+          Bane::Configuration::ConfigurationRecord.new(port, behavior)
+        when Hash
+          behavior = value.delete(:behavior)
+          options = value
+          Bane::Configuration::ConfigurationRecord.new(port, behavior, options)
+        else
+          raise ConfigurationError, "Unknown configuration option: #{value.inspect}"
+      end
+    end
+
+  end
+
+end

data/lib/bane/delegating_gserver.rb

@@ -0,0 +1,42 @@
+require 'gserver'
+
+module Bane
+  class DelegatingGServer < GServer
+    def initialize(port, behavior, options = {}, logger = $stderr)
+      super(port)
+      @behavior = behavior
+      @options = options
+      self.audit = true
+      self.stdlog = logger
+    end
+
+    def serve(io)
+      @behavior.serve(io, @options)
+    end
+
+    protected
+
+    alias_method :original_log, :log
+
+    def log(message)
+      original_log("#{@behavior.class.simple_name} #{@host}:#{@port} #{message}")
+    end
+
+    def connecting(client)
+      addr = client.peeraddr
+      log("client:#{addr[1]} #{addr[2]}<#{addr[3]}> connect")
+    end
+
+    def disconnecting(client_port)
+      log("client:#{client_port} disconnect")
+    end
+
+    def starting()
+      log("start")
+    end
+
+    def stopping()
+      log("stop")
+    end
+  end
+end

data/lib/bane/launcher.rb

@@ -0,0 +1,25 @@
+module Bane
+
+  class Launcher
+
+    def initialize(configurations, logger = $stderr)
+      @configuration = configurations
+      @logger = logger
+      @running_servers = []
+    end
+
+    def start
+      @running_servers = @configuration.start(@logger)
+    end
+
+    def join
+      @running_servers.each { |server| server.join }
+    end
+
+    def stop
+      @running_servers.each { |server| server.stop }
+    end
+
+  end
+
+end

data/lib/bane/naive_http_response.rb

@@ -0,0 +1,46 @@
+class NaiveHttpResponse
+
+  CRLF        = "\r\n"
+
+  class HttpHeader
+    def initialize(headers)
+      @headers = headers
+    end
+
+    def to_s
+      @headers.map { |k, v| "#{k}: #{v}" }.join(CRLF)
+    end
+
+  end
+
+  def initialize(response_code, response_description, content_type, body)
+    @code = response_code
+    @description = response_description
+    @content_type = content_type
+    @body = body
+  end
+
+  def to_s
+    str = []
+    str << "HTTP/1.1 #{@code} #{@description}"
+    str << http_header.to_s
+    str << ""
+    str << @body
+    str.join(CRLF)
+  end
+
+  private
+
+  def http_header()
+    HttpHeader.new(
+            {"Server" => "Bane HTTP Server",
+             "Connection" => "close",
+             "Date" => http_date(Time.now),
+             "Content-Type" => @content_type,
+             "Content-Length" => @body.length})
+  end
+
+  def http_date(time)
+    time.gmtime.strftime("%a, %d %b %Y %H:%M:%S GMT")
+  end
+end

data/lib/bane/service_registry.rb

@@ -0,0 +1,17 @@
+module Bane
+
+  module ServiceRegistry
+    def self.all_servers
+      @servers ||= []
+    end
+
+    def self.register(server)
+      all_servers << server unless all_servers.include?(server)
+    end
+
+    def self.unregister(server)
+      all_servers.delete server
+    end
+  end
+
+end

data/test/bane/behaviors_test.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'timeout'
+require 'mocha'
+
+class BehaviorsTest < Test::Unit::TestCase
+
+  include Bane::Behaviors
+
+  class FakeConnection < StringIO
+    def will_send(query)
+      @query = query
+    end
+
+    def gets
+      @query
+      @read_query = true
+    end
+
+    def read_query?
+      @read_query
+    end
+  end
+
+  def setup
+    @fake_connection = FakeConnection.new
+  end
+
+  def test_fixed_response_sends_the_specified_message
+    query_server(create(FixedResponse), :message => "Test Message")
+
+    assert_equal "Test Message", response
+  end
+
+  def test_deluge_response_sends_one_million_bytes_by_default
+    query_server(create DelugeResponse)
+
+    assert_response_length 1_000_000
+  end
+
+  def test_deluge_response_accepts_length_parameter
+    query_server(create(DelugeResponse), :length => 1)
+
+    assert_response_length 1
+  end
+
+  def test_close_immediately_sends_no_response
+    query_server(create CloseImmediately)
+
+    assert_empty_response()
+  end
+
+  def test_never_respond_never_sends_a_response
+    server = create NeverRespond
+
+    assert_raise Timeout::Error do
+      Timeout::timeout(3) { query_server(server) }
+    end
+    assert_empty_response
+  end
+
+  def test_close_after_pause_sleeps_30_seconds_by_default_and_sends_nothing
+    server = create CloseAfterPause
+    server.expects(:sleep).with(30)
+    
+    query_server(server)
+
+    assert_empty_response
+  end
+
+  def test_close_after_pause_accepts_duration_parameter
+    server = create CloseAfterPause
+
+    within(2) { query_server(server, :duration => 1) }
+  end
+
+  def test_slow_response_sends_a_message_slowly
+    server = create SlowResponse
+    message = "Hi!"
+    delay = 0.5
+    max_delay = (message.length + 1) * delay
+
+    within(max_delay) { query_server(server, :pause_duration => delay, :message => message)}
+
+    assert_equal message, response
+  end
+
+  def test_random_response_sends_a_nonempty_response
+    query_server(create RandomResponse)
+
+    assert (!response.empty?), "Should have served a nonempty response"
+  end
+
+  def test_refuse_all_http_credentials_sends_401_response_code
+    @fake_connection.will_send("GET /some/irrelevant/path HTTP/1.1")
+
+    server = create(HttpRefuseAllCredentials)
+    query_server(server)
+
+    assert @fake_connection.read_query?, "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
+
+  def test_simple_name_strips_away_the_namespace
+    assert_equal "SlowResponse", Bane::Behaviors::SlowResponse.simple_name
+  end
+
+  private
+
+  def create(server_class)
+    server_class.new()
+  end
+
+  def query_server(server, options = {})
+    server.serve(@fake_connection, options)
+  end
+
+  def response
+    @fake_connection.string
+  end
+
+  def assert_empty_response
+    assert_equal 0, response.length, "Should have sent nothing"
+  end
+
+  def assert_response_length(expected_length)
+    assert_equal expected_length, response.length, "Response was the wrong length"
+  end
+
+  def within(duration)
+    begin
+      Timeout::timeout(duration) { yield }
+    rescue Timeout::Error
+      flunk "Test took too long - should have completed within #{duration} seconds."
+    end
+  end
+
+end

data/test/bane/configuration_parser_test.rb

@@ -0,0 +1,124 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'mocha'
+
+class ConfigurationParserTest < Test::Unit::TestCase
+
+  include Bane
+
+  IRRELEVANT_BEHAVIOR = Module.new
+
+  def test_should_map_single_port_and_server_name
+    parser = ConfigurationParser.new(3000, "CloseAfterPause")
+    assert_matches_configuration([
+            {:port => 3000, :behavior => Behaviors::CloseAfterPause}
+    ], parser)
+  end
+
+  def test_should_map_multiple_servers_given_one_starting_port
+    parser = ConfigurationParser.new(3000, "CloseImmediately", "CloseAfterPause")
+    assert_matches_configuration([
+            {:port => 3000, :behavior => Behaviors::CloseImmediately},
+            {:port => 3001, :behavior => Behaviors::CloseAfterPause}
+    ], parser)
+  end
+
+  def test_should_map_string_port
+    parser = Bane::ConfigurationParser.new("3000", IRRELEVANT_BEHAVIOR)
+    actual = parser.configurations[0]
+    assert_equal 3000, actual.instance_variable_get(:@port), "Should have mapped port given a String"
+  end
+
+  def test_should_raise_if_unknown_server_name
+    assert_raises Bane::UnknownBehaviorError do
+      Bane::ConfigurationParser.new(IRRELEVANT_PORT, "ABehaviorThatDoesNotExist")
+    end
+  end
+
+  def test_should_map_server_when_given_class
+    parser = ConfigurationParser.new(IRRELEVANT_PORT, Behaviors::CloseAfterPause)
+    actual = parser.configurations[0]
+    assert_equal Behaviors::CloseAfterPause, actual.instance_variable_get(:@behavior), "Wrong behavior"
+  end
+
+  def test_should_ask_service_registry_for_all_behaviors_if_none_specified
+    fake_behavior = unique_behavior
+    another_fake_behavior = unique_behavior
+
+    ServiceRegistry.expects(:all_servers).returns([fake_behavior, another_fake_behavior])
+    parser = ConfigurationParser.new(4000)
+    assert_matches_configuration([
+            {:port => 4000, :behavior => fake_behavior},
+            {:port => 4001, :behavior => another_fake_behavior}
+    ], parser)
+  end
+
+  def test_should_raise_exception_if_no_arguments
+    assert_raises ConfigurationError do
+      ConfigurationParser.new
+    end
+  end
+
+  def test_should_raise_exception_if_nil_port_with_behaviors
+    assert_raises ConfigurationError do
+      ConfigurationParser.new(nil, IRRELEVANT_BEHAVIOR)
+    end
+  end
+
+  def test_should_map_single_hash_entry_as_port_and_behavior
+    parser = ConfigurationParser.new(
+            10256 => Behaviors::CloseAfterPause
+    )
+
+    assert_matches_configuration([
+            {:port => 10256, :behavior => Behaviors::CloseAfterPause}
+    ], parser)
+  end
+  
+  def test_should_map_multiple_hash_entries_as_port_and_behavior
+    parser = ConfigurationParser.new(
+            10256 => Behaviors::CloseAfterPause,
+            6450 => Behaviors::CloseImmediately
+    )
+
+    assert_matches_configuration([
+            {:port => 10256, :behavior => Behaviors::CloseAfterPause},
+            {:port => 6450, :behavior => Behaviors::CloseImmediately}
+    ], parser)
+  end
+
+  def test_should_map_hash_with_options
+    parser = ConfigurationParser.new(
+            10256 => {:behavior => Behaviors::CloseAfterPause, :duration => 3},
+            11239 => Behaviors::CloseImmediately
+    )
+    
+    assert_matches_configuration([
+            {:port => 10256, :behavior => Behaviors::CloseAfterPause},
+            {:port => 11239, :behavior => Behaviors::CloseImmediately}
+    ], parser)
+  end
+
+  private
+
+  def assert_matches_configuration(expected_config, actual_config)
+    actual_elements = actual_config.configurations
+    assert_equal expected_config.size, actual_elements.size, "Did not create correct number of configurations. Actual: #{actual_elements}, expected #{expected_config}"
+
+    expected_config.each do |expected|
+      # We make no guarantee on the order of the configurations
+      assert_includes_configuration(actual_elements, expected)
+    end
+  end
+
+  def assert_includes_configuration(actual_elements, expected)
+    expected_port = expected[:port]
+    matching_config = actual_elements.detect { |actual| actual.instance_variable_get(:@port) == expected_port }
+    assert_not_nil matching_config, "Should have found a configuration with port #{expected_port}"
+    assert_equal expected[:behavior], matching_config.instance_variable_get(:@behavior), "Wrong behavior for port #{expected_port}"
+  end
+
+  def unique_behavior
+    Module.new
+  end
+
+end

data/test/bane/configuration_test.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'mocha'
+
+module Bane
+  module Behaviors
+    class FakeTestServer < BasicBehavior
+    end
+  end
+end
+
+class ConfigurationTest < Test::Unit::TestCase
+
+  include Bane
+  
+  def test_starts_server_on_specified_port
+    target_port = 4000
+    DelegatingGServer.expects(:new).with(equals(target_port), anything(), anything(), anything()).returns(fake_server)
+
+    start_configuration(target_port, Behaviors::FakeTestServer)
+  end
+
+  def test_starts_server_with_specified_behavior
+    behavior_instance = stub('constructed behavior instance')
+    Behaviors::FakeTestServer.expects(:new).returns(behavior_instance)
+    DelegatingGServer.expects(:new).with(anything(), equals(behavior_instance), anything(), anything()).returns(fake_server)
+
+    start_configuration(IRRELEVANT_PORT, Behaviors::FakeTestServer)
+  end
+
+  def test_constructs_server_with_specified_options
+    options = { :an_option => :a_value, :another_option => :another_value }
+    DelegatingGServer.expects(:new).with(anything(), anything, has_entries(options), anything()).returns(fake_server)
+
+    start_configuration(IRRELEVANT_PORT, Behaviors::FakeTestServer, options)
+  end
+
+  private
+
+  def start_configuration(target_port, behavior, options = {})
+    configuration = configuration_with(target_port, behavior, options)
+    configuration.start(StringIO.new)
+  end
+
+  def configuration_with(port, behavior, options)
+    Configuration.new([Configuration::ConfigurationRecord.new(port, behavior, options)])
+  end
+
+  def fake_server
+    stub_everything('fake_server')
+  end
+
+end

data/test/bane/delegating_gserver_test.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'mocha'
+
+class DelegatingGserverTest < Test::Unit::TestCase
+  include Bane
+  
+  IRRELEVANT_IO_STREAM = nil
+  IRRELEVANT_OPTIONS = {}
+
+  def test_serve_passes_a_hash_of_options_even_if_not_initialized_with_options
+    behavior = mock()
+    server = DelegatingGServer.new(IRRELEVANT_PORT, behavior)
+
+    behavior.expects(:serve).with(anything(), is_a(Hash))
+
+    server.serve(IRRELEVANT_IO_STREAM)
+  end
+
+  def test_serve_passes_constructor_options_to_behaviors_serve_method
+    behavior = mock()
+    
+    initialized_options = {:expected => :options}
+    server = DelegatingGServer.new(IRRELEVANT_PORT, behavior, initialized_options)
+
+    behavior.expects(:serve).with(anything(), equals(initialized_options))
+
+    server.serve(IRRELEVANT_IO_STREAM)
+  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 = DelegatingGServer.new(IRRELEVANT_PORT, Bane::Behaviors::CloseImmediately.new, IRRELEVANT_OPTIONS, logger)
+
+    yield server
+
+    assert_match /CloseImmediately/, logger.string, "Log for #{method} should contain class short name"
+    assert_no_match /Behaviors::CloseImmediately/, logger.string, "Log for #{method} should not contain expanded module name"
+  end
+
+end

data/test/bane/integration_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'net/telnet'
+require 'open-uri'
+
+class BaneIntegrationTest < Test::Unit::TestCase
+
+  TEST_PORT = 4000
+
+  def test_uses_specified_port_and_server
+    run_server_with(TEST_PORT, "FixedResponse") do
+      telnet_to TEST_PORT do |response|
+        assert !response.empty?, "Should have had a non-empty response"
+      end
+    end
+  end
+
+  def test_uses_behavior_options
+    expected_message = "Expected test message"
+    options = {TEST_PORT => {:behavior => Bane::Behaviors::FixedResponse,
+                             :message => expected_message}}
+
+    run_server_with(options) do
+      telnet_to TEST_PORT do |response|
+        assert_equal expected_message, response, "Wrong response from server"
+      end
+    end
+  end
+
+  def test_serves_http_requests
+    run_server_with(TEST_PORT, "HttpRefuseAllCredentials") do
+      begin
+        open("http://localhost:#{TEST_PORT}/some/url").read
+        flunk "Should have refused access"
+      rescue OpenURI::HTTPError => e
+        assert_match /401/, e.message
+      end
+    end
+
+  end
+
+  private
+
+  def run_server_with(*options)
+    begin
+      launcher = Bane::Launcher.new(Configuration(*options), quiet_logger)
+      launcher.start
+      yield
+    ensure
+      launcher.stop if launcher
+    end
+  end
+
+  def quiet_logger
+    StringIO.new
+  end
+  
+  def telnet_to(port)
+    begin
+      telnet = Net::Telnet::new("Host" => "localhost",
+                                "Port" => port,
+                                "Timeout" => 5)
+      yield telnet.read
+    ensure
+      telnet.close
+    end
+  end
+end

data/test/bane/launcher_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'mocha'
+
+class LauncherTest < Test::Unit::TestCase
+
+  include Bane
+
+  def test_start_delegates_to_configuration
+    configuration = mock()
+    logger = stub()
+    launcher = Launcher.new(configuration, logger)
+
+    configuration.expects(:start).with(equals(logger))
+    launcher.start
+  end
+end

data/test/bane/naive_http_response_test.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class NaiveHttpResponseTest < Test::Unit::TestCase
+
+  IRRELEVANT_RESPONSE_CODE = "999"
+  IRRELEVANT_RESPONSE_DESCRIPTION = "Irrelevant description"
+  IRRELEVANT_CONTENT_TYPE = "irrelevant content type"
+  IRRELEVANT_BODY = "irrelevant body"
+
+  def test_should_send_http_format_string
+    response = response_for("200", "OK", IRRELEVANT_CONTENT_TYPE, IRRELEVANT_BODY)
+    assert_equal "HTTP/1.1 200 OK\r\n", response.lines.first, "First line should be HTTP status"
+  end
+
+  def test_should_include_date
+    assert_match /Date: .*/, any_response, 'Should have included a Date header'
+  end
+
+  def test_should_set_content_type
+    response = response_for(IRRELEVANT_RESPONSE_CODE,
+                            IRRELEVANT_RESPONSE_DESCRIPTION,
+                            "text/xml",
+                            IRRELEVANT_BODY)
+    assert_match /Content-Type: text\/xml/, response, 'Should have included content type'
+  end
+
+  def test_should_set_content_length_as_length_of_body_in_bytes
+    message = "Hello, there!"
+    response = response_for(IRRELEVANT_RESPONSE_CODE,
+                            IRRELEVANT_RESPONSE_DESCRIPTION,
+                            IRRELEVANT_CONTENT_TYPE,
+                            message)
+
+    assert_match /Content-Length: #{message.length}/, response, 'Should have included content length'
+  end
+
+  def test_should_include_newline_between_headers_and_body
+    message = "This is some body content."
+    response = response_for(IRRELEVANT_RESPONSE_CODE,
+                            IRRELEVANT_RESPONSE_DESCRIPTION,
+                            IRRELEVANT_CONTENT_TYPE,
+                            message)
+
+    response_lines = response.lines.to_a
+    index_of_body_start = response_lines.index(message)
+    line_before_body = response_lines[index_of_body_start - 1]
+    assert line_before_body.strip.empty?, "Should have had blank line before the body"
+  end
+
+  def test_should_include_the_body_at_the_end_of_the_response
+    message = "This is some body content."
+    response = response_for(IRRELEVANT_RESPONSE_CODE,
+                            IRRELEVANT_RESPONSE_DESCRIPTION,
+                            IRRELEVANT_CONTENT_TYPE,
+                            message)
+    assert_match /#{message}$/, response, "Should have ended the response with the body content"
+  end
+
+  private
+
+  def response_for(response_code, response_description, content_type, body)
+    NaiveHttpResponse.new(response_code, response_description, content_type, body).to_s
+  end
+
+  def any_response
+    response_for(IRRELEVANT_RESPONSE_CODE, IRRELEVANT_RESPONSE_DESCRIPTION, IRRELEVANT_CONTENT_TYPE, IRRELEVANT_BODY)
+  end
+
+end

data/test/bane/service_registry_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ServiceRegistryTest < Test::Unit::TestCase
+
+  include Bane
+  
+  def test_should_add_and_remove_behaviors
+    fake = fake_behavior
+
+    ServiceRegistry.register(fake)
+    assert ServiceRegistry.all_servers.include?(fake), "Should have added the new behavior"
+
+    ServiceRegistry.unregister(fake)
+    assert !(ServiceRegistry.all_servers.include?(fake)), "Should have removed the new behavior"
+  end
+
+  def fake_behavior
+    Class.new
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+require 'stringio'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'bane'
+
+
+IRRELEVANT_PORT = 4001

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: bane
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Daniel Wellman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+description: "    Bane is a test harness used to test your application's interaction with \n    other servers. It is based upon the material from Michael Nygard's \"Release\n    It!\" book as described in the \"Test Harness\" chapter.\n"
+email: dan@danielwellman.com
+executables: 
+- bane
+extensions: []
+
+extra_rdoc_files: 
+- TODO
+files: 
+- lib/bane/behaviors.rb
+- lib/bane/compatibility.rb
+- lib/bane/configuration.rb
+- lib/bane/configuration_parser.rb
+- lib/bane/delegating_gserver.rb
+- lib/bane/launcher.rb
+- lib/bane/naive_http_response.rb
+- lib/bane/service_registry.rb
+- lib/bane.rb
+- bin/bane
+- test/bane/behaviors_test.rb
+- test/bane/configuration_parser_test.rb
+- test/bane/configuration_test.rb
+- test/bane/delegating_gserver_test.rb
+- test/bane/integration_test.rb
+- test/bane/launcher_test.rb
+- test/bane/naive_http_response_test.rb
+- test/bane/service_registry_test.rb
+- test/test_helper.rb
+- examples/simple_port_and_class_as_constant.rb
+- examples/simple_port_and_class_as_string.rb
+- examples/specify_behavior_options.rb
+- examples/specify_ports.rb
+- Rakefile
+- TODO
+has_rdoc: true
+homepage: http://github.com/danielwellman/bane
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A test harness for socket connections based upon ideas from Michael Nygard's 'Release It!'
+test_files: []
+