eric-adhearsion 0.7.999

data/spec/voip/asterisk/test_agi_server.rb

@@ -0,0 +1,451 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require 'adhearsion/voip/asterisk'
+
+context "The AGI server's serve() method" do
+  
+  include AgiServerTestHelper
+  
+  attr_reader :server_class, :server
+  before :each do
+    @server_class = Adhearsion::VoIP::Asterisk::AGI::Server::RubyServer
+    @server       = @server_class.new(:port,:host)
+  end
+  
+  test 'should instantiate a new Call with the IO object it receives' do
+    stub_before_call_hooks!
+    io_mock   = flexmock "Mock IO object that's passed to the serve() method"
+    call_mock = flexmock "A Call mock that's returned by Adhearsion#receive_call_from", :variable => {}
+    flexstub(server_class).should_receive(:ahn_log)
+    the_following_code {
+      flexmock(Adhearsion).should_receive(:receive_call_from).once.with(io_mock).and_throw :created_call!
+      server.serve(io_mock)
+    }.should.throw :created_call!
+  end
+  
+  test 'should hand the call off to a new Manager if the request is agi://IP_ADDRESS_HERE' do
+    stub_before_call_hooks!
+    call_mock = flexmock 'A new mock call that will be passed to the manager', :variables => {}
+    
+    flexmock(Adhearsion).should_receive(:receive_call_from).once.and_return call_mock
+    manager_mock = flexmock 'a mock dialplan manager'
+    manager_mock.should_receive(:handle).once.with(call_mock)
+    flexmock(Adhearsion::DialPlan::Manager).should_receive(:new).once.and_return manager_mock
+    server.serve(nil)
+  end
+  
+  test 'should hand off a call to a ConfirmationManager if the request begins with confirm!' do
+    confirm_options = Adhearsion::DialPlan::ConfirmationManager.encode_hash_for_dial_macro_argument :timeout => 20, :key => "#"
+    call_mock = flexmock "a call that has network_script as a variable", :variables => {:network_script => "confirm!#{confirm_options[/^M\(\^?(.+)\)$/,1]}"}
+    manager_mock = flexmock 'a mock ConfirmationManager'
+    
+    the_following_code {
+      flexstub(Adhearsion).should_receive(:receive_call_from).once.and_return(call_mock)
+      flexmock(Adhearsion::DialPlan::ConfirmationManager).should_receive(:confirmation_call?).once.with(call_mock).and_return true
+      flexmock(Adhearsion::DialPlan::ConfirmationManager).should_receive(:handle).once.with(call_mock).and_throw :handled_call!
+      server.serve(nil)
+    }.should.throw :handled_call!
+  end
+  
+  test 'calling the serve() method invokes any BeforeCall hooks' do
+    flexmock(Adhearsion::Hooks::BeforeCall).should_receive(:trigger_hooks).once.and_throw :before_call_hooks_executed
+    assert_throws :before_call_hooks_executed do
+      server.serve nil
+    end
+  end
+  
+  test 'should execute the OnHungupCall hooks when a HungupExtensionCallException is raised' do
+    call_mock = flexmock 'a bogus call', :hungup_call? => true, :variables => {:extension => "h"}
+    mock_env  = flexmock "A mock execution environment which gets passed along in the HungupExtensionCallException"
+    
+    stub_confirmation_manager!
+    flexstub(Adhearsion).should_receive(:receive_call_from).once.and_return(call_mock)
+    flexmock(Adhearsion::DialPlan::Manager).should_receive(:handle).once.and_raise Adhearsion::HungupExtensionCallException.new(mock_env)
+    flexmock(Adhearsion::Hooks::OnHungupCall).should_receive(:trigger_hooks).once.with(mock_env).and_throw :hungup_call
+    
+    the_following_code { server.serve nil }.should.throw :hungup_call
+  end
+  
+  test 'should execute the OnFailedCall hooks when a FailedExtensionCallException is raised' do
+    call_mock = flexmock 'a bogus call', :failed_call? => true, :variables => {:extension => "failed"}
+    mock_env  = flexmock "A mock execution environment which gets passed along in the HungupExtensionCallException", :failed_reason => "does not matter" 
+    
+    server = Adhearsion::VoIP::Asterisk::AGI::Server::RubyServer.new :port, :host
+    
+    flexmock(Adhearsion).should_receive(:receive_call_from).once.and_return(call_mock)
+    flexmock(Adhearsion::DialPlan::Manager).should_receive(:handle).once.and_raise Adhearsion::FailedExtensionCallException.new(mock_env)
+    flexmock(Adhearsion::Hooks::OnFailedCall).should_receive(:trigger_hooks).once.with(mock_env).and_throw :failed_call
+    the_following_code { server.serve nil }.should.throw :failed_call
+  end
+  
+end
+
+context "Active Calls" do
+  include CallVariableTestHelper
+  attr_accessor :typical_call
+  
+  before do
+    @mock_io      = StringIO.new
+    @typical_call = Adhearsion::Call.new(@mock_io, typical_call_variables_hash)
+  end
+  
+  after do
+    Adhearsion::active_calls.clear!
+  end
+  
+  test 'A Call object can be instantiated with a hash of attributes' do
+    the_following_code {
+      Adhearsion::Call.new(@mock_io, {})
+    }.should.not.raise
+  end
+  
+  test 'Attributes passed into initialization of call object are accessible as attributes on the object' do
+    Adhearsion::Call.new(@mock_io, {:channel => typical_call_variables_hash[:channel]}).channel.should == typical_call_variables_hash[:channel]
+  end
+  
+  test 'Attributes passed into initialization of call object are accessible in the variables() Hash' do
+    Adhearsion::Call.new(@mock_io, typical_call_variables_hash).variables.should.equal typical_call_variables_hash
+  end
+  
+  test 'Can add a call to the active calls list' do
+    Adhearsion.active_calls.should.not.be.any
+    Adhearsion.active_calls << typical_call 
+    Adhearsion.active_calls.size.should == 1
+  end
+  
+  test 'A hungup call removes itself from the active calls' do
+    mock_io = flexmock typical_call_variable_io
+    mock_io.should_receive(:close).once
+    
+    size_before = Adhearsion.active_calls.size
+    
+    call = Adhearsion.receive_call_from mock_io
+    Adhearsion.active_calls.size.should.be > size_before
+    call.hangup!
+    Adhearsion.active_calls.size.should == size_before
+  end
+  
+  test 'Can find active call by unique ID' do
+    Adhearsion.active_calls << typical_call
+    assert_not_nil Adhearsion.active_calls.find(typical_call_variables_hash[:channel])
+  end
+  
+  test 'A call can store the IO associated with the PBX/switch connection' do
+    Adhearsion::Call.new(@mock_io, {}).should.respond_to(:io)
+  end
+  
+  test 'A call can be instantiated given a PBX/switch IO' do
+    call = Adhearsion::Call.receive_from(typical_call_variable_io)
+    call.should.be.kind_of(Adhearsion::Call)
+    call.channel.should == typical_call_variables_hash[:channel]
+  end
+  
+  test 'A call with an extension of "t" raises a UselessCallException' do
+    the_following_code {
+      Adhearsion::Call.new(@mock_io, typical_call_variables_hash.merge(:extension => 't'))
+    }.should.raise(Adhearsion::UselessCallException)
+  end
+  
+  test 'Can create a call and add it via a top-level method on the Adhearsion module' do
+    assert !Adhearsion.active_calls.any?
+    call = Adhearsion.receive_call_from(typical_call_variable_io)
+    call.should.be.kind_of(Adhearsion::Call)
+    Adhearsion.active_calls.size.should == 1
+  end
+  
+  test 'A call can identify its originating voip platform' do
+    call = Adhearsion::receive_call_from(typical_call_variable_io)
+    call.originating_voip_platform.should.equal(:asterisk)
+  end
+  
+end
+
+context 'A new Call object' do
+  
+  include CallVariableTestHelper
+  
+  test "it should have an @inbox object that's a synchronized Queue" do
+    new_call = Adhearsion::Call.new(nil, {})
+    new_call.inbox.should.be.kind_of Queue
+    new_call.should.respond_to :<<
+  end
+  
+  test 'the unique_identifier() method should return the :channel variable for :asterisk calls' do
+    variables = typical_call_variables_hash
+    new_call = Adhearsion::Call.new(nil, typical_call_variables_hash)
+    flexmock(new_call).should_receive(:originating_voip_platform).and_return :asterisk
+    new_call.unique_identifier.should == variables[:channel]
+  end
+  
+  test "Call#define_singleton_accessor_with_pair should define a singleton method, not a class method" do
+    control    = Adhearsion::Call.new(nil, {})
+    experiment = Adhearsion::Call.new(nil, {})
+    
+    experiment.send(:define_singleton_accessor_with_pair, "ohai", 123)
+    experiment.should.respond_to "ohai"
+    control.should.not.respond_to "ohai"
+  end
+  
+end
+
+context 'the Calls collection' do
+  
+  include CallVariableTestHelper
+  
+  test 'the #<< method should add a Call to the Hash with its unique_id' do
+    id = rand
+    collection = Adhearsion::Calls.new
+    call = Adhearsion::Call.new(nil, {})
+    flexmock(call).should_receive(:unique_identifier).and_return id
+    collection << call
+    hash = collection.instance_variable_get("@calls")
+    hash.should.not.be.empty
+    hash[id].should.equal call
+  end
+  
+  test '#size should return the size of the Hash' do
+    collection = Adhearsion::Calls.new
+    collection.size.should.equal 0
+    collection << Adhearsion::Call.new(nil, {})
+    collection.size.should.equal 1
+  end
+  
+  test '#remove_inactive_call should delete the call in the Hash' do
+    collection = Adhearsion::Calls.new
+    
+    number_of_calls = 10
+    unique_ids = Array.new(number_of_calls) { rand }
+    calls = unique_ids.map { |id| Adhearsion::Call.new(nil, {:uniqueid => id}) }
+    calls.each { |call| collection << call }
+    
+    deleted_call = calls[number_of_calls / 2]
+    collection.remove_inactive_call deleted_call
+    collection.size.should.equal number_of_calls - 1
+  end
+  
+  test '#find_by_unique_id should pull the Call from the Hash using the unique_id' do
+    id = rand
+    call_database = flexmock "a mock Hash in which calls are stored"
+    call_database.should_receive(:[]).once.with(id)
+    collection = Adhearsion::Calls.new
+    flexmock(collection).should_receive(:calls).once.and_return(call_database)
+    collection.find(id)
+  end
+  
+end
+
+context 'Typical call variable parsing with typical data that has no special treatment' do
+  include CallVariableTestHelper
+  attr_reader :variables, :io              
+              
+  setup do
+    @io        = typical_call_variable_io
+    @variables = parsed_call_variables_from(io)
+  end
+  
+  # test "listing all variable names" do
+  #   parser.variable_names.map(&:to_s).sort.should == typical_call_variables_hash.keys.map(&:to_s).sort
+  # end
+  
+  test "extracts call variables into a Hash" do
+    assert variables.kind_of?(Hash)
+  end
+  
+  test "extracting and converting variables and their values to a hash" do
+    variables.should == typical_call_variables_hash
+  end
+end
+
+context 'Call variable parsing with data that is treated specially' do
+  include CallVariableTestHelper
+  test "callington is renamed to type_of_calling_number" do
+    variables = parsed_call_variables_from typical_call_variable_io
+    variables[:type_of_calling_number].should == :unknown
+    variables.has_key?(:callington).should    == false
+  end
+  test "normalizes the context to be a valid Ruby method name"
+  test "value of 'no' converts to false" do
+    merged_hash_with_call_variables(:foo => "no")[:foo].should.equal(false)
+  end
+  test "value of 'yes' converts to true"
+  test "value of 'unknown' converts to nil"
+  test 'separate_line_into_key_value_pair parses values with spaces in them' do
+    key, value = Adhearsion::Call::Variables::Parser.separate_line_into_key_value_pair("foo: My Name")
+    value.should == 'My Name'
+  end
+end
+
+context 'Typical call variable line parsing with a typical line that is not treated specially' do
+  include CallVariableTestHelper
+  attr_reader :parser, :line
+  
+  setup do
+    @line   = 'agi_channel: SIP/marcel-b58046e0'
+    @key, @value = Adhearsion::Call::Variables::Parser.separate_line_into_key_value_pair line
+  end
+  
+  test "raw name is extracted correctly" do
+    @key.should == 'agi_channel'
+  end
+  
+  test "raw value is extracted correctly" do
+    @value.should == 'SIP/marcel-b58046e0'
+  end
+end
+
+context 'Call variable line parsing with a line that is treated specially' do
+  include CallVariableTestHelper
+  attr_reader :key, :value, :line
+  
+  setup do
+    @line   = 'agi_request: agi://10.0.0.152'
+    @key, @value = Adhearsion::Call::Variables::Parser.separate_line_into_key_value_pair line
+  end
+  
+  test "splits out name and value correctly even if the value contains a semicolon (i.e. the same character that is used as the name/value separators)" do
+    @key.should   == 'agi_request'
+    @value.should == 'agi://10.0.0.152'
+  end
+  
+end
+
+context "Extracting the query from the request URI" do
+  include CallVariableTestHelper
+  attr_reader :parser
+  
+  setup do
+    # We don't want this Call::Variables::Parser to call parse because we only care about handling the request
+    # variable which we mock here.
+    @parser = Adhearsion::Call::Variables::Parser.new(StringIO.new('This argument does not matter'))
+  end
+  
+  test "an empty hash is returned if there is no query string" do
+    parsed_call_variables_with_query('').should == {}
+  end
+  
+  test "a key and value for parameter is returned when there is one query string parameter" do
+    parsed_call_variables_with_query('?foo=bar').should == {'foo' => 'bar'}
+  end
+  
+  test "both key/value pairs are returned when there are a pair of query string parameters" do
+    parsed_call_variables_with_query('?foo=bar&baz=quux').should == {'foo' => 'bar', 'baz' => 'quux'}
+  end
+  
+  test "all key/value pairs are returned when there are more than a pair of query string parameters" do
+    parsed_call_variables_with_query('?foo=bar&baz=quux&name=marcel').should == {'foo' => 'bar', 'baz' => 'quux', 'name' => 'marcel'}
+  end
+  
+end
+
+BEGIN {
+  module CallVariableTestHelper
+    def parsed_call_variables_from(io)
+      Adhearsion::Call::Variables::Parser.parse(io).variables
+    end
+  
+    def coerce_call_variables(variables)
+      Adhearsion::Call::Variables::Parser.coerce_variables(variables)
+    end
+    
+    def merged_hash_with_call_variables(new_hash)
+      call_variables_with_new_query = typical_call_variables_hash.merge new_hash
+      coerce_call_variables call_variables_with_new_query
+    end
+    
+    def parsed_call_variables_with_query(query_string)  
+      request_string = "agi://10.0.0.0/#{query_string}"
+      merged_hash_with_call_variables({:request => request_string})[:query]
+    end
+    
+    def typical_call_variable_io
+      StringIO.new(typical_call_variable_section)
+    end
+
+    def typical_call_variable_section
+      <<-VARIABLES
+agi_network: yes
+agi_request: agi://10.0.0.152/monkey?foo=bar&qaz=qwerty
+agi_channel: SIP/marcel-b58046e0
+agi_language: en
+agi_type: SIP
+agi_uniqueid: 1191245124.16
+agi_callerid: 011441234567899
+agi_calleridname: unknown
+agi_callingpres: 0
+agi_callingani2: 0
+agi_callington: 0
+agi_callingtns: 0
+agi_dnid: 911
+agi_rdnis: unknown
+agi_context: adhearsion
+agi_extension: 911
+agi_priority: 1
+agi_enhanced: 0.0
+agi_accountcode: 
+
+      VARIABLES
+    end
+
+    # TODO:
+    #  - "unknown" should be converted to nil
+    #  - "yes" or "no" should be converted to true or false
+    #  - numbers beginning with a 0 MUST be converted to a NumericalString
+    #  - Look up why there are so many zeroes. They're likely reprentative of some PRI definition.
+
+    def typical_call_variables_hash
+      uncoerced_variable_map                = expected_uncoerced_variable_map
+
+      uncoerced_variable_map[:request]      = URI.parse(uncoerced_variable_map[:request])
+      uncoerced_variable_map[:extension]    = 911 # Adhearsion::VoIP::DSL::PhoneNumber.new(uncoerced_variable_map[:extension]) # 
+      uncoerced_variable_map[:callerid]     = Adhearsion::VoIP::DSL::NumericalString.new(uncoerced_variable_map[:callerid])
+      
+      uncoerced_variable_map[:network]      = true
+      uncoerced_variable_map[:calleridname] = nil
+      uncoerced_variable_map[:callingpres]  = 0
+      uncoerced_variable_map[:callingani2]  = 0
+      uncoerced_variable_map[:callingtns]   = 0
+      uncoerced_variable_map[:dnid]         = 911
+      uncoerced_variable_map[:rdnis]        = nil
+      uncoerced_variable_map[:priority]     = 1
+      uncoerced_variable_map[:enhanced]     = 0.0
+      uncoerced_variable_map[:uniqueid]     = 1191245124.16
+      
+      uncoerced_variable_map[:type_of_calling_number] = Adhearsion::VoIP::Constants::Q931_TYPE_OF_NUMBER[uncoerced_variable_map.delete(:callington).to_i]
+
+      coerced_variable_map = uncoerced_variable_map
+      coerced_variable_map[:query] = {"foo" => "bar", "qaz" => "qwerty"}
+      coerced_variable_map
+    end
+
+    def expected_uncoerced_variable_map
+      {:network      => 'yes',
+       :request      => 'agi://10.0.0.152/monkey?foo=bar&qaz=qwerty',
+       :channel      => 'SIP/marcel-b58046e0',
+       :language     => 'en',
+       :type         => 'SIP',
+       :uniqueid     => '1191245124.16',
+       :callerid     => '011441234567899',
+       :calleridname => 'unknown',
+       :callingpres  => '0',
+       :callingani2  => '0',
+       :callington   => '0',
+       :callingtns   => '0',
+       :dnid         => '911',
+       :rdnis        => 'unknown',
+       :context      => 'adhearsion',
+       :extension    => '911',
+       :priority     => '1',
+       :enhanced     => '0.0',
+       :accountcode  => ''}
+    end
+  end
+  
+  module AgiServerTestHelper
+    def stub_before_call_hooks!
+      flexstub(Adhearsion::Hooks::BeforeCall).should_receive :trigger_hooks
+    end
+    
+    def stub_confirmation_manager!
+      flexstub(Adhearsion::DialPlan::ConfirmationManager).should_receive(:confirmation_call?).and_return false
+    end
+  end
+}

