adhearsion-asterisk 1.3.1 → 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a687c0732e8408239c867b8480924c6206084bf4
+  data.tar.gz: 3baa0d3876880a58b2ad5376af3d2614cb47a418
+SHA512:
+  metadata.gz: d8dff1e952c3ae79c2c71713b98b4bf9cebfad82a5e917cf5d0491983051157b8e8ac96b7acbcda8a73030a322fbfe401cce664b13773c68846dfb4a17ba9c8f
+  data.tar.gz: fba213383d1700cdd1915a44d3c6649ef6f441b35e48087924d224da7a3c446aa4367200ae644c3a98c64bccda5a767cd6a756b22d1b0826b682f2b8638c8302

data/.gitignore

@@ -8,3 +8,4 @@ coverage
 vendor/bundle
 tags
 .rbenv-version
+tmp

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # develop
 
+# v1.4.0
+  * Feature: Add `#goto`, which will pass a call to another context/extension/priority and disconnect from Adhearsion
+
 # v1.3.1
   * Bugfix: Fixed `#execute` to concatenate multiple arguments correctly
 

data/adhearsion-asterisk.gemspec

@@ -19,19 +19,16 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_runtime_dependency %q<adhearsion>, ["~> 2.0"]
-  s.add_runtime_dependency %q<activesupport>, [">= 3.0.10"]
+  s.add_runtime_dependency %q<activesupport>, ["~> 3.0"]
   s.add_runtime_dependency %q<jruby-openssl> if RUBY_PLATFORM == 'java'
 
-  s.add_development_dependency %q<bundler>, [">= 1.0.0"]
-  s.add_development_dependency %q<rspec>, [">= 2.5.0"]
-  s.add_development_dependency %q<ci_reporter>, [">= 1.6.3"]
+  s.add_development_dependency %q<bundler>, ["~> 1.0"]
+  s.add_development_dependency %q<rspec>, ["~> 2.5"]
+  s.add_development_dependency %q<ci_reporter>, ["~> 1.6"]
   s.add_development_dependency %q<simplecov>, [">= 0"]
   s.add_development_dependency %q<simplecov-rcov>, [">= 0"]
-  s.add_development_dependency %q<yard>, [">= 0.6.0"]
+  s.add_development_dependency %q<yard>, ["~> 0.6"]
   s.add_development_dependency %q<rake>, [">= 0"]
-  s.add_development_dependency %q<mocha>, [">= 0"]
-  s.add_development_dependency %q<bones>
   s.add_development_dependency %q<guard-rspec>
   s.add_development_dependency %q<ruby_gntp>
-  s.add_development_dependency %q<thor>, ["~> 0.14.0"]
 end

data/lib/adhearsion/asterisk/call_controller_methods.rb

@@ -412,6 +412,19 @@ module Adhearsion
         GenerateSilenceProxy.proxy_for(self, &block) if block_given?
       end
 
+      #
+      # Go to a specified context, extension and priority
+      # This requires us to relinquish control of the call.
+      # Execution will continue until the user hangs up, but the channel will be no longer available
+      #
+      def goto(context, extension = :nothing, priority = :nothing)
+        call[:ahn_prevent_hangup] = true
+        args = ['Goto', context, extension, priority].reject { |v| v == :nothing }
+        execute *args
+        set_variable 'PUNCHBLOCK_END_ON_ASYNCAGI_BREAK', 'true'
+        agi "ASYNCAGI BREAK"
+      end
+
       class GenerateSilenceProxy
         def self.proxy_for(target, &block)
           proxy = new(target)

data/lib/adhearsion/asterisk/version.rb

@@ -1,5 +1,5 @@
 module Adhearsion
   module Asterisk
-    VERSION = "1.3.1"
+    VERSION = "1.4.0"
   end
 end

data/spec/adhearsion/asterisk/call_controller_methods_spec.rb

@@ -4,7 +4,9 @@ module Adhearsion::Asterisk
   describe CallControllerMethods do
     describe "mixed in to a CallController" do
 
-      subject { Adhearsion::CallController.new mock('Call') }
+      let(:call) { mock('Call') }
+
+      subject { Adhearsion::CallController.new call }
 
       before { Adhearsion::CallController.mixin CallControllerMethods }
 
@@ -19,10 +21,10 @@ module Adhearsion::Asterisk
           end
         end
 
