sevenscale-adhearsion 0.7.1003 → 0.8.0

data/spec/voip/asterisk/test_agi_server.rb

@@ -1,453 +0,0 @@
-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 => {}, :unique_identifier => "X"
-    
-    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]}"}, :unique_identifier => "X"
-    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"}, :unique_identifier => "X"
-    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"}, :unique_identifier => "X"
-    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(:no_var => "no")[:no_var].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[:foo] = 'bar'
-      coerced_variable_map[: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

@@ -1,227 +0,0 @@
-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
-}