eric-adhearsion 0.7.999

data/spec/voip/asterisk/test_config_manager.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require 'adhearsion/voip/asterisk/config_manager'
+
+context "The configuration file parser behavior" do
+  
+  include ConfigurationManagerTestHelper
+  
+  test "should expose a sections array" do
+    manager = mock_config_manager
+    manager.sections.map(&:first).should.equal(["jicksta", "picard"])
+  end
+  
+  test "should ignore comments" do
+    context_names = %w(monkey data)
+    tested_key_name, tested_key_value_before_comment = "bar", "baz"
+    manager = mock_config_manager_for <<-CONFIG
+[monkey]
+#{tested_key_name}=#{tested_key_value_before_comment};thiscommentshouldnotbehere
+asdf=fdsa
+;[data]
+;ignored=asdf
+    CONFIG
+    manager.sections.map(&:first).should.equal [context_names.first]
+    manager[context_names.first].size.should.equal 2
+    manager[context_names.first][tested_key_name].should.equal tested_key_value_before_comment
+  end
+  
+  test "should match context names with dashes and underscores" do
+    context_names = %w"foo-bar qaz_b-a-z"
+    definition_string = <<-CONFIG
+[#{context_names.first}]
+platypus=no
+zebra=no
+crappyconfig=yes
+
+[#{context_names.last}]
+callerid="Jay Phillips" <133>
+    CONFIG
+    mock_config_manager_for(definition_string).sections.map(&:first).should.equal context_names
+  end
+  
+  test "should strip whitespace around keys and values" do
+    section_name = "hey-there-hot-momma"
+    tested_key_name, tested_key_value_before_comment = "bar", "i heart white space. SIKE!"
+    config_manager = mock_config_manager_for <<-CONFIG
+   \t[#{section_name}]                              
+  
+   thereis            =  a lot of whitespace after these                      
+
+    #{tested_key_name}   = \t\t\t #{tested_key_value_before_comment}                
+        
+    CONFIG
+    config_manager[section_name][tested_key_name].should.equal tested_key_value_before_comment
+  end
+  
+  test "should return a Hash of properties when searching for an existing section" do
+    result = mock_config_manager["jicksta"]
+    result.should.be.kind_of Hash
+    result.size.should.equal 3
+  end
+  
+  test "should return nil when searching for a non-existant section" do
+    mock_config_manager["i-so-dont-exist-dude"].should.be.nil
+  end
+  
+end
+
+context "The configuration file writer" do
+  
+  include ConfigurationManagerTestHelper
+  
+  attr_reader :config_manager
+  
+  setup do
+    @config_manager = mock_config_manager
+  end
+  
+  test "should remove an old section when replacing it" do
+    config_manager.delete_section "picard"
+    config_manager.sections.map(&:first).should.equal ["jicksta"]
+  end
+  
+  test "should add a new section to the end" do
+    section_name = "wittynamehere"
+    config_manager.new_section(section_name, :type => "friend",
+                                             :witty => "yes",  
+                                             :shaken => "yes", 
+                                             :stirred => "no")
+    new_section = config_manager.sections.last
+    new_section.first.should.equal section_name
+    new_section.last.size.should.equal 4
+  end
+end
+
+context "The configuration file generator" do 
+end
+
+BEGIN {
+module ConfigurationManagerTestHelper
+  
+  def mock_config_manager
+    mock_config_manager_for sample_standard_config
+  end
+  
+  def mock_config_manager_for(config_string)
+    returning new_config_manager_with("bogus filename") do |manager|
+      flexmock(manager).should_receive(:execute).and_return(config_string)
+    end
+  end
+  
+  def new_config_manager_with(filename)
+    Adhearsion::VoIP::Asterisk::ConfigurationManager.new(filename)
+  end
+  
+  def sample_standard_config
+    <<-CONFIG
+[jicksta]
+foo=bar
+qaz=qwerty
+baz=zxcvb
+[picard]
+type=friend
+insecure=very
+host=dynamic
+secret=blargh
+    CONFIG
+  end
+end
+}

data/spec/voip/dsl/dispatcher_spec_helper.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+require 'adhearsion/voip/dsl/dialplan/dispatcher'
+
+module StandardDispatcherBehavior  
+  def xtest_standard_dispatcher_behavior
+    #"This test looks bogus.  Not finished?  Let's not check in failing specs ever if we can help it."
+    returned_event_command = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "ilikesexypants"
+    linking_event_command = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "ihavesexypants" do
+      returned_event_command
+    end
+    
+    dispatcher = @dispatcher_class.new MyFactory
+    dispatcher.should_receive(:dispatch!).with(linking_event_command, returned_event_command).and_return(linking_event_command, returned_event_command)
+    # returned_event_command.should_receive(:command_block).and_return nil
+    dispatcher.dispatch! linking_event_command
+  end
+end
+
+class NilDispatcher < Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher
+  def dispatch!(string)
+    # Would send it off to the PBX here (or prepend something to the String)
+  end
+end
+
+class EvalDispatcher < Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher
+  def dispatch!(event)
+    eval event.app.to_s
+  end
+end
+
+class MyFactory
+  
+  def initialize(context)
+    @context = context
+  end
+  
+  def sequence
+    all = []
+    EventCommand.new("2", :response => Numeric) do |response|
+      all << response
+      all.size > 3 ? all : nil
+    end
+  end
+end

data/spec/voip/dsl/test_dialing_dsl.rb

@@ -0,0 +1,268 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'adhearsion/voip/dsl/dialing_dsl'
+
+# Keep the monkey patches in a module and load that into Regexp
+# eigenclasses during a before(:all) block?
+
+describe "RouteRule Regexp assembling" do
+  
+  test "should compile two Regexps" do
+    first, last = /jay/, /phillips/
+    r = first | last
+    r.patterns.should == [first, last]
+  end
+  
+  test "should compile three or more Regexps" do
+    first, second, third = /lorem/, /ipsum/, /dolar/
+    r = first | second | third
+    r.patterns.should == [first, second, third]
+  end
+  
+end
+
+describe "RouteRule assembling with one provider definition" do
+  
+  before :each do
+    @provider = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:icanhascheezburger?)
+  end
+  
+  test "should store one pattern properly" do
+    pattern = /lorem/
+    route = pattern >> @provider
+    route.patterns.should == [pattern]
+  end
+  
+  test "should store three patterns properly" do
+    first, second, third = /lorem/, /ipsum/, /dolar/
+    route = first | second | third >> @provider
+    route.patterns.should == [first, second, third]
+    route.providers.should == [@provider]
+  end
+  
+end
+
+describe "RouteRule assembling with multiple patterns and multiple provider definitions" do
+  
+  before:each do
+    1.upto 3 do |i|
+      instance_variable_set "@prov_#{i}",
+        Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new("prov_#{i}")
+      instance_variable_set "@pattern_#{i}", /^#{i * 100}$/
+    end
+  end
+  
+  test "should store the patterns properly" do
+    route_1 = @pattern_1 | @pattern_2 | @pattern_3 >> @prov_1 >> @prov_2 >> @prov_3
+    route_1.patterns.should == [@pattern_1, @pattern_2, @pattern_3]
+    
+    route_2 = @pattern_2 | @pattern_3 | @pattern_1 >> @prov_3 >> @prov_2 >> @prov_1
+    route_2.patterns.should == [@pattern_2, @pattern_3, @pattern_1]
+  end
+  
+  test "should store the providers properly" do
+    route_1 = @pattern_1 | @pattern_2 | @pattern_3 >> @prov_1 >> @prov_2 >> @prov_3
+    route_1.providers.should == [@prov_1, @prov_2, @prov_3]
+    
+    route_2 = @pattern_2 | @pattern_3 | @pattern_1 >> @prov_3 >> @prov_2 >> @prov_1
+    route_2.patterns.should == [@pattern_2, @pattern_3, @pattern_1]
+  end
+end
+
+describe "The DialingDSL class internals" do
+  
+  test "should allow Asterisk-like patterns" do
+    Adhearsion::VoIP::DSL::DialingDSL.class_eval do
+      _('23XX')
+    end.should.be.instance_of Regexp
+  end
+  
+  test "should define all of the VoIP constants" do
+    lambda do
+      Adhearsion::VoIP::Constants.constants.each do |constant|      
+        eval "Adhearsion::VoIP::DSL::DialingDSL::#{constant}"
+      end
+    end.should.not.raise NameError
+  end
+  
+  # test "should define a DUNDI constant"
+  
+  test "should synchronize access to the trunking information for Thread safety"
+  
+end
+
+describe "The provider DSL's 'provider' macro" do
+  
+  test "should make the providers available in the order they were received" do
+    provider_holder = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    provider_holder.class_eval do
+      provider(:tweedledee) {}
+      provider(:tweedledum) {}
+    end
+    provider_holder.providers.map { |x| x.name }.should == [:tweedledee, :tweedledum]
+  end
+  test "should define a singleton method for the provider name given" do
+    Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
+      class_variable_get(:@@providers).size.should == 0
+      
+      provider(:icanhascheezburger?) {}
+      
+      should.respond_to(:icanhascheezburger?)
+      class_variable_get(:@@providers).size.should == 1
+    end
+  end
+  test "should not define a class-wide method for the provider name given" do
+    Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
+      provider(:icanhascheezburger?) {}
+    end
+    Adhearsion::VoIP::DSL::DialingDSL.class_eval do
+      class_variable_defined?(:@@providers).should == false
+      should.not.respond_to(:icanhascheezburger?)
+    end
+  end
+  test "should yield a ProviderDefinition object" do
+    possible_provider_definition = nil
+    Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
+      provider(:blah) { |pd| possible_provider_definition = pd }
+    end
+    possible_provider_definition.should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition)
+  end
+  test "should raise an error when no block is given" do
+    the_following_code do
+      Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
+        provider :explode
+      end
+    end.should.raise ArgumentError
+  end
+end
+
+describe "The provider DSL's monkey patches to Regexp" do
+  test "should return a RouteRule when using Regexp#| with another Regexp" do
+    (// | //).should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  test "should return a RouteRule when chaining three Regexp's with the | operator" do
+    (// | // | //).should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  test "should return a RouteRule when Regexp#| is given a RouteRule" do
+    route_rule = Adhearsion::VoIP::DSL::DialingDSL::RouteRule.new :patterns => //
+    (// | route_rule).should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  test "should return a RouteRule when Regexp#>> is given a ProviderDefinition" do
+    (/1/ >> Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:foo)).
+      should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  test "should return a RouteRule when Regexp#>>() receives a ProviderDefinition" do
+    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:london)
+    (/foo/ >> definition).should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  test "should raise an exception when Regexp#| receives something other than a RouteRule" do
+    bad_args = [ 0..100, 20, 45.55, {}, [] ]
+    bad_args.each do |arg|
+      the_following_code { /foo/ | arg }.should.raise ArgumentError
+    end
+  end
+  test "should raise an exception when Regexp#>>() receives anything other than a ProviderDefintion or RouteRule" do
+    bad_args = [ 0..100, 20, 45.55, {}, [] ]
+    bad_args.each do |arg|
+      the_following_code { /foo/ >> arg }.should.raise ArgumentError
+    end
+  end
+end
+
+describe "A RouteRule" do
+  test "should expose chained ProviderDefinitions properly" do
+    one, two, three = definitions = %w"foo bar qaz".map do |name|
+      Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new name
+    end
+    route = /^911$/ >> one >> two >> three
+    route.should.be.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+    route.providers.should == definitions
+  end
+  test "should define attr_readers for providers and patterns" do
+    route = Adhearsion::VoIP::DSL::DialingDSL::RouteRule.new
+    route.should.respond_to(:patterns)
+    route.should.respond_to(:providers)
+  end
+end
+
+describe "The provider order modifiers" do
+  disabled_test "should support randomizing trunks" do
+    dsl = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    dsl.class_eval do
+      provider(:l33thost) {}
+      provider(:h4xxhost) {}
+      route /\d+\*548/ >> random(l33thost, h4xxhost)
+    end
+    dsl.routes.first.provider_definitions.first.should.be.a.kind_of(
+      Adhearsion::VoIP::DSL::DialingDSL::RandomRouteRule
+    )
+  end
+end
+
+describe "The provider DSL's 'route' builder" do
+  test "should register routes in the order received" do
+    dsl = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    dsl.class_eval do
+      provider(:kewlphone) {}
+      [/1?4445556666/, /123/, /\d+\*548/].each do |r|
+        route r >> kewlphone
+      end
+    end
+    dsl.routes.map { |x| x.patterns }.flatten.should == [/1?4445556666/, /123/, /\d+\*548/]
+  end
+end
+
+describe "A ProviderDefinition" do
+  test "should store any arbitrary property" do
+    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new :foo
+    definition.qaz = :something
+    definition.qaz.should == :something
+  end
+  test "should define a >>() method" do
+    Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:arghh).should.respond_to(:>>)
+  end
+  
+  test "should format numbers properly" do
+    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:arghh)
+    definition.protocol = "SIP"
+    definition.format_number_for_platform("14445556666", :asterisk).should == "SIP/arghh/14445556666"
+    definition.protocol = "SCCP"
+    definition.format_number_for_platform("16663331111", :asterisk).should == "SCCP/arghh/16663331111"
+
+  end
+end
+
+describe "Routing with the interpreted route definitions" do
+  test "should use the first matching regular expression" do
+    dsl = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    dsl.class_eval do
+      provider(:bad)  {}
+      provider(:good) {}
+      route /^111$/ | /^222$/ | /^333$/ >> good >> bad
+    end
+    
+    found = dsl.calculate_routes_for(333)
+    
+    assert_equal 1, found.size
+    found.first.size.should.equal 2
+  end
+  
+end
+
+# @example = Class.new Adhearsion::VoIP::DSL::DialingDSL
+# @example.class_eval do
+#   
+#   provider:kewlphone do |trunk|
+#     trunk.protocol :sip
+#     trunk.host     "voip.nufone.com"
+#     trunk.username "phonedude"
+#     trunk.password "secret"
+#     trunk.enters   :internal
+#   end
+#   
+#   route US_NUMBER | US_LOCAL_NUMBER >> voip_ms >> nufone
+#   
+#   route INTL_NUMBER >> random(voip_ms, nufone)
+#   
+#   # route _('NXX') >> DUNDI
+#   
+# end