-        before { Punchblock::Component::Asterisk::AGI::Command.any_instance.stubs :complete_event => complete_event }
+        before { Punchblock::Component::Asterisk::AGI::Command.any_instance.stub :complete_event => complete_event }
 
         it 'should execute an AGI command with the specified name and parameters and return the response code, response and data' do
-          subject.expects(:execute_component_and_await_completion).once.with expected_agi_command
+          subject.should_receive(:execute_component_and_await_completion).once.with expected_agi_command
           values = subject.agi 'Dial', '4044754842', 15
           values.should == [200, 1, 'foobar']
         end
@@ -35,7 +37,7 @@ module Adhearsion::Asterisk
           end
 
           it 'should raise Adhearsion::Call::Hangup' do
-            subject.expects(:execute_component_and_await_completion).once.with expected_agi_command
+            subject.should_receive(:execute_component_and_await_completion).once.with expected_agi_command
             lambda { subject.agi 'Dial', '4044754842', 15 }.should raise_error(Adhearsion::Call::Hangup)
           end
         end
@@ -43,21 +45,21 @@ module Adhearsion::Asterisk
 
       describe '#execute' do
         it 'calls #agi and prefixes the command with EXEC' do
-          subject.expects(:agi).once.with 'EXEC Dial', '4044754842,15'
+          subject.should_receive(:agi).once.with 'EXEC Dial', '4044754842,15'
           subject.execute 'Dial', '4044754842', 15
         end
       end
 
       describe '#verbose' do
         it 'executes the VERBOSE AGI command' do
-          subject.expects(:agi).once.with 'VERBOSE', 'Foo Bar!', 15
+          subject.should_receive(:agi).once.with 'VERBOSE', 'Foo Bar!', 15
           subject.verbose 'Foo Bar!', 15
         end
       end
 
       describe '#enable_feature' do
         it 'it should fetch the variable for DYNAMIC_FEATURES at first' do
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES").throws(:got_variable)
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES").and_throw(:got_variable)
           expect {
             subject.enable_feature :foobar
           }.to throw_symbol :got_variable
@@ -73,13 +75,13 @@ module Adhearsion::Asterisk
 
           # I had to do this ugly hack because of a bug in Flexmock which prevented me from mocking out Hash#[]  :(
           # FIXME: mock Hash
-          #        ...DYNAMIC_FEATURE_EXTENSIONS.expects(feature_name => assertion)
+          #        ...DYNAMIC_FEATURE_EXTENSIONS.should_receive(feature_name => assertion)
 
           old_hash_feature_extension = Adhearsion::Asterisk::CallControllerMethods::DYNAMIC_FEATURE_EXTENSIONS[feature_name]
           begin
             Adhearsion::Asterisk::CallControllerMethods::DYNAMIC_FEATURE_EXTENSIONS[feature_name] = assertion
 
-            subject.expects(:enable_feature).once.with(feature_name, :this_is_the_right_arg).throws :inside_assertion!
+            subject.should_receive(:enable_feature).once.with(feature_name, :this_is_the_right_arg).and_throw :inside_assertion!
             expect { subject.enable_feature(feature_name, :this_is_the_right_arg)}.to throw_symbol :inside_assertion!
           ensure
             Adhearsion::Asterisk::CallControllerMethods::DYNAMIC_FEATURE_EXTENSIONS[feature_name] = old_hash_feature_extension
@@ -87,13 +89,13 @@ module Adhearsion::Asterisk
         end
 
         it 'should separate enabled features with a "#"' do
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES").returns("one")
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES" => 'one#bar')
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES").and_return("one")
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES" => 'one#bar')
           subject.enable_feature "bar"
         end
 
         it 'should not add duplicate enabled dynamic features' do
-          subject.expects(:variable).once.returns('eins#zwei')
+          subject.should_receive(:variable).once.and_return('eins#zwei')
           subject.enable_feature "eins"
         end
 
