adhearsion 2.3.5 → 2.4.0.beta1

data/spec/adhearsion/call_controller/menu_dsl/menu_builder_spec.rb

@@ -16,6 +16,16 @@ module Adhearsion
               foo :bar
             end
           end
+
+          let(:foo) { :bar }
+
+          it "makes the block context available" do
+            doo = nil
+            subject.build do
+              doo = foo
+            end
+            doo.should == :bar
+          end
         end#build
 
         describe "#match" do

data/spec/adhearsion/call_controller/output/async_player_spec.rb

@@ -57,7 +57,7 @@ module Adhearsion
           let(:ssml) { RubySpeech::SSML.draw { string "BOO" } }
 
           it 'executes an Output with the correct ssml' do
-            component = Punchblock::Component::Output.new :ssml => ssml.to_s
+            component = Punchblock::Component::Output.new :ssml => ssml
             expect_message_waiting_for_response component
             subject.play_ssml ssml
           end

data/spec/adhearsion/call_controller/output/player_spec.rb

@@ -61,7 +61,7 @@ module Adhearsion
           let(:ssml) { RubySpeech::SSML.draw { string "BOO" } }
 
           it 'executes an Output with the correct ssml' do
-            expect_component_execution Punchblock::Component::Output.new(:ssml => ssml.to_s)
+            expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
             subject.play_ssml ssml
           end
         end

data/spec/adhearsion/call_controller/output_spec.rb

@@ -700,7 +700,7 @@ module Adhearsion
           controller.stub(:write_and_await_response)
 
           expect_component_complete_event
-          expect_component_execution Punchblock::Component::Output.new(:ssml => ssml.to_s)
+          expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
           subject.stream_file prompt, allowed_digits
         end
 
@@ -712,7 +712,7 @@ module Adhearsion
           controller.should_receive(:write_and_await_response).once.with(kind_of(Punchblock::Component::Output))
 
           Punchblock::Component::Output.any_instance.should_receive(:stop!)
-          Punchblock::Component::Output.any_instance.should_receive(:complete_event).and_return mock('complete', reason: mock('Reason'))
+          Punchblock::Component::Output.any_instance.should_receive(:complete_event).and_return double('complete', reason: double('Reason'))
           expect_input_component_complete_event 'dtmf-5'
 
           subject.stream_file(prompt, allowed_digits).should be == '5'
@@ -724,7 +724,7 @@ module Adhearsion
             controller.stub(:write_and_await_response)
 
             expect_component_complete_event
-            expect_component_execution Punchblock::Component::Output.new({:ssml => ssml.to_s}.merge(extra_options))
+            expect_component_execution Punchblock::Component::Output.new({:ssml => ssml}.merge(extra_options))
             subject.stream_file prompt, allowed_digits, extra_options
           end
         end

data/spec/adhearsion/call_controller/record_spec.rb

@@ -139,7 +139,7 @@ module Adhearsion
           let(:complete_event) { Punchblock::Event::Complete.new }
 
           it "should execute those handlers when recording completes" do
-            foo = mock 'foo'
+            foo = double 'foo'
             foo.should_receive(:call).once.with kind_of(Punchblock::Event::Complete)
             subject.handle_record_completion { |e| foo.call e }
             subject.record_component.trigger_event_handler complete_event

data/spec/adhearsion/call_controller_spec.rb

@@ -215,7 +215,6 @@ module Adhearsion
     end
 
     [ :answer,
-      :reject,
       :mute,
       :unmute].each do |method_name|
       describe "##{method_name}" do
@@ -227,11 +226,16 @@ module Adhearsion
       end
     end
 