data/spec/voip/dsl/test_dispatcher.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/dispatcher_spec_helper'
+require 'adhearsion/voip/dsl/dialplan/dispatcher'
+
+
+describe "A EventCommand" do
+  
+  test "should allow a block that's set to response_block()" do
+    block = lambda {}
+    cmd = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "foo", &block
+    cmd.response_block.should.equal(block)
+  end
+  
+  test "should return specified return type with returns()" do
+    return_type = Numeric
+    cmd = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "foo", :returns => return_type
+    cmd.returns.should.equal(return_type)
+  end
+  
+end
+
+describe "The abstract CommandDispatcher" do
+  
+  test "should make an attribute reader for context()" do
+    context = "foo"
+    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new String, context
+    d.context.should.equal(context)
+  end
+
+  test "should instantiate a new instance of the specified factory" do
+    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new Hash
+    d.factory.should.be.kind_of(Hash)
+  end
+  
+  test "should pass the context to the factory when instantiating it" do
+    context = "shazbot"
+    klass = flexmock "a class that has one argument in its constructor"
+    klass.should_receive(:new).with(context)
+    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new klass, context
+  end
+  
+  test "should not allow calling dispatch!() directly" do
+    dispatcher = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new MyFactory
+    lambda do
+      dispatcher.dispatch! nil
+    end.should.raise(NotImplementedError)
+  end
+  
+  test "should pass a method and any args onto its CommandFactory" do
+    
+    weird_args = [1, 2, ["foo", nil], Object.new, 12.3..13.4]
+    
+    bogus_command = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "123"
+    
+    dispatcher = NilDispatcher.new MyFactory
+    flexmock(dispatcher.factory).should_receive(:monkey).with(*weird_args).and_return bogus_command
+    dispatcher.monkey(*weird_args)
+    
+  end
+  
+  test "should continue executing response_blocks until nil is returned" do
+    actual_executions, target_executions = 0, 5
+    response = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "1" do |response|
+      if response > target_executions
+        nil
+      else
+        actual_executions += 1
+        Adhearsion::VoIP::DSL::Dialplan::EventCommand.new(response + 1)
+      end
+    end
+    mock_factory_class = Class.new do
+      def initialize(*args)
+      end
+      def testplz
+        response
+      end
+    end
+    dispatcher = EvalDispatcher.new(mock_factory_class)
+    flexmock(dispatcher.factory).should_receive(:testplz).and_return(response)
+    dispatcher.testplz
+    actual_executions.should.equal(target_executions)
+  end
+end