@@ -104,63 +106,63 @@ module Adhearsion::Asterisk
         end
 
         it 'enabling :attended_transfer should actually enable the atxfer feature' do
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES").returns ''
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES" => 'atxfer')
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES").and_return ''
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES" => 'atxfer')
           subject.enable_feature :attended_transfer
         end
 
         it 'the :context optional option when enabling :attended_transfer should set the TRANSFER_CONTEXT variable to the String supplied as a Hash value' do
           context_name = "direct_dial"
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES").returns ''
-          subject.expects(:variable).once.with("DYNAMIC_FEATURES" => 'atxfer')
-          subject.expects(:variable).once.with("TRANSFER_CONTEXT" => context_name)
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES").and_return ''
+          subject.should_receive(:variable).once.with("DYNAMIC_FEATURES" => 'atxfer')
+          subject.should_receive(:variable).once.with("TRANSFER_CONTEXT" => context_name)
           subject.enable_feature :attended_transfer, :context => context_name
         end
 
         it 'enabling :attended_transfer should not add a duplicate if atxfer has been enabled, but it should still set the TRANSFER_CONTEXT variable' do
           context_name = 'blah'
-          subject.expects(:variable).once.with('DYNAMIC_FEATURES').returns 'atxfer'
-          subject.expects(:variable).once.with('TRANSFER_CONTEXT' => context_name)
+          subject.should_receive(:variable).once.with('DYNAMIC_FEATURES').and_return 'atxfer'
+          subject.should_receive(:variable).once.with('TRANSFER_CONTEXT' => context_name)
           subject.enable_feature :attended_transfer, :context => context_name
         end
       end
 
       describe '#disable_feature' do
         it "should properly remove the feature from the DYNAMIC_FEATURES variable" do
-          subject.expects(:variable).once.with('DYNAMIC_FEATURES').returns 'foobar#qaz'
-          subject.expects(:variable).once.with('DYNAMIC_FEATURES' => 'qaz')
+          subject.should_receive(:variable).once.with('DYNAMIC_FEATURES').and_return 'foobar#qaz'
+          subject.should_receive(:variable).once.with('DYNAMIC_FEATURES' => 'qaz')
           subject.disable_feature "foobar"
         end
 
         it "should not re-set the variable if the feature wasn't enabled in the first place" do
-          subject.expects(:variable).once.with('DYNAMIC_FEATURES').returns 'atxfer'
-          subject.expects(:variable).never
+          subject.should_receive(:variable).once.with('DYNAMIC_FEATURES').and_return 'atxfer'
+          subject.should_receive(:variable).never
           subject.disable_feature "jay"
         end
       end
 
       describe "#variable" do
         it "should call set_variable when Hash argument given" do
-          subject.expects(:set_variable).once.with :ohai, "ur_home_erly"
+          subject.should_receive(:set_variable).once.with :ohai, "ur_home_erly"
           subject.variable :ohai => 'ur_home_erly'
         end
 
         it "should call set_variable for every Hash-key given" do
           many_args = { :a => :b, :c => :d, :e => :f, :g => :h}
-          subject.expects(:set_variable).times(many_args.size)
+          subject.should_receive(:set_variable).exactly(many_args.size).times
           subject.variable many_args
         end
 
         it "should call get_variable for every String given" do
           variables = ["foo", "bar", :qaz, :qwerty, :baz]
           variables.each do |var|
-            subject.expects(:get_variable).once.with(var).returns("X")
+            subject.should_receive(:get_variable).once.with(var).and_return("X")
           end
           subject.variable(*variables).should == ["X"] * variables.size
         end
 
         it "should NOT return an Array when just one arg is given" do
-          subject.expects(:get_variable).once.returns "lol"
+          subject.should_receive(:get_variable).once.and_return "lol"
           subject.variable(:foo).should_not be_a Array
         end
 
@@ -173,21 +175,21 @@ module Adhearsion::Asterisk
 
       describe "#set_variable" do
         it "uses SET VARIABLE" do
-          subject.expects(:agi).once.with 'SET VARIABLE', 'foo', 'i can " has ruby?'
+          subject.should_receive(:agi).once.with 'SET VARIABLE', 'foo', 'i can " has ruby?'
           subject.set_variable 'foo', 'i can " has ruby?'
         end
       end
 
       describe '#get_variable' do
         it 'uses GET VARIABLE and extracts the value from the data' do
-          subject.expects(:agi).once.with('GET VARIABLE', 'foo').returns [200, 1, 'bar']
+          subject.should_receive(:agi).once.with('GET VARIABLE', 'foo').and_return [200, 1, 'bar']
           subject.get_variable('foo').should == 'bar'
         end
       end
 
       describe "#sip_add_header" do
         it "executes SIPAddHeader" do