-    describe "#hangup" do
-      it "delegates to the call, blocking first until it is allowed to execute" do
-        subject.should_receive(:block_until_resumed).once.ordered
-        subject.call.should_receive(:hangup).once.ordered
-        lambda { subject.send :hangup }.should raise_error Call::Hangup
+    [
+      :hangup,
+      :reject
+    ].each do |method_name|
+      describe "##{method_name}" do
+        it "delegates to the call, blocking first until it is allowed to execute, and raises Call::Hangup" do
+          subject.should_receive(:block_until_resumed).once.ordered
+          subject.call.should_receive(method_name).once.ordered
+          lambda { subject.send method_name }.should raise_error Call::Hangup
+        end
       end
     end
 
@@ -245,9 +249,9 @@ module Adhearsion
           latch.countdown!
         end
         latch.wait(1).should be false
-        subject.call << Punchblock::Event::Joined.new(:call_id => 'call1')
+        subject.call << Punchblock::Event::Joined.new(call_uri: 'call1')
         latch.wait(1).should be false
-        subject.call << Punchblock::Event::Unjoined.new(:call_id => 'call1')
+        subject.call << Punchblock::Event::Unjoined.new(call_uri: 'call1')
         latch.wait(1).should be true
       end
 
@@ -278,7 +282,7 @@ module Adhearsion
             latch.countdown!
           end
           latch.wait(1).should be false
-          subject.call << Punchblock::Event::Joined.new(:call_id => 'call1')
+          subject.call << Punchblock::Event::Joined.new(call_uri: 'call1')
           latch.wait(1).should be true
         end
 

data/spec/adhearsion/call_spec.rb

@@ -10,17 +10,21 @@ end
 
 module Adhearsion
   describe Call do
-    let(:mock_client) { mock('Client').as_null_object }
+    let(:mock_client) { double('Client').as_null_object }
 
-    let(:call_id) { rand }
+    let(:call_id) { rand.to_s }
+    let(:domain)  { 'rayo.net' }
     let(:headers) { nil }
     let(:to)      { 'sip:you@there.com' }
     let(:from)    { 'sip:me@here.com' }
+    let(:transport) { 'footransport' }
     let :offer do
-      Punchblock::Event::Offer.new :target_call_id => call_id,
-                                   :to      => to,
-                                   :from    => from,
-                                   :headers => headers
+      Punchblock::Event::Offer.new target_call_id: call_id,
+                                   domain: domain,
+                                   transport: transport,
+                                   to: to,
+                                   from: from,
+                                   headers: headers
     end
 
     subject { Adhearsion::Call.new offer }
@@ -41,14 +45,46 @@ module Adhearsion
     its(:commands) { should be_empty }
 
     its(:id)      { should be == call_id }
+    its(:domain)  { should be == domain }
+    its(:uri)     { should be == "footransport:#{call_id}@#{domain}" }
     its(:to)      { should be == to }
     its(:from)    { should be == from }
 
+    context "when the ID is nil" do
+      let(:call_id) { nil }
+
+      its(:uri) { should be == nil }
+    end
+
+    context "when the domain is nil" do
+      let(:domain) { nil }
+
+      its(:uri) { should be == "footransport:#{call_id}" }
+    end
+
+    context "when the transport is nil" do
+      let(:transport) { nil }
+
+      its(:uri) { should be == "#{call_id}@#{domain}" }
+    end
+
+    it "should mark its start time" do
+      base_time = Time.local(2008, 9, 1, 12, 0, 0)
+      Timecop.freeze base_time
+      subject.start_time.should == base_time
+    end
+
+    describe "#commands" do
+      it "should use a duplicating accessor for the command registry" do
+        subject.commands.should_not be subject.commands
+      end
+    end
+
     describe "its variables" do
       context "with an offer" do
         context "with headers" do
-          let(:headers)   { {:x_foo => 'bar'} }
-          its(:variables) { should be == headers }
+          let(:headers)   { {'X-foo' => 'bar'} }
+          its(:variables) { should be == {'x_foo' => 'bar'} }
 
           it "should be made available via []" do
             subject[:x_foo].should be == 'bar'
