adhearsion 2.1.3 → 2.2.0

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

@@ -10,15 +10,15 @@ module Adhearsion
         it "matching with a Range should handle the case of two potential matches in the range" do
           digits_that_begin_with_eleven = [110..119, 1100..1111].map { |x| Array(x) }.flatten
           calculator = RangeMatchCalculator.new 11..1111, :match_payload_doesnt_matter
-          match = calculator.match 11
-          match.exact_matches.should be == [11]
+          match = calculator.match '11'
+          match.exact_matches.should be == ['11']
           match.potential_matches.should be == digits_that_begin_with_eleven
         end
 
         it "return values of #match should be an instance of CalculatedMatch" do
           calculator = RangeMatchCalculator.new 1..9, :match_payload_doesnt_matter
-          calculator.match(0).should be_an_instance_of CalculatedMatch
-          calculator.match(1000).should be_an_instance_of CalculatedMatch
+          calculator.match('0').should be_an_instance_of CalculatedMatch
+          calculator.match('1000').should be_an_instance_of CalculatedMatch
         end
 
         it "returns a failed match if the query is not numeric or coercible to numeric" do

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

@@ -14,13 +14,13 @@ module Adhearsion
             calculator = StringMatchCalculator.new str, match_payload
 
             match_case = calculator.match str[0,2]
-            match_case.exact_match?.should_not be true
-            match_case.potential_match?.should be true
+            match_case.should_not be_exact_match
+            match_case.should be_potential_match
             match_case.potential_matches.should be == [str]
 
             match_case = calculator.match str
-            match_case.exact_match?.should be true
-            match_case.potential_match?.should_not be true
+            match_case.should be_exact_match
+            match_case.should_not be_potential_match
             match_case.exact_matches.should be == [str]
           end
         end
@@ -29,9 +29,9 @@ module Adhearsion
           %w[* #].each do |special_digit|
             calculator = StringMatchCalculator.new(special_digit, match_payload)
             match_case = calculator.match special_digit
-            match_case.potential_match?.should_not be true
-            match_case.exact_match?.should be true
             match_case.exact_matches.first.should be == special_digit
+            match_case.should be_exact_match
+            match_case.should_not be_potential_match
           end
         end
       end

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

@@ -6,9 +6,7 @@ module Adhearsion
   class CallController
     module Output
       describe Formatter do
-        subject { Formatter }
-
-        describe ".ssml_for" do
+        describe "#ssml_for" do
           let(:prompt) { "Please stand by" }
 
           let(:ssml) do
@@ -24,7 +22,7 @@ module Adhearsion
           end
         end
 
-        describe ".ssml_for_collection" do
+        describe "#ssml_for_collection" do
           let(:collection) { ["/foo/bar.wav", 1, Time.now] }
           let :ssml do
             file = collection[0]
@@ -42,7 +40,7 @@ module Adhearsion
           end
         end
 
-        describe ".detect_type" do
+        describe "#detect_type" do
           it "detects an HTTP path" do
             http_path = "http://adhearsion.com/sounds/hello.mp3"
             subject.detect_type(http_path).should be :audio

data/spec/adhearsion/call_controller/output_spec.rb

@@ -7,12 +7,12 @@ module Adhearsion
     describe Output do
       include CallControllerTestHelpers
 
-      def expect_ssml_output(ssml)
-        expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
+      def expect_ssml_output(ssml, options = {})
+        expect_component_execution Punchblock::Component::Output.new(options.merge(:ssml => ssml))
       end
 
-      def expect_async_ssml_output(ssml)
-        expect_message_waiting_for_response Punchblock::Component::Output.new(:ssml => ssml)
+      def expect_async_ssml_output(ssml, options = {})
+        expect_message_waiting_for_response Punchblock::Component::Output.new(options.merge(:ssml => ssml))
       end
 
       describe "#player" do
@@ -350,6 +350,25 @@ module Adhearsion
           end
         end
 
+        describe "with a collection of arguments" do
+          let(:args) { ["/foo/bar.wav", 1, Time.now] }
+          let :ssml do
+            file = args[0]
+            n = args[1].to_s
+            t = args[2].to_s
+            RubySpeech::SSML.draw do
+              audio :src => file
+              say_as(:interpret_as => 'cardinal') { n }
+              say_as(:interpret_as => 'time') { t }
+            end
+          end
+
+          it 'plays all arguments in one document' do
+            expect_ssml_output ssml
+            subject.play(args).should be true
+          end
+        end
+
         describe "with a number" do
           let(:argument) { 123 }
 
@@ -413,7 +432,7 @@ module Adhearsion
           end
         end
 
-        describe "with an array containing a Date/DateTime/Time object and a hash" do
+        describe "with an hash containing a Date/DateTime/Time object and format options" do
           let(:date)      { Date.parse '2011-01-23' }
           let(:format)    { "d-m-y" }
           let(:strftime)  { "%d-%m%Y" }
@@ -619,42 +638,31 @@ module Adhearsion
                                            :grammar => { :value => grammar.to_s }
         }
 