-          subject.expects(:execute).once.with 'SIPAddHeader', 'x-ahn-header: rubyrox'
+          subject.should_receive(:execute).once.with 'SIPAddHeader', 'x-ahn-header: rubyrox'
           subject.sip_add_header "x-ahn-header", "rubyrox"
         end
       end
@@ -195,7 +197,7 @@ module Adhearsion::Asterisk
       describe "#sip_get_header" do
         it "uses #get_variable to get the header value" do
           value = 'jason-was-here'
-          subject.expects(:get_variable).once.with('SIP_HEADER(x-ahn-header)').returns value
+          subject.should_receive(:get_variable).once.with('SIP_HEADER(x-ahn-header)').and_return value
           subject.sip_get_header("x-ahn-header").should == value
         end
       end
@@ -203,25 +205,25 @@ module Adhearsion::Asterisk
       describe '#join' do
         it "should pass the 'd' flag when no options are given" do
           conference_id = "123"
-          subject.expects(:execute).once.with("MeetMe", conference_id, "d", nil)
+          subject.should_receive(:execute).once.with("MeetMe", conference_id, "d", nil)
           subject.meetme conference_id
         end
 
         it "should pass through any given flags with 'd' appended to it if necessary" do
           conference_id, flags = "1000", "zomgs"
-          subject.expects(:execute).once.with("MeetMe", conference_id, flags + "d", nil)
+          subject.should_receive(:execute).once.with("MeetMe", conference_id, flags + "d", nil)
           subject.meetme conference_id, :options => flags
         end
 
         it "should NOT pass the 'd' flag when requiring static conferences" do
           conference_id, options = "1000", {:use_static_conf => true}
-          subject.expects(:execute).once.with("MeetMe", conference_id, "", nil)
+          subject.should_receive(:execute).once.with("MeetMe", conference_id, "", nil)
           subject.meetme conference_id, options
         end
 
         it "should raise an ArgumentError when the pin is not numerical" do
           lambda {
-            subject.expects(:execute).never
+            subject.should_receive(:execute).never
             subject.meetme 3333, :pin => "letters are bad, mkay?!1"
           }.should raise_error ArgumentError
         end
@@ -229,7 +231,7 @@ module Adhearsion::Asterisk
         it "should strip out illegal characters from a conference name" do
           bizarre_conference_name = "a-    bc!d&&e--`"
           normal_conference_name = "abcde"
-          subject.expects(:execute).twice.with("MeetMe", normal_conference_name, "d", nil)
+          subject.should_receive(:execute).twice.with("MeetMe", normal_conference_name, "d", nil)
 
           subject.meetme bizarre_conference_name
           subject.meetme normal_conference_name
@@ -237,7 +239,7 @@ module Adhearsion::Asterisk
 
         it "should allow textual conference names" do
           lambda {
-            subject.expects(:execute).once
+            subject.should_receive(:execute).once
             subject.meetme "david bowie's pants"
           }.should_not raise_error
         end
@@ -245,28 +247,28 @@ module Adhearsion::Asterisk
 
       describe '#voicemail' do
         it 'should not send the context name when none is given' do
-          subject.expects(:execute).once.with('voicemail', 123, '').throws :sent_voicemail!
+          subject.should_receive(:execute).once.with('voicemail', 123, '').and_throw :sent_voicemail!
           lambda { subject.voicemail 123 }.should throw_symbol(:sent_voicemail!)
         end
 
         it 'should send the context name when one is given' do
           mailbox_number, context_name = 333, 'doesntmatter'
-          subject.expects(:execute).once.with('voicemail', "#{mailbox_number}@#{context_name}", '').throws :sent_voicemail!
+          subject.should_receive(:execute).once.with('voicemail', "#{mailbox_number}@#{context_name}", '').and_throw :sent_voicemail!
           lambda { subject.voicemail(context_name => mailbox_number) }.should throw_symbol(:sent_voicemail!)
         end
 
         it 'should pass in the s option if :skip => true' do
           mailbox_number = '012'