@@ -60,20 +96,29 @@ module Adhearsion
           end
 
           context "when receiving an event with headers" do
-            let(:event) { Punchblock::Event::End.new :headers => {:x_bar => 'foo'} }
+            let(:event) { Punchblock::Event::End.new :headers => {'X-bar' => 'foo'} }
 
             it "should merge later headers" do
               subject << event
-              subject.variables.should be == {:x_foo => 'bar', :x_bar => 'foo'}
+              subject.variables.should be == {'x_foo' => 'bar', 'x_bar' => 'foo'}
+            end
+
+            context "with have symbol names" do
+              let(:event) { Punchblock::Event::End.new :headers => {:x_bar => 'foo'} }
+
+              it "should merge later headers" do
+                subject << event
+                subject.variables.should be == {'x_foo' => 'bar', 'x_bar' => 'foo'}
+              end
             end
           end
 
           context "when sending a command with headers" do
-            let(:command) { Punchblock::Command::Accept.new :headers => {:x_bar => 'foo'} }
+            let(:command) { Punchblock::Command::Accept.new :headers => {'X-bar' => 'foo'} }
 
             it "should merge later headers" do
               subject.write_command command
-              subject.variables.should be == {:x_foo => 'bar', :x_bar => 'foo'}
+              subject.variables.should be == {'x_foo' => 'bar', 'x_bar' => 'foo'}
             end
           end
         end
@@ -97,26 +142,41 @@ module Adhearsion
     end
 
     it 'allows the registration of event handlers which are called when messages are delivered' do
-      event = mock 'Event'
+      event = double 'Event'
       event.should_receive(:foo?).and_return true
-      response = mock 'Response'
+      response = double 'Response'
       response.should_receive(:call).once
       subject.register_event_handler(:foo?) { response.call }
       subject << event
     end
 
     describe "event handlers" do
-      let(:response) { mock 'Response' }
+      before { pending }
+      let(:response) { double 'Response' }
 
       describe "for joined events" do
         context "joined to another call" do
           let :event do
-            Punchblock::Event::Joined.new :call_id => 'foobar'
+            Punchblock::Event::Joined.new call_uri: 'xmpp:foobar@rayo.net'
           end
 
           it "should trigger any on_joined callbacks set for the matching call ID" do
             response.should_receive(:call).once.with(event)
