adhearsion 2.0.0.beta1 → 2.0.0.rc1

data/spec/adhearsion/call_controller/record_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
@@ -12,111 +14,61 @@ module Adhearsion
             :max_duration => 5000
           }
         end
-        let(:component) { Punchblock::Component::Record.new options }
-        let(:response)  { Punchblock::Event::Complete.new }
+        let(:component) { ::Punchblock::Component::Record.new options }
+        let(:response)  { ::Punchblock::Event::Complete.new }
 
         describe "with :async => true and an :on_complete callback" do
-          let(:callback) { lambda { |rec| @rec.push rec } }
-
           before do
-            expect_component_execution_asynchronously component
+            component
+            flexmock(::Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
+            expect_message_waiting_for_response component
             @rec = Queue.new
-            options.merge! :async => true, :on_complete => callback
-            subject.record options
-            component.request!
+            subject.record(options.merge(async: true)) { |rec| @rec.push rec }
             component.execute!
           end
 
           it "should execute the callback" do
             component.trigger_event_handler response
             Timeout::timeout 5 do
-              @rec.pop.should == response
+              @rec.pop.should be response
             end
           end
+        end
 
-          describe "when the callback raises an exception" do
-            before { TestException = Class.new StandardError }
-            let(:callback) { lambda { |rec| raise TestException } }
+        describe "when the callback raises an exception" do
+          before do
+            TestException = Class.new StandardError
+            component
+            flexmock(::Punchblock::Component::Record).should_receive(:new).once.with({}).and_return component
+          end
 
-            it "should pass the exception to the events system" do
-              flexmock(Events).should_receive(:trigger).once.with(:exception, TestException)
-              component.trigger_event_handler response
-            end
+          it "should pass the exception to the events system" do
+            flexmock(Events).should_receive(:trigger).once.with(:exception, TestException)
+            expect_component_execution component
+            subject.record { |rec| raise TestException }
+            component.request!
+            component.execute!
+            component.trigger_event_handler response
           end
         end
 
         describe "with :async => false" do
           before do
+            component
+            flexmock(::Punchblock::Component::Record).should_receive(:new).once.with(options).and_return component
             expect_component_execution component
-            component.request!
-            component.execute!
-            component.add_event response
             @rec = Queue.new
             subject.record(options.merge(:async => false)) { |rec| @rec.push rec }
+            component.request!
+            component.execute!
           end
 
           it 'should execute a passed block' do
+            component.trigger_event_handler response
             Timeout::timeout 5 do
-              @rec.pop.should == response
-            end
-          end
-        end
-      end
-
-      describe "#record with default options" do
-        let(:options) {{
-          :start_beep => true,
-          :format => 'mp3',
-          :start_paused => false,
-          :stop_beep => true,
-          :max_duration => 500000,
-          :initial_timeout => 10000,
-          :final_timeout => 30000
-        }}
-
-        let(:component) { Punchblock::Component::Record.new(options) }
-        let(:response) { Punchblock::Event::Complete.new }
-
-        before do
-          expect_message_waiting_for_response component
-          component.execute!
-          component.complete_event = response
-        end
-
-        it 'executes a #record with the correct options' do
-          subject.execute_component_and_await_completion component
-        end
-
-        it 'takes a block which is executed after acknowledgement but before waiting on completion' do
-          @comp = nil
-          subject.execute_component_and_await_completion(component) { |comp| @comp = comp }.should == component
-          @comp.should == component
-        end
-
-        describe "with a successful completion" do
-          it 'returns the executed component' do
-            subject.execute_component_and_await_completion(component).should be component
-          end
-        end
-
-        describe 'with an error response' do
-          let(:response) do
-            Punchblock::Event::Complete.new.tap do |complete|
-              complete << error
+              @rec.pop.should be == response
             end
           end
-
-          let(:error) do |error|
-            Punchblock::Event::Complete::Error.new.tap do |error|
-              error << details
-            end
-          end
-
-          let(:details) { "Something came up" }
-
-          it 'raises the error' do
-            lambda { subject.execute_component_and_await_completion component }.should raise_error(StandardError, details)
-          end
         end
       end
 

data/spec/adhearsion/call_controller/utility_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    describe Utility do
+      include CallControllerTestHelpers
+
+      describe "#grammar_digits" do
+        let(:grxml) {
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              item repeat: '2' do
+                one_of do
+                  0.upto(9) { |d| item { d.to_s } }
+                end
+              end
+            end
+          end
+        }
+
+        it 'generates the correct GRXML grammar' do
+          subject.grammar_digits(2).to_s.should be == grxml.to_s
+        end
+
+      end # describe #grammar_digits
+
+      describe "#grammar_accept" do
+        let(:grxml) {
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              one_of do
+                item { '3' }
+                item { '5' }
+              end
+            end
+          end
+        }
+
+        it 'generates the correct GRXML grammar' do
+          subject.grammar_accept('35').to_s.should be == grxml.to_s
+        end
+
+        it 'filters meaningless characters out' do
+          subject.grammar_accept('3+5').to_s.should be == grxml.to_s
+        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
+
+        it "correctly returns star as *" do
+          subject.parse_single_dtmf("dtmf-star").should be == '*'
+        end
+
+        it "correctly returns pound as #" do
+          subject.parse_single_dtmf("dtmf-pound").should be == '#'
+        end
+
+        it "correctly returns nil when input is nil" do
+          subject.parse_single_dtmf(nil).should be == nil
+        end
+      end # describe #grammar_accept
+    end
+  end
+end

data/spec/adhearsion/call_controller_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 class FinancialWizard < Adhearsion::CallController
@@ -10,16 +12,16 @@ module Adhearsion
     let(:call) { Adhearsion::Call.new mock_offer(nil, :x_foo => 'bar') }
 
     its(:call)      { should be call }
-    its(:metadata)  { should == {:doo => :dah} }
+    its(:metadata)  { should be == {:doo => :dah} }
 
     describe "setting meta-data" do
       it "should preserve data correctly" do
         subject[:foo].should be nil
         subject[:foo] = 7
-        subject[:foo].should == 7
+        subject[:foo].should be == 7
         subject[:bar] = 10
-        subject[:bar].should == 10
-        subject[:foo].should == 7
+        subject[:bar].should be == 10
+        subject[:foo].should be == 7
       end
     end
 
@@ -33,15 +35,23 @@ module Adhearsion
       end
 
       it "catches Hangup exceptions and logs the hangup" do
-        subject.should_receive(:run).once.and_raise(Hangup).ordered
+        subject.should_receive(:run).once.and_raise(Call::Hangup).ordered
         flexmock(subject.logger).should_receive(:info).once.with(/Call was hung up/).ordered
         subject.execute!
       end
 
       it "catches standard errors, triggering an exception event" do
         subject.should_receive(:run).once.and_raise(StandardError).ordered
-        flexmock(Events).should_receive(:trigger).once.with(:exception, StandardError).ordered
+        latch = CountDownLatch.new 1
+        ex = lo = nil
+        Events.exception do |e, l|
+          ex, lo = e, l
+          latch.countdown!
+        end
         subject.execute!
+        latch.wait(1).should be true
+        ex.should be_a StandardError
+        lo.should be subject.logger
       end
 
       context "when a block is specified" do
@@ -76,7 +86,7 @@ module Adhearsion
       end
 
       def simulate_remote_hangup
-        raise Hangup
+        raise Call::Hangup
       end
     end
 
@@ -193,8 +203,7 @@ module Adhearsion
       :reject,
       :hangup,
       :mute,
-      :unmute,
-      :join].each do |method_name|
+      :unmute].each do |method_name|
       describe "##{method_name}" do
         it "delegates to the call, blocking first until it is allowed to execute" do
           flexmock(subject).should_receive(:block_until_resumed).once.ordered
