punchblock 1.9.4 → 2.0.0.beta1

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

@@ -11,7 +11,7 @@ module Punchblock
 
           let(:id)          { Punchblock.new_uuid }
           let(:translator)  { Punchblock::Translator::Freeswitch.new connection }
-          let(:mock_stream) { mock('RubyFS::Stream') }
+          let(:mock_stream) { double('RubyFS::Stream') }
           let(:mock_call)   { Punchblock::Translator::Freeswitch::Call.new id, translator, nil, mock_stream }
 
           let :original_command do
@@ -48,7 +48,7 @@ module Punchblock
               subject.execute
             end
 
-            it "sends a success complete event when the recording ends" do
+            it "sends a maxduration complete event when the recording ends" do
               full_filename = "file://#{filename}"
               subject.execute
               record_stop_event = RubyFS::Event.new nil, {
@@ -56,7 +56,7 @@ module Punchblock
                 :record_file_path => filename
               }
               mock_call.handle_es_event record_stop_event
-              reason.should be_a Punchblock::Component::Record::Complete::Success
+              reason.should be_a Punchblock::Component::Record::Complete::MaxDuration
               recording.uri.should be == full_filename
               original_command.should be_complete
             end
@@ -94,8 +94,9 @@ module Punchblock
             describe 'initial_timeout' do
               context "set to nil" do
                 let(:command_options) { { :initial_timeout => nil } }
-                it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                it "should setvar RECORD_INITIAL_TIMEOUT_MS with a 0 value" do
+                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 0").ordered
+                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
                   original_command.response(0.1).should be_a Ref
                 end
@@ -103,8 +104,9 @@ module Punchblock
 
               context "set to -1" do
                 let(:command_options) { { :initial_timeout => -1 } }
-                it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                it "should setvar RECORD_INITIAL_TIMEOUT_MS with a 0 value" do
+                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 0").ordered
+                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
                   original_command.response(0.1).should be_a Ref
                 end
@@ -112,11 +114,11 @@ module Punchblock
 
               context "set to a positive number" do
                 let(:command_options) { { :initial_timeout => 10 } }
-                it "should return an error and not execute any actions" do
-                  mock_call.should_receive(:uuid_foo).never
+                it "should setvar RECORD_INITIAL_TIMEOUT_MS with a value in ms" do
+                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_INITIAL_TIMEOUT_MS 10").ordered
+                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  error = ProtocolError.new.setup 'option error', 'An initial-timeout value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  original_command.response(0.1).should be_a Ref
                 end
               end
             end
@@ -124,8 +126,9 @@ module Punchblock
             describe 'final_timeout' do
               context "set to nil" do
                 let(:command_options) { { :final_timeout => nil } }
-                it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                it "should setvar RECORD_FINAL_TIMEOUT_MS with a 0 value" do
+                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 0").ordered
+                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
                   original_command.response(0.1).should be_a Ref
                 end
@@ -133,8 +136,9 @@ module Punchblock
 
               context "set to -1" do
                 let(:command_options) { { :final_timeout => -1 } }
-                it "should execute normally" do
-                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/)
+                it "should setvar RECORD_FINAL_TIMEOUT_MS with a 0 value" do
+                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 0").ordered
+                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
                   original_command.response(0.1).should be_a Ref
                 end
@@ -142,11 +146,11 @@ module Punchblock
 
               context "set to a positive number" do
                 let(:command_options) { { :final_timeout => 10 } }
-                it "should return an error and not execute any actions" do
-                  mock_call.should_receive(:uuid_foo).never
+                it "should setvar RECORD_FINAL_TIMEOUT_MS with a value in ms" do
+                  mock_call.should_receive(:uuid_foo).once.with(:setvar, "RECORD_FINAL_TIMEOUT_MS 10").ordered
+                  mock_call.should_receive(:uuid_foo).once.with(:record, /.wav$/).ordered
                   subject.execute