-          subject.expects(:execute).once.with('voicemail', mailbox_number, 's').throws :sent_voicemail!
+          subject.should_receive(:execute).once.with('voicemail', mailbox_number, 's').and_throw :sent_voicemail!
           lambda { subject.voicemail(mailbox_number, :skip => true) }.should throw_symbol(:sent_voicemail!)
         end
 
         it 'should combine mailbox numbers with the context name given when both are given' do
-          subject.expects(:variable).with("VMSTATUS").returns 'SUCCESS'
+          subject.should_receive(:variable).with("VMSTATUS").and_return 'SUCCESS'
           context   = "lolcats"
           mailboxes = [1,2,3,4,5]
           mailboxes_with_context = mailboxes.map { |mailbox| [mailbox, context].join '@' }
-          subject.expects(:execute).once.with('voicemail', mailboxes_with_context.join('&'), '')
+          subject.should_receive(:execute).once.with('voicemail', mailboxes_with_context.join('&'), '')
           subject.voicemail context => mailboxes
         end
 
@@ -296,13 +298,13 @@ module Adhearsion::Asterisk
 
         it 'should pass in the u option if :greeting => :unavailable' do
           mailbox_number = '776'
-          subject.expects(:execute).once.with('voicemail', mailbox_number, 'u').throws :sent_voicemail!
+          subject.should_receive(:execute).once.with('voicemail', mailbox_number, 'u').and_throw :sent_voicemail!
           lambda { subject.voicemail(mailbox_number, :greeting => :unavailable) }.should throw_symbol(:sent_voicemail!)
         end
 
         it 'should pass in both the skip and greeting options if both are supplied' do
           mailbox_number = '4'
-          subject.expects(:execute).once.with('voicemail', mailbox_number, 'u').throws :sent_voicemail!
+          subject.should_receive(:execute).once.with('voicemail', mailbox_number, 'u').and_throw :sent_voicemail!
           lambda { subject.voicemail(mailbox_number, :greeting => :unavailable) }.should throw_symbol(:sent_voicemail!)
         end
 
@@ -318,25 +320,25 @@ module Adhearsion::Asterisk
 
         it 'should pass in the b option if :gretting => :busy' do
           mailbox_number = '1'
-          subject.expects(:execute).once.with('voicemail', mailbox_number, 'b').throws :sent_voicemail!
+          subject.should_receive(:execute).once.with('voicemail', mailbox_number, 'b').and_throw :sent_voicemail!
           lambda { subject.voicemail(mailbox_number, :greeting => :busy) }.should throw_symbol(:sent_voicemail!)
         end
 
         it 'should return true if VMSTATUS == "SUCCESS"' do
-          subject.expects(:execute).once
-          subject.expects(:variable).once.with('VMSTATUS').returns "SUCCESS"
+          subject.should_receive(:execute).once
+          subject.should_receive(:variable).once.with('VMSTATUS').and_return "SUCCESS"
           subject.voicemail(3).should be true
         end
 
         it 'should return false if VMSTATUS == "USEREXIT"' do
-          subject.expects(:execute).once
-          subject.expects(:variable).once.with('VMSTATUS').returns "USEREXIT"
+          subject.should_receive(:execute).once
+          subject.should_receive(:variable).once.with('VMSTATUS').and_return "USEREXIT"
           subject.voicemail(2).should be false
         end
 
         it 'should return nil if VMSTATUS == "FAILED"' do
-          subject.expects(:execute).once
-          subject.expects(:variable).once.with('VMSTATUS').returns "FAILED"
+          subject.should_receive(:execute).once
+          subject.should_receive(:variable).once.with('VMSTATUS').and_return "FAILED"
           subject.voicemail(2).should be nil
         end
       end
@@ -345,48 +347,48 @@ module Adhearsion::Asterisk
         it "the :folder Hash key argument should wrap the value in a()" do
           folder = "foobar"
           mailbox = 81
-          subject.expects(:execute).once.with("VoiceMailMain", "#{mailbox}","a(#{folder})")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "#{mailbox}","a(#{folder})")
           subject.voicemail_main :mailbox => mailbox, :folder => folder
         end
 
         it ':authenticate should pass in the "s" option if given false' do
           mailbox = 333
-          subject.expects(:execute).once.with("VoiceMailMain", "#{mailbox}","s")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "#{mailbox}","s")
           subject.voicemail_main :mailbox => mailbox, :authenticate => false
         end
 
         it ':authenticate should pass in the s option if given false' do
           mailbox = 55