data/spec/voip/dsl/test_parser.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+require 'adhearsion/voip/dsl/dialplan/parser'
+
+describe "The Adhearsion VoIP dialplan parser" do
+  
+  test "should return a list of dialplans properly from dialplan code" do
+    file = "foobar.rb"
+    flexmock(Adhearsion::Paths).should_receive(:manager_for?).and_return true
+    flexmock(Adhearsion::VoIP::DSL::Dialplan::DialplanParser).
+      should_receive(:all_dialplans).and_return [file]
+      
+    flexmock(File).should_receive(:exists?).with(file).and_return true
+    flexmock(File).should_receive(:read).once.with(file).and_return <<-DIALPLAN
+      internal {
+        play "hello-world"
+      }
+      monkeys {
+        play "tt-monkeys"
+      }
+    DIALPLAN
+    contexts = Adhearsion::VoIP::DSL::Dialplan::DialplanParser.get_contexts
+    contexts.keys.size.should.equal(2)
+    contexts.keys.should.include(:internal)
+    contexts.keys.should.include(:monkeys)
+    contexts.each_pair do |context, struct|
+      struct.should.be.kind_of(OpenStruct)
+      %w"file name block".each do |method|
+        struct.should.respond_to(method)
+      end
+    end
+  end
+  
+  test "should raise an error when no dialplan paths were in the .ahnrc file" do
+    lambda do
+      # Not loading it here is the same as it not existing in the "paths" sub-Hash
+      Adhearsion::Paths.manager_for?("dialplans").once.and_return false
+      Adhearsion::VoIP::DSL::Dialplan::DialplanParser.get_contexts
+    end.should.raise NoMethodError
+  end
+  
+  test "should warn() when no dialplan files exist but return an empty Hash" #do
+  #   Adhearsion::Paths.should_receive(:manager_for?).with("dialplans").and_return true
+  #   Adhearsion::Paths.
+  #   Adhearsion::Logging::LoggingMethods.should_receive(:warn)
+  #   
+  # end
+  
+  test "should warn() when no contexts were found but return an empty Hash" do
+    
+  end
+  
+end
+
+describe "The Adhearsion VoIP dialplan interpreter" do
+  
+  test "should make dialplan contexts available within the context's block" do    
+    file = "contexts_from_code_helper_pseudo_dialplan.rb"
+    flexmock(Adhearsion::Paths).should_receive(:manager_for?).once.with("dialplans").and_return true
+    flexmock(Adhearsion::VoIP::DSL::Dialplan::DialplanParser).
+      should_receive(:all_dialplans).and_return [file]
+        
+    flexmock(File).should_receive(:exists?).with(file).and_return true
+    flexmock(File).should_receive(:read).with(file).and_return "foo { cool_method }"
+    
+    contexts = Adhearsion::VoIP::DSL::Dialplan::DialplanParser.get_contexts
+    
+    contexts.each_pair do |name, struct|
+      contexts.meta_def(name) { struct.code }
+    end
+    
+    # Simulate incoming request
+    contexts = contexts.clone
+    
+    call_variables = { "callerid" => "14445556666", "context"  => "foo" }
+    
+    call_variables.each_pair do |key, value|
+      contexts.meta_def(key) { value }
+      contexts.instance_variable_set "@#{key}", value
+    end
+    
+    # TODO
+    # dispatcher = DSL::Dialplan::CommandDispatcher.new 
+    
+  end
+  
+end