-                  error = ProtocolError.new.setup 'option error', 'A final-timeout value is unsupported.'
-                  original_command.response(0.1).should be == error
+                  original_command.response(0.1).should be_a Ref
                 end
               end
             end

data/spec/punchblock/translator/freeswitch/component/tts_output_spec.rb

@@ -25,7 +25,7 @@ module Punchblock
           end
 
           let :command_options do
-            { :ssml => ssml_doc }
+            { :render_document => {:value => ssml_doc} }
           end
 
           def execute
@@ -49,16 +49,17 @@ module Punchblock
             let(:command_opts) { {} }
 
             let :command_options do
-              { :ssml => ssml_doc }.merge(command_opts)
+              { :render_document => {:value => ssml_doc} }.merge(command_opts)
             end
 
             let :original_command do
               Punchblock::Component::Output.new command_options
             end
 
-            describe 'ssml' do
+            describe 'document' do
               context 'unset' do
-                let(:command_opts) { { :ssml => nil } }
+                let(:ssml_doc) { nil }
+
                 it "should return an error and not execute any actions" do
                   execute
                   error = ProtocolError.new.setup 'option error', 'An SSML document is required.'
@@ -76,7 +77,16 @@ module Punchblock
                   expect_playback
                   execute
                   subject.handle_es_event RubyFS::Event.new(nil, :event_name => "CHANNEL_EXECUTE_COMPLETE")
-                  original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Success
+                  original_command.complete_event(0.1).reason.should be_a Punchblock::Component::Output::Complete::Finish
+                end
+              end
+
+              context 'with multiple documents' do
+                let(:command_opts) { { :render_documents => [{:value => ssml_doc}, {:value => ssml_doc}] } }
+                it "should return an error and not execute any actions" do
+                  subject.execute
+                  error = ProtocolError.new.setup 'option error', 'Only a single document is supported.'
+                  original_command.response(0.1).should be == error
                 end
               end
             end
@@ -221,11 +231,11 @@ module Punchblock
                 end
               end
 
-              context "set to :speech" do
-                let(:command_opts) { { :interrupt_on => :speech } }
+              context "set to :voice" do
+                let(:command_opts) { { :interrupt_on => :voice } }
                 it "should return an error and not execute any actions" do
                   execute
-                  error = ProtocolError.new.setup 'option error', 'An interrupt-on value of speech is unsupported.'
+                  error = ProtocolError.new.setup 'option error', 'An interrupt-on value of voice is unsupported.'
                   original_command.response(0.1).should be == error
                 end
               end

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

@@ -26,7 +26,7 @@ module Punchblock
                 RubyFS::Event.new nil, :event_name => 'CHANNEL_EXECUTE'
               end
 
-              let(:response) { mock 'Response' }
+              let(:response) { double 'Response' }
 
               it 'should execute the handler' do
                 response.should_receive(:call).once.with es_event
@@ -46,10 +46,8 @@ module Punchblock
             end
 
             let :expected_event do
-              Punchblock::Event::Complete.new.tap do |e|
-                e.target_call_id = call.id
-                e.component_id = subject.id
-              end
+              Punchblock::Event::Complete.new target_call_id: call.id,
+                component_id: subject.id
             end
 
             it "should send the event to the connection" do
@@ -63,9 +61,7 @@ module Punchblock
 
             let(:reason) { Punchblock::Event::Complete::Stop.new }
             let :expected_event do
-              Punchblock::Event::Complete.new.tap do |c|
-                c.reason = Punchblock::Event::Complete::Stop.new
-              end
+              Punchblock::Event::Complete.new reason: reason
             end
 
             it "should send a complete event with the specified reason" do

data/spec/punchblock/translator/freeswitch_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 module Punchblock
   module Translator
     describe Freeswitch do
-      let(:connection)    { mock 'Connection::Freeswitch' }
+      let(:connection)    { double 'Connection::Freeswitch' }
       let(:media_engine)  { :flite }
       let(:default_voice) { :hal }
 
       let(:translator)  { described_class.new connection, media_engine, default_voice }
