punchblock 1.9.4 → 2.0.0.beta1

data/spec/punchblock/translator/asterisk/component/output_spec.rb

@@ -10,7 +10,7 @@ module Punchblock
           include HasMockCallbackConnection
 
           let(:media_engine)  { nil }
-          let(:ami_client)    { mock('AMI') }
+          let(:ami_client)    { double('AMI') }
           let(:translator)    { Punchblock::Translator::Asterisk.new ami_client, connection, media_engine }
           let(:mock_call)     { Punchblock::Translator::Asterisk::Call.new 'foo', translator, ami_client, connection }
 
@@ -25,7 +25,7 @@ module Punchblock
           end
 
           let :command_options do
-            { :ssml => ssml_doc }
+            { :render_document => {:value => ssml_doc} }
           end
 
           subject { Output.new original_command, mock_call }
@@ -62,7 +62,7 @@ module Punchblock
               let(:command_opts) { {} }
 
               let :command_options do
-                { :ssml => ssml_doc }.merge(command_opts)
+                { :render_document => {:value => ssml_doc} }.merge(command_opts)
               end
 
               def ssml_with_options(prefix = '', postfix = '')
@@ -80,7 +80,7 @@ module Punchblock
               it 'should send a complete event when Swift completes' do
                 mock_call.should_receive(:execute_agi_command).and_return code: 200, result: 1
                 subject.execute
-                original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
+                original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Finish
               end
 
               context "when we get a RubyAMI Error" do
@@ -94,6 +94,16 @@ module Punchblock
                 end
               end
 
+              context "when the channel is gone" do
+                it "should send an error complete event" do
+                  error = ChannelGoneError.new 'FooBar'
+                  mock_call.should_receive(:execute_agi_command).and_raise error
+                  subject.execute
+                  complete_reason = original_command.complete_event(0.1).reason
+                  complete_reason.should be_a Punchblock::Event::Complete::Hangup
+                end
+              end
+
               context "when the call is not answered" do
                 before { expect_answered false }
 
@@ -129,8 +139,8 @@ module Punchblock
                   end
                 end
 
-                context "set to :speech" do
-                  let(:command_opts) { { :interrupt_on => :speech } }
+                context "set to :voice" do
+                  let(:command_opts) { { :interrupt_on => :voice } }
                   it "should return an error and not execute any actions" do
                     subject.execute
                     error = ProtocolError.new.setup 'option error', 'An interrupt-on value of speech is unsupported.'
@@ -174,43 +184,30 @@ module Punchblock
               let(:command_opts) { {} }
 
               let :command_options do
-                { :ssml => ssml_doc }.merge(command_opts)
+                { :render_document => {:value => ssml_doc} }.merge(command_opts)
               end
 
+              let(:synthstatus) { 'OK' }
+              before { mock_call.stub(:channel_var).with('SYNTHSTATUS').and_return synthstatus }
+
               def expect_mrcpsynth_with_options(options)
                 mock_call.should_receive(:execute_agi_command).once.with do |*args|
                   args[0].should be == 'EXEC MRCPSynth'
-                  args[2].should match options
+                  args[1].should match options
                 end.and_return code: 200, result: 1
               end
 
               before { expect_answered }
 
               it "should execute MRCPSynth" do