-          subject.expects(:execute).once.with("VoiceMailMain", "#{mailbox}")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "#{mailbox}")
           subject.voicemail_main :mailbox => mailbox, :authenticate => true
         end
 
         it 'should not pass any flags only a mailbox is given' do
           mailbox = "1"
-          subject.expects(:execute).once.with("VoiceMailMain", "#{mailbox}")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "#{mailbox}")
           subject.voicemail_main :mailbox => mailbox
         end
 
         it 'when given no mailbox or context an empty string should be passed to execute as the first argument' do
-          subject.expects(:execute).once.with("VoiceMailMain", "", "s")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "", "s")
           subject.voicemail_main :authenticate => false
         end
 
         it 'should properly concatenate the options when given multiple ones' do
           folder = "ohai"
           mailbox = 9999
-          subject.expects(:execute).once.with("VoiceMailMain", "#{mailbox}", "sa(#{folder})")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "#{mailbox}", "sa(#{folder})")
           subject.voicemail_main :mailbox => mailbox, :authenticate => false, :folder => folder
         end
 
         it 'should not require any arguments' do
-          subject.expects(:execute).once.with("VoiceMailMain")
+          subject.should_receive(:execute).once.with("VoiceMailMain")
           subject.voicemail_main
         end
 
         it 'should pass in the "@context_name" part in if a :context is given and no mailbox is given' do
           context_name = "icanhascheezburger"
-          subject.expects(:execute).once.with("VoiceMailMain", "@#{context_name}")
+          subject.should_receive(:execute).once.with("VoiceMailMain", "@#{context_name}")
           subject.voicemail_main :context => context_name
         end
 
@@ -425,17 +427,17 @@ module Adhearsion::Asterisk
         let(:time_format) { 'IMp' }
 
         it "if a Date object is passed in, SayUnixTime is sent with the argument and format" do
-          subject.expects(:execute).once.with("SayUnixTime", date.to_time.to_i, "", date_format)
+          subject.should_receive(:execute).once.with("SayUnixTime", date.to_time.to_i, "", date_format)
           subject.play_time(date, :format => date_format)
         end
 
         it "if a Time object is passed in, SayUnixTime is sent with the argument and format" do
-          subject.expects(:execute).once.with("SayUnixTime", time.to_i, "", time_format)
+          subject.should_receive(:execute).once.with("SayUnixTime", time.to_i, "", time_format)
           subject.play_time(time, :format => time_format)
         end
 
         it "if a Time object is passed in alone, SayUnixTime is sent with the argument and the default format" do
-          subject.expects(:execute).once.with("SayUnixTime", time.to_i, "", "")
+          subject.should_receive(:execute).once.with("SayUnixTime", time.to_i, "", "")
           subject.play_time(time)
         end
 
@@ -444,7 +446,7 @@ module Adhearsion::Asterisk
       describe "#play_numeric" do
         let(:numeric) { 20 }
         it "should send the correct command SayNumber playing a numeric argument" do
-          subject.expects(:execute).once.with("SayNumber", numeric)
+          subject.should_receive(:execute).once.with("SayNumber", numeric)
           subject.play_numeric(numeric)
         end
       end
@@ -452,7 +454,7 @@ module Adhearsion::Asterisk
       describe "#play_digits" do
         let(:numeric) { 20 }
         it "should send the correct command SayDigits playing a numeric argument" do
-          subject.expects(:execute).once.with("SayDigits", numeric)
+          subject.should_receive(:execute).once.with("SayDigits", numeric)
           subject.play_digits(numeric)
         end
       end
@@ -460,7 +462,7 @@ module Adhearsion::Asterisk
       describe "#play_tones" do
         context "should send the correct command Playtones playing tones" do
           before do
-            subject.expects(:execute).once.with("Playtones", "!950/330,!1400/330,!1800/330,0")
+            subject.should_receive(:execute).once.with("Playtones", "!950/330,!1400/330,!1800/330,0")
           end
 
           it "given as a string" do
@@ -472,7 +474,7 @@ module Adhearsion::Asterisk
           end
 
           it "and sleep for the duration when instructed" do
-            subject.expects(:sleep).once.with(0.99)
+            subject.should_receive(:sleep).once.with(0.99)
             subject.play_tones("!950/330,!1400/330,!1800/330,0", true)
           end
         end