-            subject.on_joined(:call_id => 'foobar') { |event| response.call event }
+            subject.on_joined(:call_uri => 'xmpp:foobar@rayo.net') { |event| response.call event }
+            subject << event
+          end
+
+          it "should trigger any on_joined callbacks set for the matching call ID as a string" do
+            response.should_receive(:call).once.with(event)
+            subject.on_joined('foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should trigger any on_joined callbacks set for the matching call" do
+            response.should_receive(:call).once.with(event)
+            call = Call.new
+            call.wrapped_object.stub id: 'foobar', domain: 'rayo.net'
+            subject.on_joined(call) { |event| response.call event }
             subject << event
           end
 
@@ -155,18 +215,32 @@ module Adhearsion
             subject.on_joined(:call_id => 'foobar') { |event| response.call event }
             subject << event
           end
+
+          it "should not trigger any on_joined callbacks set for the matching call ID as a string" do
+            response.should_receive(:call).never
+            subject.on_joined('foobar') { |event| response.call event }
+            subject << event
+          end
+
+          it "should not trigger any on_joined callbacks set for the matching call" do
+            response.should_receive(:call).never
+            call = Call.new
+            call.stub :id => 'foobar'
+            subject.on_joined(call) { |event| response.call event }
+            subject << event
+          end
         end
       end
 
       describe "for unjoined events" do
         context "unjoined from another call" do
           let :event do
-            Punchblock::Event::Unjoined.new :call_id => 'foobar'
+            Punchblock::Event::Unjoined.new call_uri: 'xmpp:foobar@rayo.net'
           end
 
           it "should trigger any on_unjoined callbacks set for the matching call ID" do
             response.should_receive(:call).once.with(event)
-            subject.on_unjoined(:call_id => 'foobar') { |event| response.call event }
+            subject.on_unjoined(:call_uri => 'xmpp:foobar@rayo.net') { |event| response.call event }
             subject << event
           end
 
@@ -179,7 +253,7 @@ module Adhearsion
           it "should trigger any on_unjoined callbacks set for the matching call" do
             response.should_receive(:call).once.with(event)
             call = Call.new
-            call.stub :id => 'foobar'
+            call.wrapped_object.stub id: 'foobar', domain: 'rayo.net'
             subject.on_unjoined(call) { |event| response.call event }
             subject << event
           end
@@ -278,11 +352,11 @@ module Adhearsion
       before { other_call.stub :id => other_call_id }
 
       let :joined_event do
-        Punchblock::Event::Joined.new :call_id => other_call_id
+        Punchblock::Event::Joined.new call_uri: other_call_id
       end
 
       let :unjoined_event do
-        Punchblock::Event::Unjoined.new :call_id => other_call_id
+        Punchblock::Event::Unjoined.new call_uri: other_call_id
       end
 
       context "when we know about the joined call" do
@@ -332,9 +406,41 @@ module Adhearsion
           subject.end_reason.should be == :hangup
         end
 
+        it "should set the end time" do
+          finish_time = Time.local(2008, 9, 1, 12, 1, 3)
+          Timecop.freeze finish_time
+          subject.end_time.should == nil
+          subject << end_event
+          subject.end_time.should == finish_time
+        end
+
+        it "should set the call duration" do
+          start_time = Time.local(2008, 9, 1, 12, 0, 0)
+          Timecop.freeze start_time
+          subject
+
+          mid_point_time = Time.local(2008, 9, 1, 12, 0, 37)
+          Timecop.freeze mid_point_time
+
+          subject.duration.should == 37.0
+
+          finish_time = Time.local(2008, 9, 1, 12, 1, 3)
+          Timecop.freeze finish_time
+
+          subject << end_event
+
+          future_time = Time.local(2008, 9, 1, 12, 2, 3)
+          Timecop.freeze finish_time
+
+          subject.duration.should == 63.0
+        end
+
         it "should instruct the command registry to terminate" do
-          subject.commands.should_receive(:terminate).once
+          command = Punchblock::Command::Answer.new
+          command.request!
+          subject.future.write_and_await_response command
           subject << end_event
+          command.response(1).should be_a Call::Hangup
         end
 
         it "removes itself from the active calls" do
@@ -357,6 +463,33 @@ module Adhearsion
       end
     end
 
+    describe "#wait_for_end" do
+      let :end_event do
+        Punchblock::Event::End.new reason: :hangup
+      end
+
+      context "when the call has already ended" do
+        before { subject << end_event }
+
+        it "should return the end reason" do
+          subject.wait_for_end.should == :hangup
+        end
+      end
+
+      context "when the call has not yet ended" do
+        it "should block until the call ends and return the end reason" do
+          fut = subject.future.wait_for_end
+
+          sleep 0.5
+          fut.should_not be_ready
+
+          subject << end_event
+
+          fut.value.should == :hangup
+        end
+      end
+    end
+
     describe "tagging a call" do
       it 'with a single Symbol' do
         lambda {
@@ -405,11 +538,11 @@ module Adhearsion
     end
 
     describe "#write_command" do
-      let(:mock_command) { mock('Command') }
+      let(:mock_command) { double('Command') }
 
       it "should asynchronously write the command to the Punchblock connection" do
         subject.wrapped_object.should_receive(:client).once.and_return mock_client
-        mock_client.should_receive(:execute_command).once.with(mock_command, :call_id => subject.id, :async => true).and_return true
+        mock_client.should_receive(:execute_command).once.with(mock_command, call_id: call_id, domain: domain, async: true).and_return true
         subject.write_command mock_command
       end
 
@@ -446,9 +579,9 @@ module Adhearsion
         subject.write_and_await_response message
       end
 
-      it "adds the command to the registry" do
+      it "removes the command from the registry after execution" do
         subject.write_and_await_response message
-        subject.commands.should_not be_empty
+        subject.commands.should be_empty
       end
 
       it "blocks until a response is received" do
@@ -463,6 +596,26 @@ module Adhearsion
         (Time.now - starting_time).should >= 0.5
       end
 
+      context "while waiting for a response" do
+        let(:slow_command) { Punchblock::Command::Dial.new }
+
+        before { slow_command.request! }
+
+        it "does not block the whole actor while waiting for a response" do
+          fut = subject.future.write_and_await_response slow_command
+          subject.id.should == call_id
+          slow_command.response = response
+          fut.value
+        end
+
+        it "adds the command to the registry" do
+          subject.future.write_and_await_response slow_command
+          sleep 0.2
+          subject.commands.should_not be_empty
+          subject.commands.first.should be slow_command
+        end
+      end
+
       describe "with a successful response" do
         it "returns the executed command" do
           subject.write_and_await_response(message).should be message
@@ -572,7 +725,7 @@ module Adhearsion
         describe "with no headers" do
           it 'should send a Reject message' do
             expect_message_waiting_for_response do |c|
-              c.is_a?(Punchblock::Command::Reject) && c.headers_hash == {}
+              c.is_a?(Punchblock::Command::Reject) && c.headers == {}
             end
             subject.reject
           end
@@ -582,7 +735,7 @@ module Adhearsion
           it 'should send a Hangup message with the correct headers' do
             headers = {:foo => 'bar'}
             expect_message_waiting_for_response do |c|
-              c.is_a?(Punchblock::Command::Reject) && c.headers_hash == headers
+              c.is_a?(Punchblock::Command::Reject) && c.headers == headers
             end
             subject.reject nil, headers
           end
@@ -640,18 +793,20 @@ module Adhearsion
 
         context "with a call" do
           let(:call_id) { rand.to_s }
+          let(:domain)  { 'rayo.net' }
+          let(:uri)     { "footransport:#{call_id}@#{domain}" }
           let(:target)  { described_class.new }
 
-          before { target.stub id: call_id }
+          before { target.wrapped_object.stub uri: uri }
 
           it "should send a join command joining to the provided call ID" do
-            expect_join_with_options :call_id => call_id
+            expect_join_with_options call_uri: uri
             subject.join target
           end
 
           context "and direction/media options" do
             it "should send a join command with the correct options" do
-              expect_join_with_options :call_id => call_id, :media => :bridge, :direction => :recv
+              expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
               subject.join target, :media => :bridge, :direction => :recv
             end
           end
@@ -661,30 +816,30 @@ module Adhearsion
           let(:target) { rand.to_s }
 
           it "should send a join command joining to the provided call ID" do
-            expect_join_with_options :call_id => target
+            expect_join_with_options call_uri: "footransport:#{target}@#{subject.domain}"
             subject.join target
           end
 
           context "and direction/media options" do
             it "should send a join command with the correct options" do
-              expect_join_with_options :call_id => target, :media => :bridge, :direction => :recv
+              expect_join_with_options :call_uri => "footransport:#{target}@#{subject.domain}", :media => :bridge, :direction => :recv
               subject.join target, :media => :bridge, :direction => :recv
             end
           end
         end
 
-        context "with a call ID as a hash key" do
+        context "with a call URI as a hash key" do
           let(:call_id) { rand.to_s }
-          let(:target)  { { :call_id => call_id } }
+          let(:target)  { { :call_uri => call_id } }
 
           it "should send a join command joining to the provided call ID" do
-            expect_join_with_options :call_id => call_id
+            expect_join_with_options :call_uri => call_id
             subject.join target
           end
 
           context "and direction/media options" do
             it "should send a join command with the correct options" do
-              expect_join_with_options :call_id => call_id, :media => :bridge, :direction => :recv
+              expect_join_with_options :call_uri => call_id, :media => :bridge, :direction => :recv
               subject.join target.merge({:media => :bridge, :direction => :recv})
             end
           end
@@ -710,10 +865,10 @@ module Adhearsion
         context "with a call ID and a mixer name as hash keys" do
           let(:call_id)     { rand.to_s }
           let(:mixer_name)  { rand.to_s }
-          let(:target)      { { :call_id => call_id, :mixer_name => mixer_name } }
+          let(:target)      { { :call_uri => call_id, :mixer_name => mixer_name } }
 
           it "should raise an ArgumentError" do
-            lambda { subject.join target }.should raise_error ArgumentError, /call ID and mixer name/
+            lambda { subject.join target }.should raise_error ArgumentError, /call URI and mixer name/
           end
         end
       end
@@ -727,12 +882,14 @@ module Adhearsion
 
         context "with a call" do
           let(:call_id) { rand.to_s }
+          let(:domain)  { 'rayo.net' }
+          let(:uri)     { "footransport:#{call_id}@#{domain}" }
           let(:target)  { described_class.new }
 
-          before { target.stub id: call_id }
+          before { target.wrapped_object.stub uri: uri }
 
           it "should send an unjoin command unjoining from the provided call ID" do
-            expect_unjoin_with_options :call_id => call_id
+            expect_unjoin_with_options call_uri: "footransport:#{call_id}@#{domain}"
             subject.unjoin target
           end
         end
@@ -741,17 +898,17 @@ module Adhearsion
           let(:target) { rand.to_s }
 
           it "should send an unjoin command unjoining from the provided call ID" do
-            expect_unjoin_with_options :call_id => target
+            expect_unjoin_with_options call_uri: "footransport:#{target}@#{subject.domain}"
             subject.unjoin target
           end
         end
 
-        context "with a call ID as a hash key" do
+        context "with a call URI as a hash key" do
           let(:call_id) { rand.to_s }
-          let(:target)  { { :call_id => call_id } }
+          let(:target)  { { call_uri: call_id } }
 
           it "should send an unjoin command unjoining from the provided call ID" do
-            expect_unjoin_with_options :call_id => call_id
+            expect_unjoin_with_options call_uri: call_id
             subject.unjoin target
           end
         end
@@ -766,13 +923,13 @@ module Adhearsion
           end
         end
 
-        context "with a call ID and a mixer name as hash keys" do
+        context "with a call URI and a mixer name as hash keys" do
           let(:call_id)     { rand.to_s }
           let(:mixer_name)  { rand.to_s }
-          let(:target)      { { :call_id => call_id, :mixer_name => mixer_name } }
+          let(:target)      { { call_uri: call_id, mixer_name: mixer_name } }
 
           it "should raise an ArgumentError" do
-            lambda { subject.unjoin target }.should raise_error ArgumentError, /call ID and mixer name/
+            lambda { subject.unjoin target }.should raise_error ArgumentError, /call URI and mixer name/
           end
         end
       end
@@ -846,8 +1003,8 @@ module Adhearsion
       end
 
       context "with two controllers registered" do
-        let(:controller1) { mock 'CallController1' }
-        let(:controller2) { mock 'CallController2' }
+        let(:controller1) { double 'CallController1' }
+        let(:controller2) { double 'CallController2' }
 
         before { subject.controllers << controller1 << controller2 }
 
@@ -869,6 +1026,14 @@ module Adhearsion
           end
         end
       end
+
+      describe "after termination" do
+        it "should delete its logger" do
+          logger = subject.logger
+          subject.terminate
+          ::Logging::Repository.instance[logger.name].should be_nil
+        end
+      end
     end
 
     describe Call::CommandRegistry do