data/spec/voip/asterisk/test_ami.rb

@@ -0,0 +1,227 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/mock_ami_server"
+
+require 'adhearsion'
+require 'adhearsion/voip/asterisk/ami'
+
+context "Connecting via AMI" do
+  test "should raise an exception if the password was invalid" do
+    host, port = "localhost", 5038
+    ami = Adhearsion::VoIP::Asterisk::AMI.new "admin", "bad_password", "localhost", :port => port
+  
+    ami_server = AmiServer.new
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return(ami_server)
+    flexmock(IO).should_receive(:select).at_least.once.with([ami_server], nil, nil, 1.0).and_return(true)
+
+    the_following_code do
+      ami.connect!
+    end.should.raise Adhearsion::VoIP::Asterisk::AMI::AuthenticationFailedException
+    ami.disconnect!
+  end
+  
+  test "should discover its own permissions and make them available as connection attributes"
+  
+  # TODO: DRY up the following two specs
+  test "should start a new thread if events are enabled" do
+    host, port = "localhost", 5038
+    ami = Adhearsion::VoIP::Asterisk::AMI.new "admin", "password", "localhost", :port => port, :events => true
+  
+    ami_server = AmiServer.new
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return(ami_server)
+    flexmock(IO).should_receive(:select).at_least.once.with([ami_server], nil, nil, 1.0).and_return(true)
+
+    ami.connect!
+    ami.instance_eval { meta_eval { attr_accessor :event_thread } }
+    ami.event_thread.should.be.a.kind_of Thread
+    ami.disconnect!
+  end
+  
+  test "should find the Asterisk version when connecting" do
+    host, port = "localhost", 5038
+    ami = Adhearsion::VoIP::Asterisk::AMI.new "admin", "password", "localhost", :port => port
+  
+    ami_server = AmiServer.new
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return(ami_server)
+    flexmock(IO).should_receive(:select).at_least.once.with([ami_server], nil, nil, 1.0).and_return(true)
+
+    ami.connect!
+    ami.version.should == "1.0"
+    ami.disconnect!
+  end
+end
+
+context "The AMI command interface" do
+  before do
+    host, port = "localhost", 5038
+    @ami = Adhearsion::VoIP::Asterisk::AMI.new "admin", "password", host, :port => port, :events => false
+
+    ami_server = AmiServer.new
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return(ami_server)
+    flexmock(IO).should_receive(:select).at_least.once.with([ami_server], nil, nil, 1.0).and_return(true)
+
+    @ami.connect!
+  end
+  
+  after do
+    @ami.disconnect!
+  end
+  
+  test "should respond to an immediate command" do
+    resp = @ami.queues
+    resp[0][:raw].should.be.a.kind_of String
+  end
+
+  test "should respond to a follows command" do
+    resp = @ami.command :Command => "show channels"
+    resp[0][:raw].should.be.a.kind_of String
+  end
+
+  test "should respond to a DBGet for a non-existent key with an exception" do
+    the_following_code do
+      resp = @ami.dbget :Family => "none", :Key => "somekey"
+    end.should.raise Adhearsion::VoIP::Asterisk::AMI::ActionError
+  end
+  
+  test "should respond to a DBGet for a key with an event" do
+    resp = @ami.dbput :Family => "none", :Key => "somekey", :Val => 5
+    resp = @ami.dbget :Family => "none", :Key => "somekey"
+    resp[0]['Val'].should == "5"
+  end
+  
+  test "should respond to a command that generates follows event(s)" do
+    resp = @ami.queuestatus
+    resp[0]['Queue'].should == "default"
+  end
+  
+  test "should show usage for an improper follows command" do
+    resp = @ami.command :Command => "meetme list"
+    resp[0][:raw].should.be.a.kind_of String
+  end
+  
+  test "should respond to a synchronous originate"
+  test "should respond to an asynchronous originate"
+
+  test "should define events() as a private method to prevent turning events on or off" do
+    @ami.private_methods.include?("events").should.equal true
+  end
+  
+  test "should raise an exception when Asterisk doesn't recognize a command" do
+    the_following_code {
+      @ami.this_command_does_not_exist_kthx
+    }.should.raise Adhearsion::VoIP::Asterisk::AMI::ActionError
+    
+  end
+  
+end
+
+context 'AMI#originate' do
+  include AmiCommandTestHelper
+  test "should pass the arguments to execute_ami_command! with the options given" do
+    ami     = new_ami_instance
+    options = { :channel => "ohai_lolz", :application => "Echo" }
+    flexmock(ami).should_receive(:execute_ami_command!).with(:originate, options).once
+    ami.originate options
+  end
+  
+  test "should rename the :caller_id Hash key to :callerid" do
+    ami, caller_id = new_ami_instance, "Jay"
+    options = { :channel => "ohai_lolz", :application => "Echo"}
+    flexmock(ami).should_receive(:execute_ami_command!).with(:originate, options.merge(:callerid => caller_id)).once
+    ami.originate options.merge(:caller_id => caller_id)
+  end
+  
+end
+
+context 'AMI#call_and_exec' do
+  include AmiCommandTestHelper
+  test "should execute originate properly with the minimum arguments" do
+    number, app = "12224446666", "Echo"
+    
+    ami = flexmock new_ami_instance
+    ami.should_receive(:originate).once.with(:channel => number, :application => app).and_return true
+    ami.call_and_exec number, app
+  end
+  
+end
+
+context 'AMI#introduce' do
+  
+  include AmiCommandTestHelper
+  
+  test "should execute origiante properly (when :caller_id and :options aren't specified)" do
+    caller, callee, caller_id = "SIP/12224446666@trunk", "SIP/12224447777@trunk", "Jay Phillips"
+    
+    correct_args = {:application => "Dial", :channel => caller, :data => callee, :caller_id => "Jay"}
+    ami = flexmock new_ami_instance
+    ami.should_receive(:originate).once.with(correct_args).and_return(true)
+    ami.introduce caller, callee, :caller_id => "Jay"
+  end
+  
+end
+
+context "The manager proxy" do
+  before do
+    host, port = "localhost", 5038
+    @ami = Adhearsion::VoIP::Asterisk::AMI.new "admin", "password", "localhost", :port => port, :events => false
+
+    ami_server = AmiServer.new
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return(ami_server)
+    flexmock(IO).should_receive(:select).at_least.once.with([ami_server], nil, nil, 1.0).and_return(true)
+
+    @ami.connect!
+    @door = DRb.start_service "druby://127.0.0.1:9050", Adhearsion::DrbDoor.instance
+  end
+  
+  test "should accept a command" do
+    client = DRbObject.new nil, DRb.uri
+    client.proxy.ping
+  end
+
+  after do
+    DRb.stop_service
+    @ami.disconnect!
+  end
+end
+
+context "The command-sending interface" do
+  test "should raise an exception if permission was denied"
+  test "should allow variables to be specified as a Hash"
+end
+
+context "Sent arbitrary AMI commands" do
+  
+  test "should allow a convenient way of parsing by event name"
+  test "should return Hash arguments"
+  
+  test "should recognize its subclasses"
+  test "should send events to all of its subclasses"
+  test "should catch action names with method_missing() and format them properly"
+
+  test "should raise an exception if permission was denied"
+end
+
+context "AMI Packets" do
+  test "A Packet should not be an error" do
+    Adhearsion::VoIP::Asterisk::AMI::Packet.new.error?.should.be false
+  end
+  test "An ErrorPacket should be an error" do
+    Adhearsion::VoIP::Asterisk::AMI::ErrorPacket.new.error?.should.be true
+  end
+end
+
+context "The event parser" do
+  test "should parse the the YAML-like format "
+  test "should allow a Hash to specify multiple matches"
+end
+
+BEGIN {
+module AmiCommandTestHelper
+  def new_ami_instance
+    # TODO. mock everything out here
+    returning Adhearsion::VoIP::Asterisk::AMI.new("user","pass") do |ami|
+      flexmock(ami).should_receive(:connect!).and_return(true)
+    end
+  end
+  
+end
+}