@@ -204,6 +213,70 @@ module Adhearsion
       end
     end
 
+    describe "#join" do
+      it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
+        flexmock(subject).should_receive(:block_until_resumed).once.ordered
+        flexmock(subject.call).should_receive(:join).once.with('call1', :foo => :bar).ordered.and_return Punchblock::Command::Join.new(:other_call_id => 'call1')
+        latch = CountDownLatch.new 1
+        Thread.new do
+          subject.join 'call1', :foo => :bar
+          latch.countdown!
+        end
+        latch.wait(1).should be false
+        subject.call << Punchblock::Event::Joined.new(:other_call_id => 'call1')
+        latch.wait(1).should be false
+        subject.call << Punchblock::Event::Unjoined.new(:other_call_id => 'call1')
+        latch.wait(1).should be true
+      end
+
+      context "with a mixer" do
+        it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
+          flexmock(subject).should_receive(:block_until_resumed).once.ordered
+          flexmock(subject.call).should_receive(:join).once.with({:mixer_name => 'foobar', :foo => :bar}, {}).ordered.and_return Punchblock::Command::Join.new(:mixer_name => 'foobar')
+          latch = CountDownLatch.new 1
+          Thread.new do
+            subject.join :mixer_name => 'foobar', :foo => :bar
+            latch.countdown!
+          end
+          latch.wait(1).should be false
+          subject.call << Punchblock::Event::Joined.new(:mixer_name => 'foobar')
+          latch.wait(1).should be false
+          subject.call << Punchblock::Event::Unjoined.new(:mixer_name => 'foobar')
+          latch.wait(1).should be true
+        end
+      end
+
+      context "with :async => true" do
+        it "delegates to the call, blocking first until it is allowed to execute, and unblocking when the joined event is received" do
+          flexmock(subject).should_receive(:block_until_resumed).once.ordered
+          flexmock(subject.call).should_receive(:join).once.with('call1', :foo => :bar).ordered.and_return Punchblock::Command::Join.new(:other_call_id => 'call1')
+          latch = CountDownLatch.new 1
+          Thread.new do
+            subject.join 'call1', :foo => :bar, :async => true
+            latch.countdown!
+          end
+          latch.wait(1).should be false
+          subject.call << Punchblock::Event::Joined.new(:other_call_id => 'call1')
+          latch.wait(1).should be true
+        end
+
+        context "with a mixer" do
+          it "delegates to the call, blocking first until it is allowed to execute, and unblocking when the joined event is received" do
+            flexmock(subject).should_receive(:block_until_resumed).once.ordered
+            flexmock(subject.call).should_receive(:join).once.with({:mixer_name => 'foobar', :foo => :bar}, {}).ordered.and_return Punchblock::Command::Join.new(:mixer_name => 'foobar')
+            latch = CountDownLatch.new 1
+            Thread.new do
+              subject.join :mixer_name => 'foobar', :foo => :bar, :async => true
+              latch.countdown!
+            end
+            latch.wait(1).should be false
+            subject.call << Punchblock::Event::Joined.new(:mixer_name => 'foobar')
+            latch.wait(1).should be true
+          end
+        end
+      end
+    end
+
     describe "#block_until_resumed" do
       context "when the controller has not been paused" do
         it "should not block" do