@@ -481,15 +483,15 @@ module Adhearsion::Asterisk
       describe "#play_soundfile" do
         let(:audiofile) { "tt-monkeys" }
         it "should send the correct command Playback playing an audio file" do
-          subject.expects(:execute).once.with("Playback", audiofile)
-          # subject.expects(:execute).once.with("Playback", audiofile).returns([200, 1, nil])
-          subject.expects(:get_variable).once.with("PLAYBACKSTATUS").returns(PLAYBACK_SUCCESS)
+          subject.should_receive(:execute).once.with("Playback", audiofile)
+          # subject.should_receive(:execute).once.with("Playback", audiofile).and_return([200, 1, nil])
+          subject.should_receive(:get_variable).once.with("PLAYBACKSTATUS").and_return(PLAYBACK_SUCCESS)
           subject.play_soundfile(audiofile)
         end
 
         it "should return false if playback fails" do
-          subject.expects(:execute).once.with("Playback", audiofile)
-          subject.expects(:get_variable).once.with("PLAYBACKSTATUS").returns('FAILED')
+          subject.should_receive(:execute).once.with("Playback", audiofile)
+          subject.should_receive(:get_variable).once.with("PLAYBACKSTATUS").and_return('FAILED')
           subject.play_soundfile(audiofile).should == false
         end
       end
@@ -498,7 +500,7 @@ module Adhearsion::Asterisk
         context 'executes Playtones with 0 as an argument if it' do
           before do
             command = Punchblock::Component::Asterisk::AGI::Command.new :name => "EXEC Playtones", :params => ["0"]
-            @expect_command = subject.expects(:execute_component_and_await_completion).with(command)
+            @expect_command = subject.should_receive(:execute_component_and_await_completion).with(command)
           end
 
           it 'is not given a block' do
@@ -507,7 +509,7 @@ module Adhearsion::Asterisk
           end
 
           it 'is given a block, which it then yields' do
-            @expect_command.times(3)
+            @expect_command.exactly(3).times
             expect { |b| subject.generate_silence { b.to_proc.call; run; run } }.to yield_with_no_args
           end
 
@@ -542,6 +544,48 @@ module Adhearsion::Asterisk
           end
         end
       end
+
+      describe "#goto" do
+        let(:context) { "foo" }
+        let(:extension) { "s" }
+        let(:priority) { 1 }
+
+        it "sets the call to not hangup after execution" do
+          call.should_receive(:[]=).with(:ahn_prevent_hangup, true)
+          subject.should_receive(:execute).with('Goto', context, extension, priority)
+          subject.should_receive(:set_variable).with('PUNCHBLOCK_END_ON_ASYNCAGI_BREAK', 'true').once
+          subject.should_receive(:agi).with("ASYNCAGI BREAK").at_most :once
+          subject.goto(context, extension, priority)
+        end
+
+        it "releases control of the call using ASYNCAGI BREAK" do
+          call.should_receive(:[]=).with(:ahn_prevent_hangup, true).at_most :once
+          subject.should_receive(:execute).with('Goto', context, extension, priority).at_most :once
+          subject.should_receive(:set_variable).with('PUNCHBLOCK_END_ON_ASYNCAGI_BREAK', 'true').once
+          subject.should_receive(:agi).with("ASYNCAGI BREAK").once
+          subject.goto(context, extension, priority)
+        end
+
+        context "number of arguments" do
+          before :each do
+            call.should_receive(:[]=).with(:ahn_prevent_hangup, true).at_most :once
+            subject.should_receive(:set_variable).with('PUNCHBLOCK_END_ON_ASYNCAGI_BREAK', 'true').once
+            subject.should_receive(:agi).with("ASYNCAGI BREAK").at_most :once
+          end
+          it "executes Goto with 3 arguments when passed all 3" do
+            subject.should_receive(:execute).with('Goto', context, extension, priority)
+            subject.goto(context, extension, priority)
+          end
+          it "executes Goto with 2 arguments when passed 2" do
+            subject.should_receive(:execute).with('Goto', context, extension)
+            subject.goto(context, extension)
+          end
+          it "executes Goto with 1 arguments when passed 1" do
+            subject.should_receive(:execute).with('Goto', context)
+            subject.goto(context)
+          end
+        end
+      end
     end
   end#main describe
 end