bane 0.3.0 → 0.4.0

data/lib/bane/compatibility.rb

@@ -1,36 +0,0 @@
-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
-
-# Copied from ActiveSupport
-unless :to_proc.respond_to?(:to_proc)
-  class Symbol
-    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
-    #
-    #   # The same as people.collect { |p| p.name }
-    #   people.collect(&:name)
-    #
-    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
-    #   people.select(&:manager?).collect(&:salary)
-    def to_proc
-      Proc.new { |*args| args.shift.__send__(self, *args) }
-    end
-  end
-end

data/lib/bane/configuration_parser.rb

@@ -1,89 +0,0 @@
-module Bane
-
-  class ConfigurationParser
-
-    attr_reader :configurations
-
-    def initialize(*args)
-      warn_about_deprecation()
-      @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
-
-    def warn_about_deprecation
-      warn "Kernel#Configuration() and ConfigurationParser are deprecated. Please directly construct an array of BehaviorServers to pass to Launcher."
-    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 << create_server(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
-          create_server(port, behavior)
-        when Hash
-          behavior = value.delete(:behavior)
-          options = value
-          create_server(port, behavior, options)
-        else
-          raise ConfigurationError, "Unknown configuration option: #{value.inspect}"
-      end
-    end
-
-    def create_server(port, behavior, options = {})
-      BehaviorServer.new(port, behavior.new(options), BehaviorServer::DEFAULT_HOST)
-    end
-
-  end
-
-end
-
-# Helper method to easily create configuration.
-module Kernel
-  def Configuration(*args)
-    Bane::ConfigurationParser.new(*args).configurations
-  end
-end

data/lib/bane/service_registry.rb

@@ -1,21 +0,0 @@
-module Bane
-
-  module ServiceRegistry
-    def self.all_servers
-      @servers ||= []
-    end
-
-    def self.all_server_names
-      all_servers.map(&:simple_name).sort
-    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/behavior_server_test.rb

@@ -1,59 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
-require 'mocha'
-
-class BehaviorServerTest < Test::Unit::TestCase
-  include Bane
-  
-  IRRELEVANT_IO_STREAM = nil
-  IRRELEVANT_OPTIONS = {}
-  IRRELEVANT_HOST = "1.1.1.1"
-  IRRELEVANT_BEHAVIOR = nil
-
-  def test_initializes_server_on_specified_port
-    server = BehaviorServer.new(6000, IRRELEVANT_BEHAVIOR)
-    assert_equal 6000, server.port
-  end
-
-  def test_initializes_server_on_specified_hostname
-    server = BehaviorServer.new(IRRELEVANT_PORT, IRRELEVANT_BEHAVIOR, "hostname")
-    assert_equal "hostname", server.host
-  end
-
-  def test_delegates_serve_call_to_behavior
-    io = mock()
-    behavior = mock()
-    server = BehaviorServer.new(IRRELEVANT_PORT, behavior)
-
-    behavior.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 = BehaviorServer.new(IRRELEVANT_PORT, Bane::Behaviors::CloseImmediately.new)
-    server.stdlog = 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/behaviors_test.rb

@@ -1,135 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
-require 'timeout'
-require 'mocha'
-
-class BehaviorsTest < Test::Unit::TestCase
-
-  include Bane::Behaviors
-
-  def setup
-    @fake_connection = FakeConnection.new
-  end
-
-  def test_fixed_response_sends_the_specified_message
-    query_server(FixedResponse.new(:message => "Test Message"))
-
-    assert_equal "Test Message", response
-  end
-
-  def test_newline_response_sends_only_a_newline_character
-    query_server(NewlineResponse.new)
-
-    assert_equal "\n", response
-  end
-
-  def test_deluge_response_sends_one_million_bytes_by_default
-    query_server(DelugeResponse.new)
-
-    assert_response_length 1_000_000
-  end
-
-  def test_deluge_response_accepts_length_parameter
-    query_server(DelugeResponse.new(:length => 1))
-
-    assert_response_length 1
-  end
-
-  def test_close_immediately_sends_no_response
-    query_server(CloseImmediately.new)
-
-    assert_empty_response()
-  end
-
-  def test_never_respond_never_sends_a_response
-    server = NeverRespond.new
-
-    assert_raise Timeout::Error do
-      Timeout::timeout(1) { query_server(server) }
-    end
-    assert_empty_response
-  end
-
-  def test_close_after_pause_sleeps_30_seconds_by_default
-    server = CloseAfterPause.new
-    server.expects(:sleep).with(30)
-
-    query_server(server)
-  end
-
-
-  def test_close_after_pause_accepts_duration_parameter
-    server = CloseAfterPause.new(:duration => 1)
-    server.expects(:sleep).with(1)
-
-    query_server(server)
-  end
-
-  def test_close_after_pause_sends_nothing
-    server = CloseAfterPause.new
-    server.stubs(:sleep)
-
-    query_server(server)
-  end
-
-  def test_slow_response_sends_a_message_slowly
-    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
-
-  def test_random_response_sends_a_nonempty_response
-    query_server(RandomResponse.new)
-
-    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 = 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
-
-  def test_simple_name_strips_away_the_namespace
-    assert_equal "SlowResponse", Bane::Behaviors::SlowResponse.simple_name
-  end
-
-  def test_for_each_line_reads_a_line_before_responding
-    server = Bane::Behaviors::FixedResponseForEachLine.new({:message => "Dynamic"})
-
-    @fake_connection.will_send "irrelevant\n"
-
-    query_server(server)
-    assert_equal "Dynamic", response
-
-    assert @fake_connection.read_all_queries?
-  end
-
-  private
-
-  def query_server(server)
-    server.serve(@fake_connection)
-  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
-
-end

data/test/bane/configuration_parser_test.rb

@@ -1,111 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + '/../test_helper'
-require 'mocha'
-
-class ConfigurationParserTest < Test::Unit::TestCase
-
-  include Bane
-
-  IRRELEVANT_BEHAVIOR = Bane::Behaviors::CloseImmediately
-
-  def setup
-    ConfigurationParser.any_instance.stubs(:warn_about_deprecation)
-  end
-
-  def test_should_map_single_port_and_server_name
-    expect_server_created_with :port => 3000, :behavior => Behaviors::CloseAfterPause
-
-    ConfigurationParser.new(3000, "CloseAfterPause")
-  end
-
-  def test_should_map_multiple_servers_given_one_starting_port
-    expect_server_created_with :port => 3000, :behavior => Behaviors::CloseImmediately
-    expect_server_created_with :port => 3001, :behavior => Behaviors::CloseAfterPause
-
-    ConfigurationParser.new(3000, "CloseImmediately", "CloseAfterPause")
-  end
-
-  def test_should_map_string_port
-    expect_server_created_with :port => 3000, :behavior => IRRELEVANT_BEHAVIOR
-    
-    Bane::ConfigurationParser.new("3000", IRRELEVANT_BEHAVIOR)
-  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
-    expect_server_created_with :port => anything(), :behavior => Behaviors::CloseAfterPause
-
-    ConfigurationParser.new(IRRELEVANT_PORT, Behaviors::CloseAfterPause)
-  end
-
-  def test_should_ask_service_registry_for_all_behaviors_if_none_specified
-    fake_behavior = unique_behavior
-    another_fake_behavior = unique_behavior
-
-    expect_server_created_with :port => anything(), :behavior => fake_behavior
-    expect_server_created_with :port => anything(), :behavior => another_fake_behavior
-
-    ServiceRegistry.expects(:all_servers).returns([fake_behavior, another_fake_behavior])
-    ConfigurationParser.new(4000)
-  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
-    expect_server_created_with :port => 10256, :behavior => Behaviors::CloseAfterPause
-
-    ConfigurationParser.new(
-            10256 => Behaviors::CloseAfterPause
-    )
-  end
-  
-  def test_should_map_multiple_hash_entries_as_port_and_behavior
-    expect_server_created_with :port => 10256, :behavior => Behaviors::CloseAfterPause
-    expect_server_created_with :port => 6450, :behavior => Behaviors::CloseImmediately
-
-    ConfigurationParser.new(
-            10256 => Behaviors::CloseAfterPause,
-            6450 => Behaviors::CloseImmediately
-    )
-  end
-
-  def test_should_map_hash_with_options
-    expect_server_created_with :port => 10256, :behavior => Behaviors::CloseAfterPause, :options => { :duration => 3 }
-    expect_server_created_with :port => 11239, :behavior => Behaviors::CloseImmediately
-
-    ConfigurationParser.new(
-            10256 => {:behavior => Behaviors::CloseAfterPause, :duration => 3},
-            11239 => Behaviors::CloseImmediately
-    )
-  end
-
-  private
-
-  def expect_server_created_with(arguments)
-    arguments = { :options => anything() }.merge(arguments)
-    a_behavior_instance = "an instance of #{arguments[:behavior]}.to_s"
-    behavior = arguments[:behavior]
-    behavior.expects(:new).with(arguments[:options]).returns(a_behavior_instance)
-    BehaviorServer.expects(:new).with(arguments[:port], a_behavior_instance, BehaviorServer::DEFAULT_HOST)
-  end
-
-  
-  def unique_behavior
-    Class.new
-  end
-
-end