@@ -221,7 +294,7 @@ module Adhearsion
         it "should unblock when the controller is unpaused" do
           t1 = t2 = nil
           latch = CountDownLatch.new 1
-          t = Thread.new do
+          Thread.new do
             t1 = Time.now
             subject.block_until_resumed
             t2 = Time.now
@@ -255,8 +328,8 @@ module Adhearsion
 
       it "takes a block which is executed after acknowledgement but before waiting on completion" do
         @comp = nil
-        subject.execute_component_and_await_completion(component) { |comp| @comp = comp }.should == component
-        @comp.should == component
+        subject.execute_component_and_await_completion(component) { |comp| @comp = comp }.should be == component
+        @comp.should be == component
       end
 
       describe "with a successful completion" do
@@ -273,20 +346,22 @@ module Adhearsion
         end
 
         let(:error) do |error|
-          Punchblock::Event::Complete::Error.new.tap do |error|
-            error << details
+          Punchblock::Event::Complete::Error.new.tap do |e|
+            e << details
           end
         end
 
         let(:details) { "Oh noes, it's all borked" }
 
         it "raises the error" do
-          lambda { subject.execute_component_and_await_completion component }.should raise_error(StandardError, details)
+          lambda { subject.execute_component_and_await_completion component }.should raise_error(StandardError, "#{details}: #{component}")
         end
       end
 
       it "blocks until the component receives a complete event" do
         slow_component = Punchblock::Component::Output.new