+        def expect_component_complete_event
+          complete_event = Punchblock::Event::Complete.new
+          flexmock(complete_event).should_receive(:reason => flexmock(:utterance => 'dtmf-5'))
+          flexmock(Punchblock::Component::Input).new_instances do |input|
+            input.should_receive(:complete?).and_return(false)
+            input.should_receive(:complete_event).and_return(complete_event)
+          end
+        end
+
         #test does pass and method works, but not sure if the empty method is a good idea
         it "plays the correct output" do
           def controller.write_and_await_response(input_component)
             # it is actually a no-op here
           end
 
-          def expect_component_complete_event
-            complete_event = Punchblock::Event::Complete.new
-            flexmock(complete_event).should_receive(:reason => flexmock(:interpretation => 'dtmf-5', :name => :input))
-            flexmock(Punchblock::Component::Input).new_instances do |input|
-              input.should_receive(:complete?).and_return(false)
-              input.should_receive(:complete_event).and_return(complete_event)
-            end
-          end
-
           expect_component_complete_event
           expect_component_execution Punchblock::Component::Output.new(:ssml => ssml.to_s)
           subject.stream_file prompt, allowed_digits
         end
 
         it "returns a single digit amongst the allowed when pressed" do
-          flexmock(Punchblock::Event::Complete).new_instances.should_receive(:reason => flexmock(:interpretation => 'dtmf-5', :name => :input))
-
           def controller.write_and_await_response(input_component)
             input_component.trigger_event_handler Punchblock::Event::Complete.new
           end
 
-          def expect_component_complete_event
-            complete_event = Punchblock::Event::Complete.new
-            flexmock(complete_event).should_receive(:reason => flexmock(:interpretation => 'dtmf-5', :name => :input))
-            flexmock(Punchblock::Component::Input).new_instances do |input|
-              input.should_receive(:complete?).and_return(false)
-              input.should_receive(:complete_event).and_return(complete_event)
-            end
-          end
-
           expect_component_complete_event
           flexmock(Punchblock::Component::Output).new_instances.should_receive(:stop!)
           expect_component_execution output_component
@@ -680,6 +688,19 @@ module Adhearsion
           end
         end
 
+        describe "with a default voice set" do
+          before { Adhearsion.config.punchblock.default_voice = 'foo' }
+
+          it 'sets the voice on the output component' do
+            str = "Hello world"
+            ssml = RubySpeech::SSML.draw { string str }
+            expect_ssml_output ssml, voice: 'foo'
+            subject.say(str)
+          end
+
+          after { Adhearsion.config.punchblock.default_voice = nil }
+        end
+
         describe "converts the argument to a string" do
           it 'calls output with a string' do
             argument = 123
@@ -714,6 +735,19 @@ module Adhearsion
           end
         end
 
+        describe "with a default voice set" do
+          before { Adhearsion.config.punchblock.default_voice = 'foo' }
+
+          it 'sets the voice on the output component' do
+            str = "Hello world"
+            ssml = RubySpeech::SSML.draw { string str }
+            expect_async_ssml_output ssml, voice: 'foo'
+            subject.say!(str)
+          end
+
+          after { Adhearsion.config.punchblock.default_voice = nil }
+        end
+
         describe "converts the argument to a string" do
           it 'calls output with a string' do
             argument = 123

data/spec/adhearsion/call_controller/record_spec.rb

@@ -7,8 +7,129 @@ module Adhearsion
     describe Record do
       include CallControllerTestHelpers
 