data/spec/voip/freeswitch/test_basic_connection_manager.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require 'adhearsion/voip/freeswitch/basic_connection_manager'
+
+include Adhearsion::VoIP::FreeSwitch
+
+context "FreeSwitch BasicConnectionManager" do
+  attr_reader :manager, :io
+  setup do
+    @io      = StringIO.new
+    @manager = BasicConnectionManager.new io
+  end
+  
+  test "<<() should add two newlines" do
+    manager << "foobar"
+    io.string.should == "foobar\n\n"
+  end
+  
+end
+
+context "FreeSwitch BasicConnectionManager's header parser" do
+  test "YAML-like headers are read properly" do
+    header = {
+      "Foo-Bar"                  => "bar",
+      "Qaz-Monkey-Charlie-Zebra" => "qwerty"
+    }
+    
+    string_header = header.inject("") do |string, (key, value)|
+      string + "#{key}: #{value}\n"
+    end
+    
+    string_header << "\n"
+    
+    manager = BasicConnectionManager.new StringIO.new(string_header)
+    manager.get_raw_header.should == string_header.strip
+    
+    manager = BasicConnectionManager.new StringIO.new(string_header)
+    manager.get_header.should == header
+  end
+end

data/spec/voip/freeswitch/test_inbound_connection_manager.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require 'adhearsion/voip/freeswitch/inbound_connection_manager'
+include Adhearsion::VoIP::FreeSwitch
+
+context "A FreeSwitch InboundConnectionManager" do
+  
+  test "authenticatating with the given password" do 
+    manager = InboundConnectionManager.new io_mock
+    manager.login password
+  end
+  
+  test "a hash is accepted when creating a new InboundConnectionManager" do
+    host, port = "myhost.mydomain", 31337
+    
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return io_mock
+    
+    InboundConnectionManager.new :host => host, :port => port, :pass => password
+  end
+  
+  test "an IO is accepted when creating a new InboundConnectionManager"
+  
+  private
+    def io_mock
+      @io_mock ||=
+        begin
+          io_mock = StringIO.new
+          flexmock(io_mock) do |io|
+            io.should_receive(:write).with("auth #{password}\n\n")
+            io.should_receive(:gets).and_return "connection: kthnx\n",
+              "\n", "login: +OK\n", "\n"
+          end
+          io_mock
+        end
+    end
+    
+    def password
+      "supersecret"
+    end
+end