-                mock_call.should_receive(:execute_agi_command).once.with('EXEC MRCPSynth', ssml_doc.to_s.squish.gsub(/["\\]/) { |m| "\\#{m}" }, '').and_return code: 200, result: 1
+                mock_call.should_receive(:execute_agi_command).once.with('EXEC MRCPSynth', ["\"#{ssml_doc.to_s.squish.gsub('"', '\"')}\"", ''].join(',')).and_return code: 200, result: 1
                 subject.execute
               end
 
-              context "when the SSML document contains commas" do
-                let :ssml_doc do
-                  RubySpeech::SSML.draw do
-                    string "this, here, is a test"
-                  end
-                end
-
-                it 'should escape TTS strings containing a comma' do
-                  mock_call.should_receive(:execute_agi_command).once.with do |*args|
-                    args[0].should be == 'EXEC MRCPSynth'
-                    args[1].should match(/this\\, here\\, is a test/)
-                  end.and_return code: 200, result: 1
-                  subject.execute
-                end
-              end
-
               it 'should send a complete event when MRCPSynth completes' do
                 mock_call.should_receive(:execute_agi_command).and_return code: 200, result: 1
                 subject.execute
-                original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
+                original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Finish
               end
 
               context "when we get a RubyAMI Error" do
@@ -224,6 +221,16 @@ module Punchblock
                 end
               end
 
+              context "when the channel is gone" do
+                it "should send an error complete event" do
+                  error = ChannelGoneError.new 'FooBar'
+                  mock_call.should_receive(:execute_agi_command).and_raise error
+                  subject.execute
+                  complete_reason = original_command.complete_event(0.1).reason
+                  complete_reason.should be_a Punchblock::Event::Complete::Hangup
+                end
+              end
+
               context "when the call is not answered" do
                 before { expect_answered false }
 
@@ -234,15 +241,36 @@ module Punchblock
                 end
               end
 
-              describe 'ssml' do
+              context "when the SYNTHSTATUS variable is set to 'ERROR'" do
+                let(:synthstatus) { 'ERROR' }
+
+                it "should send an error complete event" do
+                  mock_call.should_receive(:execute_agi_command).and_return code: 200, result: 1
+                  subject.execute
+                  complete_reason = original_command.complete_event(0.1).reason
+                  complete_reason.should be_a Punchblock::Event::Complete::Error
+                  complete_reason.details.should == "Terminated due to UniMRCP error"
+                end
+              end
+
+              describe 'document' do
                 context 'unset' do
-                  let(:command_opts) { { :ssml => nil } }
+                  let(:ssml_doc) { nil }
                   it "should return an error and not execute any actions" do
                     subject.execute
                     error = ProtocolError.new.setup 'option error', 'An SSML document is required.'
                     original_command.response(0.1).should be == error
                   end
                 end
+
+                context 'with multiple documents' do
+                  let(:command_opts) { { :render_documents => [{:value => ssml_doc}, {:value => ssml_doc}] } }
+                  it "should return an error and not execute any actions" do
+                    subject.execute
+                    error = ProtocolError.new.setup 'option error', 'Only a single document is supported.'
+                    original_command.response(0.1).should be == error
+                  end
+                end
               end
 
               describe 'start-offset' do
@@ -383,8 +411,8 @@ module Punchblock
                   end
                 end
 
-                context "set to :speech" do
-                  let(:command_opts) { { :interrupt_on => :speech } }
+                context "set to :voice" do
+                  let(:command_opts) { { :interrupt_on => :voice } }
                   it "should return an error and not execute any actions" do
                     subject.execute
                     error = ProtocolError.new.setup 'option error', 'An interrupt-on value of speech is unsupported.'
@@ -415,16 +443,19 @@ module Punchblock
                 let(:command_opts) { {} }
 
                 let :command_options do
-                  { :ssml => ssml_doc }.merge(command_opts)
+                  { :render_document => {:value => ssml_doc} }.merge(command_opts)
                 end
 
                 let :original_command do
                   Punchblock::Component::Output.new command_options
                 end
 
+                let(:playbackstatus) { 'SUCCESS' }
+                before { mock_call.stub(:channel_var).with('PLAYBACKSTATUS').and_return playbackstatus }
+
                 describe 'ssml' do
                   context 'unset' do
-                    let(:command_opts) { { :ssml => nil } }
+                    let(:ssml_doc) { nil }
                     it "should return an error and not execute any actions" do
                       subject.execute
                       error = ProtocolError.new.setup 'option error', 'An SSML document is required.'
@@ -433,11 +464,9 @@ module Punchblock
                   end
 
                   context 'with a single audio SSML node' do
-                    let(:audio_filename) { 'http://foo.com/bar.mp3' }
-                    let :command_options do
-                      {
-                        :ssml => RubySpeech::SSML.draw { audio :src => audio_filename }
-                      }
+                    let(:audio_filename) { 'tt-monkeys' }
+                    let :ssml_doc do
+                      RubySpeech::SSML.draw { audio :src => audio_filename }
                     end
 
                     it 'should playback the audio file using Playback' do
@@ -452,7 +481,17 @@ module Punchblock
                       end
                       expect_playback
                       subject.execute
-                      original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
+                      original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Finish
+                    end
+
+                    context "when the audio filename is prefixed by file://" do
+                      let(:audio_filename) { 'file://tt-monkeys' }
+
+                      it 'should playback the audio file using Playback' do
+                        expect_answered
+                        expect_playback 'tt-monkeys'
+                        subject.execute
+                      end
                     end
 
                     context "when we get a RubyAMI Error" do
@@ -466,14 +505,36 @@ module Punchblock
                         complete_reason.details.should == "Terminated due to AMI error 'FooBar'"
                       end
                     end
+
+                    context "when the channel is gone" do
+                      it "should send an error complete event" do
+                        expect_answered
+                        error = ChannelGoneError.new 'FooBar'
+                        mock_call.should_receive(:execute_agi_command).and_raise error
+                        subject.execute
+                        complete_reason = original_command.complete_event(0.1).reason
+                        complete_reason.should be_a Punchblock::Event::Complete::Hangup
+                      end
+                    end
+
+                    context "when the PLAYBACKSTATUS variable is set to 'FAILED'" do
+                      let(:playbackstatus) { 'FAILED' }
+
+                      it "should send an error complete event" do
+                        expect_answered
+                        mock_call.should_receive(:execute_agi_command).and_return code: 200, result: 1
+                        subject.execute
+                        complete_reason = original_command.complete_event(0.1).reason
+                        complete_reason.should be_a Punchblock::Event::Complete::Error
+                        complete_reason.details.should == "Terminated due to playback error"
+                      end
+                    end
                   end
 
                   context 'with a single text node without spaces' do
                     let(:audio_filename) { 'tt-monkeys' }
-                    let :command_options do
-                      {
-                        :ssml => RubySpeech::SSML.draw { string audio_filename }
-                      }
+                    let :ssml_doc do
+                      RubySpeech::SSML.draw { string audio_filename }
                     end
 
                     it 'should playback the audio file using Playback' do
@@ -486,7 +547,7 @@ module Punchblock
                       expect_answered
                       expect_playback
                       subject.execute
-                      original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
+                      original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Finish
                     end
 
                     context "when we get a RubyAMI Error" do
@@ -513,7 +574,9 @@ module Punchblock
                         let(:audio_filename) { 'tt-monkeys' }
                         let :command_options do
                           {
-                            :ssml => RubySpeech::SSML.draw { string audio_filename },
+                            :render_document => {
+                              :value => RubySpeech::SSML.draw { string audio_filename },
+                            },
                             :interrupt_on => :any
                           }
                         end
@@ -527,28 +590,14 @@ module Punchblock
                     end
                   end
 
-                  context 'with a string (not SSML)' do
-                    let :command_options do
-                      { :text => 'Foo Bar' }
-                    end
-
-                    it "should return an unrenderable document error" do
-                      subject.execute
-                      error = ProtocolError.new.setup 'unrenderable document error', 'The provided document could not be rendered. See http://adhearsion.com/docs/common_problems#unrenderable-document-error for details.'
-                      original_command.response(0.1).should be == error
-                    end
-                  end
-
                   context 'with multiple audio SSML nodes' do
                     let(:audio_filename1) { 'http://foo.com/bar.mp3' }
                     let(:audio_filename2) { 'http://foo.com/baz.mp3' }
-                    let :command_options do
-                      {
-                        :ssml => RubySpeech::SSML.draw do
-                          audio :src => audio_filename1
-                          audio :src => audio_filename2
-                        end
-                      }
+                    let :ssml_doc do
+                      RubySpeech::SSML.draw do
+                        audio :src => audio_filename1
+                        audio :src => audio_filename2
+                      end
                     end
 
                     it 'should playback all audio files using Playback' do
@@ -565,7 +614,7 @@ module Punchblock
                       expect_playback [audio_filename1, audio_filename2].join('&')
                       latch = CountDownLatch.new 1
                       original_command.should_receive(:add_event).once.with do |e|
-                        e.reason.should be_a Punchblock::Component::Output::Complete::Success
+                        e.reason.should be_a Punchblock::Component::Output::Complete::Finish
                         latch.countdown!
                       end
                       subject.execute
@@ -574,12 +623,10 @@ module Punchblock
                   end
 
                   context "with an SSML document containing elements other than <audio/>" do
-                    let :command_options do
-                      {
-                        :ssml => RubySpeech::SSML.draw do
-                          string "Foo Bar"
-                        end
-                      }
+                    let :ssml_doc do
+                      RubySpeech::SSML.draw do
+                        string "Foo Bar"
+                      end
                     end
 
                     it "should return an unrenderable document error" do
@@ -750,7 +797,7 @@ module Punchblock
                     before do
                       expect_answered
                       mock_call.should_receive(:execute_agi_command).once.with('EXEC Playback', audio_filename)
-                      subject.wrapped_object.should_receive(:send_success).and_return nil
+                      subject.wrapped_object.should_receive(:send_finish).and_return nil
                     end
 
                     context "when a DTMF digit is received" do
@@ -763,7 +810,7 @@ module Punchblock
                         mock_call.async.process_ami_event ami_event
                         sleep 0.2
                         original_command.should be_complete
-                        reason.should be_a Punchblock::Component::Output::Complete::Success
+                        reason.should be_a Punchblock::Component::Output::Complete::Finish
                       end
 
                       it "redirects the call back to async AGI" do
@@ -781,7 +828,7 @@ module Punchblock
                     before do
                       expect_answered
                       mock_call.should_receive(:execute_agi_command).once.with('EXEC Playback', audio_filename)
-                      subject.wrapped_object.should_receive(:send_success).and_return nil
+                      subject.wrapped_object.should_receive(:send_finish).and_return nil
                     end
 
                     context "when a DTMF digit is received" do
@@ -794,7 +841,7 @@ module Punchblock
                         mock_call.async.process_ami_event ami_event
                         sleep 0.2
                         original_command.should be_complete
-                        reason.should be_a Punchblock::Component::Output::Complete::Success
+                        reason.should be_a Punchblock::Component::Output::Complete::Finish
                       end
 
                       it "redirects the call back to async AGI" do
@@ -806,8 +853,8 @@ module Punchblock
                     end
                   end
 
-                  context "set to :speech" do
-                    let(:command_opts) { { :interrupt_on => :speech } }
+                  context "set to :voice" do
+                    let(:command_opts) { { :interrupt_on => :voice } }
                     it "should return an error and not execute any actions" do
                       subject.execute
                       error = ProtocolError.new.setup 'option error', 'An interrupt-on value of speech is unsupported.'
@@ -830,13 +877,16 @@ module Punchblock
               let(:command_opts) { {:renderer => :asterisk} }
 
               let :command_options do
-                { :ssml => ssml_doc }.merge(command_opts)
+                { :render_document => {:value => ssml_doc} }.merge(command_opts)
               end
 
               let :original_command do
                 Punchblock::Component::Output.new command_options
               end
 
+              let(:playbackstatus) { 'SUCCESS' }
+              before { mock_call.stub(:channel_var).with('PLAYBACKSTATUS').and_return playbackstatus }
+
               it "should use the media renderer set and not the platform default" do
                 expect_answered
                 mock_call.should_receive(:execute_agi_command).once.with 'EXEC Playback', audio_filename

data/spec/punchblock/translator/asterisk/component/record_spec.rb

@@ -11,7 +11,7 @@ module Punchblock
 
           let(:media_engine)  { nil }
           let(:channel)       { 'SIP/foo' }
-          let(:ami_client)    { stub('AMI Client').as_null_object }
+          let(:ami_client)    { double('AMI Client').as_null_object }
           let(:translator)    { Punchblock::Translator::Asterisk.new ami_client, connection, media_engine }
           let(:mock_call)     { Punchblock::Translator::Asterisk::Call.new channel, translator, ami_client, connection }
 
@@ -53,13 +53,13 @@ module Punchblock
               subject.execute
             end
 
-            it "sends a success complete event when the recording ends" do
+            it "sends a max duration complete event when the recording ends" do
               full_filename = "file://#{Record::RECORDING_BASE_PATH}/#{subject.id}.wav"
               ami_client.should_receive(:send_action)
               subject.execute
               monitor_stop_event = RubyAMI::Event.new 'MonitorStop', 'Channel' => channel
               mock_call.process_ami_event monitor_stop_event
-              reason.should be_a Punchblock::Component::Record::Complete::Success
+              reason.should be_a Punchblock::Component::Record::Complete::MaxDuration
               recording.uri.should be == full_filename
               original_command.should be_complete
             end
@@ -235,14 +235,23 @@ module Punchblock
                 end
 
                 context "when we get a RubyAMI Error" do
-                  it "should send an error complete event" do
+                  it "should send an error response" do
                     error = RubyAMI::Error.new.tap { |e| e.message = 'FooBar' }
                     mock_call.should_receive(:execute_agi_command).and_raise error
                     ami_client.should_receive(:send_action).never
                     subject.execute
-                    complete_reason = original_command.complete_event(0.1).reason
-                    complete_reason.should be_a Punchblock::Event::Complete::Error
-                    complete_reason.details.should == "Terminated due to AMI error 'FooBar'"
+                    error = ProtocolError.new.setup :platform_error, "Terminated due to AMI error 'FooBar'"
+                    original_command.response(0.1).should be == error
+                  end
+                end
+
+                context "when the channel is no longer available" do
+                  it "should send an error complete event" do
+                    mock_call.should_receive(:execute_agi_command).and_raise ChannelGoneError
+                    ami_client.should_receive(:send_action).never
+                    subject.execute
+                    error = ProtocolError.new.setup(:item_not_found, "Could not find a call with ID #{mock_call.id}", mock_call.id)
+                    original_command.response(0.1).should be == error
                   end
                 end
               end
@@ -297,7 +306,7 @@ module Punchblock
                   monitor_stop_event = RubyAMI::Event.new 'MonitorStop', 'Channel' => channel
                   mock_call.process_ami_event monitor_stop_event
 
-                  reason.should be_a Punchblock::Component::Record::Complete::Success
+                  reason.should be_a Punchblock::Component::Record::Complete::MaxDuration
                   recording.uri.should be == full_filename
                   original_command.should be_complete
                 end

data/spec/punchblock/translator/asterisk/component/stop_by_redirect_spec.rb

@@ -15,8 +15,8 @@ module Punchblock
             end
           end
 
-          let(:connection)  { stub 'Connection' }
-          let(:ami_client)  { stub('AMI Client').as_null_object }
+          let(:connection)  { double 'Connection' }
+          let(:ami_client)  { double('AMI Client').as_null_object }
           let(:translator)  { Punchblock::Translator::Asterisk.new ami_client, connection }
           let(:mock_call)   { Call.new 'SIP/foo', translator, ami_client, connection }
 

data/spec/punchblock/translator/asterisk/component_spec.rb

@@ -29,10 +29,8 @@ module Punchblock
             end
 
             let :expected_event do
-              Punchblock::Event::Complete.new.tap do |e|
-                e.target_call_id = call.id
-                e.component_id = subject.id
-              end
+              Punchblock::Event::Complete.new target_call_id: call.id,
+                component_id: subject.id
             end
 
             it "should send the event to the connection" do
@@ -46,9 +44,7 @@ module Punchblock
 
             let(:reason) { Punchblock::Event::Complete::Stop.new }
             let :expected_event do
-              Punchblock::Event::Complete.new.tap do |c|
-                c.reason = Punchblock::Event::Complete::Stop.new
-              end
+              Punchblock::Event::Complete.new reason: reason
             end
 
             it "should send a complete event with the specified reason" do

data/spec/punchblock/translator/asterisk_spec.rb

@@ -6,8 +6,8 @@ require 'ostruct'
 module Punchblock
   module Translator
     describe Asterisk do
-      let(:ami_client)    { mock 'RubyAMI::Client' }
-      let(:connection)    { mock 'Connection::Asterisk', handle_event: nil }
+      let(:ami_client)    { double 'RubyAMI::Client' }
+      let(:connection)    { double 'Connection::Asterisk', handle_event: nil }
       let(:media_engine)  { :asterisk }
 
       let(:translator) { Asterisk.new ami_client, connection, media_engine }
@@ -112,20 +112,20 @@ module Punchblock
 
         it 'should make the call inaccessible by ID' do
           subject.call_with_id(call_id).should be call
-          subject.deregister_call call
+          subject.deregister_call call_id, channel
           subject.call_with_id(call_id).should be_nil
         end
 
         it 'should make the call inaccessible by channel' do
           subject.call_for_channel(channel).should be call
-          subject.deregister_call call
+          subject.deregister_call call_id, channel
           subject.call_for_channel(channel).should be_nil
         end
       end
 
       describe '#register_component' do
         let(:component_id) { 'abc123' }
-        let(:component)    { mock 'Asterisk::Component::Asterisk::AMIAction', :id => component_id }
+        let(:component)    { double 'Asterisk::Component::Asterisk::AMIAction', :id => component_id }
 
         it 'should make the component accessible by ID' do
           subject.register_component component
@@ -135,7 +135,7 @@ module Punchblock
 
       describe '#execute_call_command' do
         let(:call_id) { 'abc123' }
-        let(:command) { Command::Answer.new.tap { |c| c.target_call_id = call_id } }
+        let(:command) { Command::Answer.new target_call_id: call_id }
 
         context "with a known call ID" do
           let(:call) { Translator::Asterisk::Call.new 'SIP/foo', subject, ami_client, connection }
@@ -153,16 +153,13 @@ module Punchblock
         end
 
         let :end_error_event do
-          Punchblock::Event::End.new.tap do |e|
-            e.target_call_id = call_id
-            e.reason = :error
-          end
+          Punchblock::Event::End.new reason: :error, target_call_id: call_id
         end
 
         context "for an outgoing call which began executing but crashed" do
           let(:dial_command) { Command::Dial.new :to => 'SIP/1234', :from => 'abc123' }
 
-          let(:call_id) { dial_command.response.id }
+          let(:call_id) { dial_command.response.call_id }
 
           before do
             subject.async.should_receive(:execute_global_command)
@@ -238,7 +235,7 @@ module Punchblock
         let(:component_node)  { Component::Output.new }
         let(:component)       { Translator::Asterisk::Component::Output.new(component_node, call) }
 
-        let(:command) { Component::Stop.new.tap { |c| c.component_id = component.id } }
+        let(:command) { Component::Stop.new component_id: component.id }
 
         before do
           command.request!
@@ -281,7 +278,7 @@ module Punchblock
           end
 
           it 'should instruct the call to send a dial' do
-            mock_call = stub('Asterisk::Call').as_null_object
+            mock_call = double('Asterisk::Call').as_null_object
             Asterisk::Call.should_receive(:new_link).once.and_return mock_call
             mock_call.async.should_receive(:dial).once.with command
             subject.execute_global_command command
@@ -293,7 +290,7 @@ module Punchblock
             Component::Asterisk::AMI::Action.new :name => 'Status', :params => { :channel => 'foo' }
           end
 
-          let(:mock_action) { stub('Asterisk::Component::Asterisk::AMIAction').as_null_object }
+          let(:mock_action) { double('Asterisk::Component::Asterisk::AMIAction').as_null_object }
 
           it 'should create a component actor and execute it asynchronously' do
             Asterisk::Component::Asterisk::AMIAction.should_receive(:new).once.with(command, subject, ami_client).and_return mock_action
@@ -322,7 +319,7 @@ module Punchblock
 
       describe '#handle_pb_event' do
         it 'should forward the event to the connection' do
-          event = mock 'Punchblock::Event'
+          event = double 'Punchblock::Event'
           subject.connection.should_receive(:handle_event).once.with event
           subject.handle_pb_event event
         end
@@ -338,11 +335,11 @@ module Punchblock
         end
 
         let :expected_pb_event do
-          Event::Asterisk::AMI::Event.new :name => 'Newchannel',
-                                          :attributes => { :channel  => "SIP/101-3f3f",
-                                                           :state    => "Ring",
-                                                           :callerid => "101",
-                                                           :uniqueid => "1094154427.10"}
+          Event::Asterisk::AMI::Event.new name: 'Newchannel',
+                                          headers: { 'Channel'  => "SIP/101-3f3f",
+                                                     'State'    => "Ring",
+                                                     'Callerid' => "101",
+                                                     'Uniqueid' => "1094154427.10"}
         end
 
         it 'should create a Punchblock AMI event object and pass it to the connection' do
@@ -407,9 +404,8 @@ module Punchblock
           end
 
           it 'should instruct the call to send an offer' do
-            mock_call = stub('Asterisk::Call').as_null_object
-            Asterisk::Call.should_receive(:new).once.and_return mock_call
-            subject.wrapped_object.should_receive(:link)
+            mock_call = double('Asterisk::Call').as_null_object
+            Asterisk::Call.should_receive(:new_link).once.and_return mock_call
             mock_call.async.should_receive(:send_offer).once
             subject.handle_ami_event ami_event
           end
@@ -422,7 +418,7 @@ module Punchblock
             end
 
             it "should not create a new call" do
-              Asterisk::Call.should_receive(:new).never
+              Asterisk::Call.should_receive(:new_link).never
               subject.handle_ami_event ami_event
             end
           end