+      describe Recorder do
+        let(:interruptible)     { false }
+        let(:async)             { false }
+        let(:component_options) { { :start_beep => true } }
+        let :options do
+          component_options.merge :interruptible => interruptible,
+            :async => async
+        end
+
+        let(:component) { Punchblock::Component::Record.new component_options }
+        let :stopper_grammar do
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              one_of do
+                item { '0' }
+                item { '1' }
+                item { '2' }
+                item { '3' }
+                item { '4' }
+                item { '5' }
+                item { '6' }
+                item { '7' }
+                item { '8' }
+                item { '9' }
+                item { '#' }
+                item { '*' }
+              end
+            end
+          end
+        end
+        let(:input_component) { Punchblock::Component::Input.new mode: :dtmf, grammar: { :value => stopper_grammar } }
+
+        subject { Recorder.new controller, options }
+
+        its(:record_component) { should == component }
+
+        context "when passing time related options" do
+          let :component_options do
+            { :max_duration => 5.5, :initial_timeout => 6.5, :final_timeout => 3.2 }
+          end
+
+          let :component do
+            Punchblock::Component::Record.new :max_duration => 5500,
+              :initial_timeout => 6500,
+              :final_timeout => 3200
+          end
+
+          it "takes seconds but sets milliseconds on the command" do
+            subject.record_component.should == component
+          end
+        end
+
+        describe "#run" do
+          context "with :async => false" do
+            it "executes the component synchronously" do
+              expect_component_execution subject.record_component
+              subject.run
+            end
+          end
+
+          context "with :async => true" do
+            let(:async) { true }
+
+            it "executes the component asynchronously" do
+              expect_message_waiting_for_response subject.record_component
+              subject.run
+            end
+          end
+
+          context "with :interruptible => false" do
+            its(:stopper_component) { should be_nil }
+
+            it "does not use an Input component" do
+              controller.should_receive(:execute_component_and_await_completion).once.with(component)
+              controller.should_receive(:write_and_await_response).never.with(input_component)
+              subject.run
+            end
+          end
+
+          context "with :interruptible => true" do
+            let(:interruptible) { true }
+
+            its(:stopper_component) { should == input_component }
+
+            describe "when the input component completes" do
+              let(:complete_event) { Punchblock::Event::Complete.new }
+
+              before do
+                subject.stopper_component.request!
+                subject.stopper_component.execute!
+              end
+
+              it "stops the recording" do
+                flexmock(subject.record_component).should_receive(:stop!).once
+                subject.stopper_component.trigger_event_handler complete_event
+              end
+            end
+
+            describe "when the recording completes" do
+              it "stops the input component" do
+                controller.should_receive(:execute_component_and_await_completion).once.with(component)
+                controller.should_receive(:write_and_await_response).once.with(input_component)
+                flexmock(subject.stopper_component).should_receive(:stop!).once
+                subject.run
+              end
+            end
+          end
+        end
+
+        describe "setting completion handlers" do
+          let(:complete_event) { Punchblock::Event::Complete.new }
+
+          it "should execute those handlers when recording completes" do
+            foo = flexmock 'foo'
+            foo.should_receive(:call).once.with Punchblock::Event::Complete
+            subject.handle_record_completion { |e| foo.call e }
+            subject.record_component.trigger_event_handler complete_event
+          end
+        end
+      end
+
       describe "#record" do