+        slow_component.request!
+        slow_component.execute!
         Thread.new do
           sleep 0.5
           slow_component.complete_event = response

data/spec/adhearsion/call_spec.rb

@@ -1,8 +1,10 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
   describe Call do
-    let(:mock_client) { flexmock('Client').tap &:should_ignore_missing }
+    let(:mock_client) { flexmock('Client').tap(&:should_ignore_missing) }
 
     let(:call_id) { rand }
     let(:headers) { nil }
@@ -27,32 +29,31 @@ module Adhearsion
 
     it { should respond_to :<< }
 
-    its(:end_reason) { should == nil }
+    its(:end_reason) { should be == nil }
     it { should be_active }
 
-    its(:commands) { should be_a Call::CommandRegistry }
     its(:commands) { should be_empty }
 
-    its(:id)      { should == call_id }
-    its(:to)      { should == to }
-    its(:from)    { should == from }
+    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 == 30 }
+    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 == headers }
+        its(:variables) { should be == headers }
 
         it "should be made available via []" do
-          subject[:x_foo].should == 'bar'
+          subject[:x_foo].should be == 'bar'
         end
 
         it "should be alterable using []=" do
           subject[:x_foo] = 'baz'
-          subject[:x_foo].should == 'baz'
+          subject[:x_foo].should be == 'baz'
         end
 
         context "when receiving an event with headers" do
@@ -60,7 +61,7 @@ module Adhearsion
 
           it "should merge later headers" do
             subject << event
-            subject.variables.should == {:x_foo => 'bar', :x_bar => 'foo'}
+            subject.variables.should be == {:x_foo => 'bar', :x_bar => 'foo'}
           end
         end
 
@@ -69,19 +70,19 @@ module Adhearsion
 
           it "should merge later headers" do
             subject.write_command command
-            subject.variables.should == {:x_foo => 'bar', :x_bar => 'foo'}
+            subject.variables.should be == {:x_foo => 'bar', :x_bar => 'foo'}
           end
         end
       end
 
       context "with an offer without headers" do
         let(:headers)   { nil }
-        its(:variables) { should == {} }
+        its(:variables) { should be == {} }
       end
 
       context "without an offer" do
         let(:offer)     { nil }
-        its(:variables) { should == {} }
+        its(:variables) { should be == {} }
       end
     end
 
@@ -133,7 +134,7 @@ module Adhearsion
 
         it "should set the end reason" do
           subject << end_event
-          subject.end_reason.should == :hangup
+          subject.end_reason.should be == :hangup
         end
 
         it "should instruct the command registry to terminate" do
@@ -145,10 +146,10 @@ module Adhearsion
           size_before = Adhearsion.active_calls.size
 
           Adhearsion.active_calls << subject
-          Adhearsion.active_calls.size.should > size_before
+          Adhearsion.active_calls.size.should be > size_before
 
           subject << end_event
-          Adhearsion.active_calls.size.should == size_before
+          Adhearsion.active_calls.size.should be == size_before
         end
 
         it "shuts down the actor" do
@@ -190,7 +191,7 @@ module Adhearsion
       subject.tag :female
       subject.remove_tag :female
       subject.tag :male
-      subject.tags.should == [:moderator, :male]
+      subject.tags.should be == [:moderator, :male]
     end
 
     describe "#tagged_with?" do
@@ -214,7 +215,7 @@ module Adhearsion
       it "should asynchronously write the command to the Punchblock connection" do
         mock_client = flexmock('Client')
         flexmock(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).and_return true