-      let(:stream)      { mock 'RubyFS::Stream' }
+      let(:stream)      { double 'RubyFS::Stream' }
 
       before { connection.should_receive(:stream).at_most(:once).and_return stream }
 
@@ -88,14 +88,14 @@ module Punchblock
 
         it 'should make the call inaccessible by ID' do
           subject.call_with_id(call_id).should be call
-          subject.deregister_call call
+          subject.deregister_call call_id
           subject.call_with_id(call_id).should be_nil
         end
       end
 
       describe '#register_component' do
         let(:component_id) { 'abc123' }
-        let(:component)    { mock 'Foo', :id => component_id }
+        let(:component)    { double 'Foo', :id => component_id }
 
         it 'should make the component accessible by ID' do
           subject.register_component component
@@ -105,7 +105,7 @@ module Punchblock
 
       describe '#execute_call_command' do
         let(:call_id) { 'abc123' }
-        let(:command) { Command::Answer.new.tap { |c| c.target_call_id = call_id } }
+        let(:command) { Command::Answer.new target_call_id: call_id }
 
         context "with a known call ID" do
           let(:call) { described_class::Call.new 'SIP/foo', subject }
@@ -123,16 +123,13 @@ module Punchblock
         end
 
         let :end_error_event do
-          Punchblock::Event::End.new.tap do |e|
-            e.target_call_id = call_id
-            e.reason = :error
-          end
+          Punchblock::Event::End.new reason: :error, target_call_id: call_id
         end
 
         context "for an outgoing call which began executing but crashed" do
           let(:dial_command) { Command::Dial.new :to => 'SIP/1234', :from => 'abc123' }
 
-          let(:call_id) { dial_command.response.id }
+          let(:call_id) { dial_command.response.call_id }
 
           before do
             stream.as_null_object
@@ -205,7 +202,7 @@ module Punchblock
         let(:component_node)  { Component::Output.new }
         let(:component)       { Translator::Freeswitch::Component::Output.new(component_node, call) }
 
-        let(:command) { Component::Stop.new.tap { |c| c.component_id = component.id } }
+        let(:command) { Component::Stop.new component_id: component.id }
 
         before do
           command.request!
@@ -256,7 +253,7 @@ module Punchblock
           end
 
           it 'should instruct the call to send a dial' do
-            mock_call = stub('Freeswitch::Call').as_null_object
+            mock_call = double('Freeswitch::Call').as_null_object
             Freeswitch::Call.should_receive(:new_link).once.and_return mock_call
             mock_call.async.should_receive(:dial).once.with command
             subject.execute_global_command command
@@ -277,7 +274,7 @@ module Punchblock
 
       describe '#handle_pb_event' do
         it 'should forward the event to the connection' do
-          event = mock 'Punchblock::Event'
+          event = double 'Punchblock::Event'
           subject.connection.should_receive(:handle_event).once.with event
           subject.handle_pb_event event
         end
@@ -530,7 +527,7 @@ module Punchblock
 
         describe 'with a CHANNEL_PARK event' do
           it 'should instruct the call to send an offer' do
-            mock_call = stub('Freeswitch::Call').as_null_object
+            mock_call = double('Freeswitch::Call').as_null_object
             Freeswitch::Call.should_receive(:new).once.and_return mock_call
             subject.wrapped_object.should_receive(:link)
             mock_call.async.should_receive(:send_offer).once