-        let(:max_duration) { 5 }
+        let(:max_duration) { 5.5 }
         let(:options) do
           {
             :start_beep => true,
@@ -104,7 +225,7 @@ module Adhearsion
             complete_event = Punchblock::Event::Complete.new
             flexmock(complete_event).should_receive(:reason => flexmock(:name => :input))
             flexmock(Punchblock::Component::Input).new_instances do |input|
-              input.should_receive(:complete?).and_return(false)
+              input.should_receive(:complete?).and_return(true)
               input.should_receive(:complete_event).and_return(complete_event)
             end
             flexmock(Punchblock::Component::Record).new_instances.should_receive(:stop!)

data/spec/adhearsion/call_controller/utility_spec.rb

@@ -47,21 +47,41 @@ module Adhearsion
         end
       end # grammar_accept
 
-      describe "#parse_single_dtmf"  do
-        it "correctly returns the parsed input" do
-          subject.parse_single_dtmf("dtmf-3").should be == '3'
-        end
+      describe "#parse_dtmf" do
+        context "with a single digit" do
+          it "correctly returns the parsed input" do
+            subject.parse_dtmf("dtmf-3").should be == '3'
+          end
 
-        it "correctly returns star as *" do
-          subject.parse_single_dtmf("dtmf-star").should be == '*'
-        end
+          it "correctly returns star as *" do
+            subject.parse_dtmf("dtmf-star").should be == '*'
+          end
+
+          it "correctly returns * as *" do
+            subject.parse_dtmf("*").should be == '*'
+          end
+
+          it "correctly returns pound as #" do
+            subject.parse_dtmf("dtmf-pound").should be == '#'
+          end
+
+          it "correctly returns # as #" do
+            subject.parse_dtmf("#").should be == '#'
+          end
 
-        it "correctly returns pound as #" do
-          subject.parse_single_dtmf("dtmf-pound").should be == '#'
+          it "correctly parses digits without the dtmf- prefix" do
+            subject.parse_dtmf('1').should be == '1'
+          end
+
+          it "correctly returns nil when input is nil" do
+            subject.parse_dtmf(nil).should be == nil
+          end
         end
 
-        it "correctly returns nil when input is nil" do
-          subject.parse_single_dtmf(nil).should be == nil
+        context "with multiple digits separated by spaces" do
+          it "returns the digits without space separation" do
+            subject.parse_dtmf('1 dtmf-5 dtmf-star # 2').should be == '15*#2'
+          end
         end
       end # describe #grammar_accept
     end

data/spec/adhearsion/call_spec.rb

@@ -43,47 +43,45 @@ module Adhearsion
     its(:id)      { should be == call_id }
     its(:to)      { should be == to }
     its(:from)    { should be == from }
-    its(:offer)   { should be offer }
-    its(:client)  { should be mock_client }
-
-    its(:after_end_hold_time) { should be == 30 }
 
     describe "its variables" do
-      context "with an offer with headers" do
-        let(:headers)   { {:x_foo => 'bar'} }
-        its(:variables) { should be == headers }
+      context "with an offer" do
+        context "with headers" do
+          let(:headers)   { {:x_foo => 'bar'} }
+          its(:variables) { should be == headers }
 
-        it "should be made available via []" do
-          subject[:x_foo].should be == 'bar'
-        end
+          it "should be made available via []" do
+            subject[:x_foo].should be == 'bar'
+          end
 
-        it "should be alterable using []=" do
-          subject[:x_foo] = 'baz'
-          subject[:x_foo].should be == 'baz'
-        end
+          it "should be alterable using []=" do
+            subject[:x_foo] = 'baz'
+            subject[:x_foo].should be == 'baz'
+          end
 
-        context "when receiving an event with headers" do
-          let(:event) { Punchblock::Event::End.new :headers => {:x_bar => 'foo'} }
+          context "when receiving an event with headers" 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'}
+            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'} }
+          context "when sending a command with headers" do
+            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'}
+            it "should merge later headers" do
+              subject.write_command command
+              subject.variables.should be == {:x_foo => 'bar', :x_bar => 'foo'}
+            end
           end
         end
-      end
 
-      context "with an offer without headers" do
-        let(:headers)   { nil }
-        its(:variables) { should be == {} }
+        context "without headers" do
+          let(:headers)   { nil }
+          its(:variables) { should be == {} }
+        end
       end
 
       context "without an offer" do
@@ -273,6 +271,49 @@ module Adhearsion
       end
     end
 
+    context "peer registry" do
+      let(:other_call_id) { 'foobar' }
+      let(:other_call) { flexmock Call.new, :id => other_call_id }
+
+      let :joined_event do
+        Punchblock::Event::Joined.new :call_id => other_call_id
+      end
+
+      let :unjoined_event do
+        Punchblock::Event::Unjoined.new :call_id => other_call_id
+      end
+
+      context "when we know about the joined call" do
+        before { Adhearsion.active_calls << other_call }
+
+        it "should add the peer to its registry" do
+          subject << joined_event
+          subject.peers.should == {'foobar' => other_call}
+        end
+      end
+
+      context "when we don't know about the joined call" do
+        it "should add a nil entry to its registry" do
+          subject << joined_event
+          subject.peers.should == {'foobar' => nil}
+        end
+      end
+
+      it "should not return the same registry every call" do
+        subject.peers.should_not be subject.peers
+      end
+
+      context "when being unjoined from a previously joined call" do
+        before { subject << joined_event }
+
+        it "should remove the peer from its registry" do
+          subject.peers.should_not eql({})
+          subject << unjoined_event
+          subject.peers.should eql({})
+        end
+      end
+    end
+
     describe "#<<" do
       describe "with a Punchblock End" do
         let :end_event do
@@ -307,7 +348,7 @@ module Adhearsion
         end
 
         it "shuts down the actor" do
-          flexmock subject.wrapped_object, :after_end_hold_time => 2
+          Adhearsion.config.platform.after_hangup_lifetime = 2
           subject << end_event
           sleep 2.1
           subject.should_not be_alive
@@ -539,6 +580,12 @@ module Adhearsion
             subject.reject nil, headers
           end
         end
+
+        it "should immediately fire the :call_rejected event giving the call and the reason" do
+          expect_message_waiting_for_response Punchblock::Command::Reject
+          flexmock(Adhearsion::Events).should_receive(:trigger_immediately).once.with(:call_rejected, :call => subject, :reason => :decline)
+          subject.reject :decline
+        end
       end
 
       describe "#hangup" do
@@ -760,12 +807,6 @@ module Adhearsion
           lambda { subject.execute_controller(mock_controller) { foo } }.should raise_error(ArgumentError)
         end
 
-        it "should add the controller thread to the important threads" do
-          flexmock(CallController).should_receive(:exec)
-          controller_thread = subject.execute_controller mock_controller, lambda { |call| latch.countdown! }
-          Adhearsion::Process.important_threads.should include controller_thread
-        end
-
         it "should pass the exception to the events system" do
           latch = CountDownLatch.new 1
           Adhearsion::Events.exception do |e, l|