+        mock_client.should_receive(:execute_command).once.with(mock_command, :call_id => subject.id, :async => true).and_return true
         subject.write_command mock_command
       end
 
@@ -224,7 +225,7 @@ module Adhearsion
         end
 
         it "should raise a Hangup exception" do
-          lambda { subject.write_command mock_command }.should raise_error(Hangup)
+          lambda { subject.write_command mock_command }.should raise_error(Call::Hangup)
         end
 
         describe "if the command is a Hangup" do
@@ -258,6 +259,7 @@ module Adhearsion
 
       it "blocks until a response is received" do
         slow_command = Punchblock::Command::Dial.new
+        slow_command.request!
         Thread.new do
           sleep 0.5
           slow_command.response = response
@@ -274,13 +276,22 @@ module Adhearsion
       end
 
       describe "with an error response" do
-        let(:new_exception) { Class.new Exception }
+        let(:new_exception) { Punchblock::ProtocolError }
         let(:response) { new_exception.new }
 
         it "raises the error" do
           flexmock(Events).should_receive(:trigger).never
           lambda { subject.write_and_await_response message }.should raise_error new_exception
         end
+
+        context "where the name is :item_not_found" do
+          let(:response) { new_exception.new :item_not_found }
+
+          it "should raise a Hangup exception" do
+            flexmock(Events).should_receive(:trigger).never
+            lambda { subject.write_and_await_response message }.should raise_error Call::Hangup
+          end
+        end
       end
 
       describe "when the response times out" do
@@ -289,7 +300,7 @@ module Adhearsion
         end
 
         it "should raise the error in the caller but not crash the actor" do
-          lambda { subject.write_and_await_response message }.should raise_error Timeout::Error
+          lambda { subject.write_and_await_response message }.should raise_error Call::CommandTimeout, message.to_s
           sleep 0.5
           subject.should be_alive
         end
@@ -497,6 +508,63 @@ module Adhearsion
         end
       end
 
+      describe "#unjoin" do
+        def expect_unjoin_with_options(options = {})
+          Punchblock::Command::Unjoin.new(options).tap do |unjoin|
+            expect_message_waiting_for_response unjoin
+          end
+        end
+
+        context "with a call" do
+          let(:call_id) { rand.to_s }
+          let(:target)  { flexmock Call.new, :id => call_id }
+
+          it "should send an unjoin command unjoining from the provided call ID" do
+            expect_unjoin_with_options :other_call_id => call_id
+            subject.unjoin target
+          end
+        end
+
+        context "with a call ID" do
+          let(:target) { rand.to_s }
+
+          it "should send an unjoin command unjoining from the provided call ID" do
+            expect_unjoin_with_options :other_call_id => target
+            subject.unjoin target
+          end
+        end
+
+        context "with a call ID as a hash key" do
+          let(:call_id) { rand.to_s }
+          let(:target)  { { :call_id => call_id } }
+
+          it "should send an unjoin command unjoining from the provided call ID" do
+            expect_unjoin_with_options :other_call_id => call_id
+            subject.unjoin target
+          end
+        end
+
+        context "with a mixer name as a hash key" do
+          let(:mixer_name)  { rand.to_s }
+          let(:target)      { { :mixer_name => mixer_name } }
+
+          it "should send an unjoin command unjoining from the provided call ID" do
+            expect_unjoin_with_options :mixer_name => mixer_name
+            subject.unjoin target
+          end
+        end
+
+        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 } }
+
+          it "should raise an ArgumentError" do
+            lambda { subject.unjoin target }.should raise_error ArgumentError, /call ID and mixer name/
+          end
+        end
+      end
+
       describe "#mute" do
         it 'should send a Mute message' do
           expect_message_waiting_for_response Punchblock::Command::Mute.new
@@ -612,9 +680,9 @@ module Adhearsion
           end
           subject.terminate
           commands.each do |command|
-            command.response.should be_a Hangup
+            command.response.should be_a Call::Hangup
           end
-          finished_command.response.should == :foo
+          finished_command.response.should be == :foo
         end
       end
     end