data/spec/punchblock/uri_list_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Punchblock::URIList do
+  its(:size) { should == 0 }
+
+  context "created with a set of entries" do
+    subject { described_class.new 'http://example.com/hello.mp3', 'http://example.com/goodbye.mp3' }
+
+    its(:size) { should == 2 }
+    its(:to_ary) { should == ['http://example.com/hello.mp3', 'http://example.com/goodbye.mp3'] }
+
+    its(:to_s) { should == "http://example.com/hello.mp3\nhttp://example.com/goodbye.mp3" }
+  end
+
+  context "created with an array of entries" do
+    subject { described_class.new ['http://example.com/hello.mp3', 'http://example.com/goodbye.mp3'] }
+
+    its(:size) { should == 2 }
+    its(:to_ary) { should == ['http://example.com/hello.mp3', 'http://example.com/goodbye.mp3'] }
+    its(:to_s) { should == "http://example.com/hello.mp3\nhttp://example.com/goodbye.mp3" }
+  end
+
+  context "imported from a string" do
+    let(:string) do
+      <<-STRING
+      http://example.com/hello.mp3
+      http://example.com/goodbye.mp3
+      STRING
+    end
+
+    subject { described_class.import string }
+
+    its(:size) { should == 2 }
+    its(:to_ary) { should == ['http://example.com/hello.mp3', 'http://example.com/goodbye.mp3'] }
+    its(:to_s) { should == "http://example.com/hello.mp3\nhttp://example.com/goodbye.mp3" }
+  end
+
+  describe "comparisons" do
+    context "when the elements are the same" do
+      described_class.new('foo', 'bar').should == described_class.new('foo', 'bar')
+    end
+
+    context "when the elements are different" do
+      described_class.new('foo', 'baz').should_not == described_class.new('bar', 'baz')
+    end
+  end
+end

data/spec/punchblock_spec.rb

@@ -2,7 +2,17 @@ require 'spec_helper'
 
 describe Punchblock do
   describe '#client_with_connection' do
-    let(:mock_connection) { stub('Connection').as_null_object }
+    let(:mock_connection) { double('Connection').as_null_object }
+
+    context 'with :xmpp' do
+      it 'sets up an XMPP connection, passing options, and a client with the connection attached' do
+        options = {:username => 'foo', :password => 'bar'}
+        Punchblock::Connection::XMPP.should_receive(:new).once.with(options).and_return mock_connection
+        client = Punchblock.client_with_connection :xmpp, options
+        client.should be_a Punchblock::Client
+        client.connection.should be mock_connection
+      end
+    end
 
     context 'with :XMPP' do
       it 'sets up an XMPP connection, passing options, and a client with the connection attached' do

data/spec/spec_helper.rb

@@ -3,6 +3,9 @@
 require 'punchblock'
 require 'countdownlatch'
 require 'logger'
+require 'celluloid'
+require 'coveralls'
+Coveralls.wear!
 
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
@@ -12,6 +15,10 @@ RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 
+  config.mock_with :rspec do |mocks|
+    mocks.add_stub_and_should_receive_to Celluloid::AbstractProxy
+  end
+
   config.before :suite do |variable|
     Punchblock.logger = Logger.new(STDOUT)
     Punchblock.logger.define_singleton_method :trace, Punchblock.logger.method(:debug)
@@ -42,20 +49,9 @@ shared_examples_for 'event' do
 end
 
 shared_examples_for 'command_headers' do
-  it 'takes a hash of keys and values for headers' do
-    headers = { :x_skill => 'agent', :x_customer_id => '8877' }
-
-    control = [ Punchblock::Header.new(:x_skill, 'agent'), Punchblock::Header.new(:x_customer_id, '8877')]
-
-    di = subject.class.new :headers => headers
-    di.headers.should have(2).items
-    di.headers.each { |i| control.include?(i).should be_true }
-  end
 end
 
 shared_examples_for 'event_headers' do
-  its(:headers) { should be == [Punchblock::Header.new('X-skill', 'agent'), Punchblock::Header.new('X-customer-id', '8877')]}
-  its(:headers_hash) { should be == {:x_skill => 'agent', :x_customer_id => '8877'} }
 end
 
 shared_examples_for 'key_value_pairs' do

data/spec/support/mock_connection_with_event_handler.rb

@@ -3,7 +3,7 @@
 module HasMockCallbackConnection
   def self.included(test_case)
     test_case.let(:connection) do
-      mock('Connection').tap do |mc|
+      double('Connection').tap do |mc|
         mc.stub :handle_event do |event|
           original_command.add_event event
         end