adhearsion 2.0.1 → 2.1.0

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

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    module Output
+      describe Formatter do
+        subject { Formatter }
+
+        describe ".ssml_for" do
+          let(:prompt) { "Please stand by" }
+
+          let(:ssml) do
+            RubySpeech::SSML.draw { string 'Please stand by' }
+          end
+
+          it 'returns SSML for a text argument' do
+            subject.ssml_for(prompt).should be == ssml
+          end
+
+          it 'returns the same SSML passed in if it is SSML' do
+            subject.ssml_for(ssml).should be == ssml
+          end
+        end
+
+        describe ".ssml_for_collection" do
+          let(:collection) { ["/foo/bar.wav", 1, Time.now] }
+          let :ssml do
+            file = collection[0]
+            n = collection[1].to_s
+            t = collection[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 "should create a composite SSML document" do
+            subject.ssml_for_collection(collection).should be == ssml
+          end
+        end
+
+        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
+          end
+
+          it "detects a file path" do
+            file_path = "file:///usr/shared/sounds/hello.mp3"
+            subject.detect_type(file_path).should be :audio
+
+            absolute_path = "/usr/shared/sounds/hello.mp3"
+            subject.detect_type(absolute_path).should be :audio
+
+            relative_path = "foo/bar"
+            subject.detect_type(relative_path).should_not be :audio
+          end
+
+          it "detects a Date object" do
+            today = Date.today
+            subject.detect_type(today).should be :time
+          end
+
+          it "detects a Time object" do
+            now = Time.now
+            subject.detect_type(now).should be :time
+          end
+
+          it "detects a DateTime object" do
+            today = DateTime.now
+            subject.detect_type(today).should be :time
+          end
+
+          it "detects a Numeric object" do
+            number = 123
+            subject.detect_type(number).should be :numeric
+          end
+
+          it "returns text as a fallback" do
+            output = "Hello"
+            subject.detect_type(output).should be :text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    module Output
+      describe Player do
+        include CallControllerTestHelpers
+
+        let(:controller) { flexmock new_controller }
+
+        subject { Player.new controller }
+
+        describe "#output" do
+          let(:content) { RubySpeech::SSML.draw { string "BOO" } }
+
+          it "should execute an output component with the provided SSML content" do
+            expect_component_execution Punchblock::Component::Output.new(:ssml => content)
+            subject.output content
+          end
+
+          it "should allow extra options to be passed to the output component" do
+            component = Punchblock::Component::Output.new :ssml => content, :start_paused => true
+            expect_component_execution component
+            subject.output content, :start_paused => true
+          end
+
+          it "yields the component to the block before executing it" do
+            component = Punchblock::Component::Output.new :ssml => content, :start_paused => true
+            expect_component_execution component
+            subject.output content do |comp|
+              comp.start_paused = true
+            end
+          end
+
+          it "raises a PlaybackError if the component fails to start" do
+            expect_component_execution Punchblock::Component::Output.new(:ssml => content), Punchblock::ProtocolError
+            lambda { subject.output content }.should raise_error(PlaybackError)
+          end
+
+          it "raises a Playback Error if the component ends due to an error" do
+            expect_component_execution Punchblock::Component::Output.new(:ssml => content), Adhearsion::Error
+            lambda { subject.output content }.should raise_error(PlaybackError)
+          end
+
+          it "raises a Playback Error if the component ends due to an error" do
+            e = Call::Hangup.new
+            expect_component_execution Punchblock::Component::Output.new(:ssml => content), e
+            lambda { subject.output content }.should raise_error(e)
+          end
+        end
+
+        describe "#play_ssml" do
+          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)
+            subject.play_ssml ssml
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/call_controller/output_spec.rb

@@ -7,57 +7,102 @@ module Adhearsion
     describe Output do
       include CallControllerTestHelpers
 
-      describe "#play_ssml" do
-        let(:ssml) { RubySpeech::SSML.draw { string "BOO" } }
+      def expect_ssml_output(ssml)
+        expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
+      end
 
-        it 'executes an Output with the correct ssml' do
-          expect_component_execution Punchblock::Component::Output.new(:ssml => ssml.to_s)
-          subject.play_ssml ssml
+      def expect_async_ssml_output(ssml)
+        expect_message_waiting_for_response Punchblock::Component::Output.new(:ssml => ssml)
+      end
+
+      describe "#player" do
+        it "should return a Player component targetted at the current controller" do
+          player = controller.player
+          player.should be_a Output::Player
+          player.controller.should be controller
         end
 
-        describe "if an error is returned" do
-          before do
-            pending
-            subject.should_receive(:execute_component_and_await_completion).once.and_raise(StandardError)
-          end
+        it "should return the same player every time" do
+          controller.player.should be controller.player
+        end
+      end
 
-          it 'should return false' do
-            pending
-            subject.play_ssml(ssml).should be false
-          end
+      describe "#async_player" do
+        it "should return an AsyncPlayer component targetted at the current controller" do
+          player = controller.async_player
+          player.should be_a Output::AsyncPlayer
+          player.controller.should be controller
+        end
+
+        it "should return the same player every time" do
+          controller.async_player.should be controller.async_player
         end
       end
 
       describe "#play_audio" do
-        let(:audio_file)  { "/sounds/boo.wav" }
-        let(:fallback)    { "text for tts" }
+        let(:audio_file) { "/sounds/boo.wav" }
 
-        let(:ssml) do
+        let :ssml do
           file = audio_file
           RubySpeech::SSML.draw { audio :src => file }
         end
 
-        let(:ssml_with_fallback) do
+        it 'plays the correct ssml' do
+          expect_ssml_output ssml
+          subject.play_audio(audio_file).should be true
+        end
+
+        context "with a fallback" do
+          let(:fallback) { "text for tts" }
+
+          let :ssml do
+            file = audio_file
+            fallback_text = fallback
+            RubySpeech::SSML.draw do
+              audio(:src => file) { fallback_text }
+            end
+          end
+
+          it 'places the fallback in the SSML doc' do
+            expect_ssml_output ssml
+            subject.play_audio(audio_file, :fallback => fallback).should be true
+          end
+        end
+      end
+
+      describe "#play_audio!" do
+        let(:audio_file) { "/sounds/boo.wav" }
+
+        let :ssml do
           file = audio_file
-          fallback_text = fallback
-          RubySpeech::SSML.draw {
-            audio(:src => file) { fallback_text }
-          }
+          RubySpeech::SSML.draw { audio :src => file }
         end
 
         it 'plays the correct ssml' do
-          subject.should_receive(:play_ssml).once.with(ssml).and_return true
-          subject.play_audio(audio_file).should be true
+          expect_async_ssml_output ssml
+          subject.play_audio!(audio_file).should be_a Punchblock::Component::Output
         end
 
-        it 'allows for fallback tts' do
-          subject.should_receive(:play_ssml).once.with(ssml_with_fallback).and_return true
-          subject.play_audio(audio_file, :fallback => fallback).should be true
+        context "with a fallback" do
+          let(:fallback) { "text for tts" }
+
+          let :ssml do
+            file = audio_file
+            fallback_text = fallback
+            RubySpeech::SSML.draw do
+              audio(:src => file) { fallback_text }
+            end
+          end
+
+          it 'places the fallback in the SSML doc' do
+            expect_async_ssml_output ssml
+            subject.play_audio!(audio_file, :fallback => fallback).should be_a Punchblock::Component::Output
+          end
         end
       end
 
       describe "#play_numeric" do
-        let :expected_doc do
+        let :ssml do
           RubySpeech::SSML.draw do
             say_as(:interpret_as => 'cardinal') { "123" }
           end
@@ -67,7 +112,7 @@ module Adhearsion
           let(:input) { 123 }
 
           it 'plays the correct ssml' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_numeric(input).should be true
           end
         end
@@ -76,7 +121,7 @@ module Adhearsion
           let(:input) { "123" }
 
           it 'plays the correct ssml' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_numeric(input).should be true
           end
         end
@@ -84,14 +129,48 @@ module Adhearsion
         describe "with something that's not a number" do
           let(:input) { 'foo' }
 
-          it 'returns nil' do
-            subject.play_numeric(input).should be nil
+          it 'raises ArgumentError' do
+            lambda { subject.play_numeric input }.should raise_error(ArgumentError)
+          end
+        end
+      end
+
+      describe "#play_numeric!" do
+        let :ssml do
+          RubySpeech::SSML.draw do
+            say_as(:interpret_as => 'cardinal') { "123" }
+          end
+        end
+
+        describe "with a number" do
+          let(:input) { 123 }
+
+          it 'plays the correct ssml' do
+            expect_async_ssml_output ssml
+            subject.play_numeric!(input).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with a string representation of a number" do
+          let(:input) { "123" }
+
+          it 'plays the correct ssml' do
+            expect_async_ssml_output ssml
+            subject.play_numeric!(input).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with something that's not a number" do
+          let(:input) { 'foo' }
+
+          it 'raises ArgumentError' do
+            lambda { subject.play_numeric! input }.should raise_error(ArgumentError)
           end
         end
       end
 
       describe "#play_time" do
-        let :expected_doc do
+        let :ssml do
           content = input.to_s
           opts    = expected_say_as_options
           RubySpeech::SSML.draw do
@@ -104,7 +183,7 @@ module Adhearsion
           let(:expected_say_as_options) { {:interpret_as => 'time'} }
 
           it 'plays the correct SSML' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_time(input).should be true
           end
         end
@@ -114,7 +193,7 @@ module Adhearsion
           let(:expected_say_as_options) { {:interpret_as => 'date'} }
 
           it 'plays the correct SSML' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_time(input).should be true
           end
         end
@@ -125,7 +204,7 @@ module Adhearsion
           let(:expected_say_as_options) { {:interpret_as => 'date', :format => format} }
 
           it 'plays the correct SSML' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_time(input, :format => format).should be true
           end
         end
@@ -137,7 +216,7 @@ module Adhearsion
           let(:expected_say_as_options) { {:interpret_as => 'date'} }
 
           it 'plays the correct SSML' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_time(base_input, :strftime => strftime).should be true
           end
         end
@@ -150,7 +229,7 @@ module Adhearsion
           let(:expected_say_as_options) { {:interpret_as => 'date', :format => format} }
 
           it 'plays the correct SSML' do
-            subject.should_receive(:play_ssml).once.with(expected_doc).and_return true
+            expect_ssml_output ssml
             subject.play_time(base_input, :format => format, :strftime => strftime).should be true
           end
         end
@@ -158,87 +237,198 @@ module Adhearsion
         describe "with an object other than Time, DateTime, or Date" do
           let(:input) { "foo" }
 
-          it 'returns false' do
-            subject.play_time(input).should be false
+          it 'raises ArgumentError' do
+            lambda { subject.play_time input }.should raise_error(ArgumentError)
+          end
+        end
+      end
+
+      describe "#play_time!" do
+        let :ssml do
+          content = input.to_s
+          opts    = expected_say_as_options
+          RubySpeech::SSML.draw do
+            say_as(opts) { content }
+          end
+        end
+
+        describe "with a time" do
+          let(:input) { Time.parse("12/5/2000") }
+          let(:expected_say_as_options) { {:interpret_as => 'time'} }
+
+          it 'plays the correct SSML' do
+            expect_async_ssml_output ssml
+            subject.play_time!(input).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with a date" do
+          let(:input) { Date.parse('2011-01-23') }
+          let(:expected_say_as_options) { {:interpret_as => 'date'} }
+
+          it 'plays the correct SSML' do
+            expect_async_ssml_output ssml
+            subject.play_time!(input).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with a date and a say_as format" do
+          let(:input)   { Date.parse('2011-01-23') }
+          let(:format)  { "d-m-y" }
+          let(:expected_say_as_options) { {:interpret_as => 'date', :format => format} }
+
+          it 'plays the correct SSML' do
+            expect_async_ssml_output ssml
+            subject.play_time!(input, :format => format).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with a date and a strftime option" do
+          let(:strftime)    { "%d-%m-%Y" }
+          let(:base_input)  { Date.parse('2011-01-23') }
+          let(:input)       { base_input.strftime(strftime) }
+          let(:expected_say_as_options) { {:interpret_as => 'date'} }
+
+          it 'plays the correct SSML' do
+            expect_async_ssml_output ssml
+            subject.play_time!(base_input, :strftime => strftime).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with a date, a format option and a strftime option" do
+          let(:strftime)    { "%d-%m-%Y" }
+          let(:format)      { "d-m-y" }
+          let(:base_input)  { Date.parse('2011-01-23') }
+          let(:input)       { base_input.strftime(strftime) }
+          let(:expected_say_as_options) { {:interpret_as => 'date', :format => format} }
+
+          it 'plays the correct SSML' do
+            expect_async_ssml_output ssml
+            subject.play_time!(base_input, :format => format, :strftime => strftime).should be_a Punchblock::Component::Output
+          end
+        end
+
+        describe "with an object other than Time, DateTime, or Date" do
+          let(:input) { "foo" }
+
+          it 'raises ArgumentError' do
+            lambda { subject.play_time! input }.should raise_error(ArgumentError)
           end
         end
       end
 
       describe '#play' do
         describe "with a single string" do
-          let(:file) { "cents-per-minute" }
+          let(:audio_file) { "/foo/bar.wav" }
+          let :ssml do
+            file = audio_file
+            RubySpeech::SSML.draw { audio :src => file }
+          end
 
           it 'plays the audio file' do
-            subject.should_receive(:play_ssml_for).once.with(file).and_return true
-            subject.play(file).should be true
+            expect_ssml_output ssml
+            subject.play(audio_file).should be true
           end
         end
 
-        describe "with multiple strings" do
-          let(:args) { ['rock', 'paperz', 'scissors'] }
-
-          it 'plays multiple files' do
-            args.each do |file|
-              subject.should_receive(:play_ssml_for).once.with(file).and_return true
+        describe "with multiple 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 "if an audio file cannot be found" do
-            before do
-              pending
-              subject.should_receive(:play_audio).with(args[0]).and_return(true).ordered
-              subject.should_receive(:play_audio).with(args[1]).and_return(false).ordered
-              subject.should_receive(:play_audio).with(args[2]).and_return(true).ordered
-            end
+        describe "with a number" do
+          let(:argument) { 123 }
 
-            it 'should return false' do
-              subject.play(*args).should be false
+          let(:ssml) do
+            number = argument.to_s
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'cardinal') { number }
             end
           end
-        end
 
-        describe "with a number" do
           it 'plays the number' do
-            subject.should_receive(:play_ssml_for).with(123).and_return(true)
-            subject.play(123).should be true
+            expect_ssml_output ssml
+            subject.play(argument).should be true
           end
         end
 
         describe "with a string representation of a number" do
+          let(:argument) { '123' }
+
+          let(:ssml) do
+            number = argument
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'cardinal') { number }
+            end
+          end
+
           it 'plays the number' do
-            subject.should_receive(:play_ssml_for).with('123').and_return(true)
-            subject.play('123').should be true
+            expect_ssml_output ssml
+            subject.play(argument).should be true
           end
         end
 
         describe "with a time" do
-          let(:time) { Time.parse("12/5/2000") }
+          let(:time) { Time.parse "12/5/2000" }
+
+          let(:ssml) do
+            t = time.to_s
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'time') { t }
+            end
+          end
 
           it 'plays the time' do
-            subject.should_receive(:play_ssml_for).with(time).and_return(true)
+            expect_ssml_output ssml
             subject.play(time).should be true
           end
         end
 
         describe "with a date" do
-          let(:date) { Date.parse('2011-01-23') }
+          let(:date) { Date.parse '2011-01-23' }
+          let(:ssml) do
+            d = date.to_s
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'date') { d }
+            end
+          end
 
           it 'plays the time' do
-            subject.should_receive(:play_ssml_for).with(date).and_return(true)
+            expect_ssml_output ssml
             subject.play(date).should be true
           end
         end
 
         describe "with an array containing a Date/DateTime/Time object and a hash" do
-          let(:date)      { Date.parse('2011-01-23') }
+          let(:date)      { Date.parse '2011-01-23' }
           let(:format)    { "d-m-y" }
           let(:strftime)  { "%d-%m%Y" }
 
+          let :ssml do
+            d = date.strftime strftime
+            f = format
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'date', :format => f) { d }
+            end
+          end
+
           it 'plays the time with the specified format and strftime' do
-            subject.should_receive(:play_ssml_for).with(date, {:format => format, :strftime => strftime}).and_return(true)
-            subject.play({:value => date, :format => format, :strftime => strftime}).should be true
+            expect_ssml_output ssml
+            subject.play(:value => date, :format => format, :strftime => strftime).should be true
           end
         end
 
@@ -246,125 +436,157 @@ module Adhearsion
           let(:ssml) { RubySpeech::SSML.draw { string "Hello world" } }
 
           it "plays the SSML without generating" do
-            subject.should_receive(:play_ssml).with(ssml).and_return(true)
+            expect_ssml_output ssml
             subject.play(ssml).should be true
           end
         end
       end
 
-      describe "#play!" do
-        let(:prompt)        { "Press any button." }
-        let(:second_prompt) { "Or press nothing." }
-        let(:non_existing) { "http://adhearsion.com/nonexistingfile.mp3" }
+      describe '#play!' do
+        describe "with a single string" do
+          let(:audio_file) { "/foo/bar.wav" }
+          let :ssml do
+            file = audio_file
+            RubySpeech::SSML.draw { audio :src => file }
+          end
 
-        it "calls play a single time" do
-          subject.should_receive(:play).once.with(prompt).and_return(true)
-          subject.play!(prompt)
+          it 'plays the audio file' do
+            expect_async_ssml_output ssml
+            subject.play!(audio_file).should be_a Punchblock::Component::Output
+          end
         end
 
-        it "calls play two times" do
-          subject.should_receive(:play).once.with(prompt, second_prompt).and_return(true)
-          subject.play!(prompt, second_prompt)
-        end
+        describe "with multiple 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 "raises an exception if play fails" do
-          subject.should_receive(:play).once.and_return false
-          expect { subject.play!(non_existing) }.to raise_error(Output::PlaybackError)
+          it 'plays all arguments in one document' do
+            expect_async_ssml_output ssml
+            subject.play!(*args).should be_a Punchblock::Component::Output
+          end
         end
-      end
 
-      describe "#speak" do
-        it "should be an alias for #say" do
-          subject.method(:speak).should be == subject.method(:say)
-        end
-      end
+        describe "with a number" do
+          let(:argument) { 123 }
 
-      describe "#say" do
-        describe "with a RubySpeech document" do
-          it 'plays the correct SSML' do
-            ssml = RubySpeech::SSML.draw { string "Hello world" }
-            expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
-            subject.say(ssml).should be_a Punchblock::Component::Output
+          let(:ssml) do
+            number = argument.to_s
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'cardinal') { number }
+            end
           end
-        end
 
-        describe "with a string" do
-          it 'outputs the correct text' do
-            str = "Hello world"
-            ssml = RubySpeech::SSML.draw { string str }
-            expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
-            subject.say(str).should be_a Punchblock::Component::Output
+          it 'plays the number' do
+            expect_async_ssml_output ssml
+            subject.play!(argument).should be_a Punchblock::Component::Output
           end
         end
 
-        describe "converts the argument to a string" do
-          it 'calls output with a string' do
-            argument = 123
-            ssml = RubySpeech::SSML.draw { string '123' }
-            expect_component_execution Punchblock::Component::Output.new(:ssml => ssml)
-            subject.say(argument).should be_a Punchblock::Component::Output
+        describe "with a string representation of a number" do
+          let(:argument) { '123' }
+
+          let(:ssml) do
+            number = argument
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'cardinal') { number }
+            end
+          end
+
+          it 'plays the number' do
+            expect_async_ssml_output ssml
+            subject.play!(argument).should be_a Punchblock::Component::Output
           end
         end
-      end
 
-      describe "#ssml_for" do
-        let(:prompt) { "Please stand by" }
+        describe "with a time" do
+          let(:time) { Time.parse "12/5/2000" }
 
-        let(:ssml) do
-          RubySpeech::SSML.draw do
-            string 'Please stand by'
+          let(:ssml) do
+            t = time.to_s
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'time') { t }
+            end
           end
-        end
 
-        it 'returns SSML for a text argument' do
-          subject.ssml_for(prompt).should be == ssml
+          it 'plays the time' do
+            expect_async_ssml_output ssml
+            subject.play!(time).should be_a Punchblock::Component::Output
+          end
         end
 
-        it 'returns the same SSML passed in if it is SSML' do
-          subject.ssml_for(ssml) == ssml
-        end
-      end
+        describe "with a date" do
+          let(:date) { Date.parse '2011-01-23' }
+          let(:ssml) do
+            d = date.to_s
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'date') { d }
+            end
+          end
 
-      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
+          it 'plays the time' do
+            expect_async_ssml_output ssml
+            subject.play!(date).should be_a Punchblock::Component::Output
+          end
         end
 
-        it "detects a file path" do
-          file_path = "file:///usr/shared/sounds/hello.mp3"
-          subject.detect_type(file_path).should be :audio
+        describe "with an array containing a Date/DateTime/Time object and a hash" do
+          let(:date)      { Date.parse '2011-01-23' }
+          let(:format)    { "d-m-y" }
+          let(:strftime)  { "%d-%m%Y" }
 
-          absolute_path = "/usr/shared/sounds/hello.mp3"
-          subject.detect_type(absolute_path).should be :audio
+          let :ssml do
+            d = date.strftime strftime
+            f = format
+            RubySpeech::SSML.draw do
+              say_as(:interpret_as => 'date', :format => f) { d }
+            end
+          end
 
-          relative_path = "foo/bar"
-          subject.detect_type(relative_path).should_not be :audio
+          it 'plays the time with the specified format and strftime' do
+            expect_async_ssml_output ssml
+            subject.play!(:value => date, :format => format, :strftime => strftime).should be_a Punchblock::Component::Output
+          end
         end
 
-        it "detects a Date object" do
-          today = Date.today
-          subject.detect_type(today).should be :time
-        end
+        describe "with an SSML document" do
+          let(:ssml) { RubySpeech::SSML.draw { string "Hello world" } }
 
-        it "detects a Time object" do
-          now = Time.now
-          subject.detect_type(now).should be :time
+          it "plays the SSML without generating" do
+            expect_async_ssml_output ssml
+            subject.play!(ssml).should be_a Punchblock::Component::Output
+          end
         end
+      end
+
+      describe "#interruptible_play" do
+        let(:output1)       { "one two" }
+        let(:output2)       { "three four" }
+        let(:non_existing)  { "http://adhearsion.com/nonexistingfile.mp3" }
 
-        it "detects a DateTime object" do
-          today = DateTime.now
-          subject.detect_type(today).should be :time
+        it "plays two outputs in succession" do
+          subject.should_receive(:stream_file).twice
+          digit = subject.interruptible_play output1, output2
+          digit.should be_nil
         end
 
-        it "detects a Numeric object" do
-          number = 123
-          subject.detect_type(number).should be :numeric
+        it "stops at the first play when input is received" do
+          subject.should_receive(:stream_file).once.and_return(2)
+          digit = subject.interruptible_play output1, output2
+          digit.should be == 2
         end
 
-        it "returns text as a fallback" do
-          output = "Hello"
-          subject.detect_type(output).should be :text
+        it 'raises an exception when output is unsuccessful' do
+          subject.should_receive(:stream_file).once.and_raise Output::PlaybackError, "Output failed"
+          expect { subject.interruptible_play non_existing }.to raise_error(Output::PlaybackError)
         end
       end
 
@@ -372,21 +594,21 @@ module Adhearsion
         let(:allowed_digits)  { '35' }
         let(:prompt)          { "Press 3 or 5 to make something happen." }
 
-        let(:ssml) {
+        let(:ssml) do
           RubySpeech::SSML.draw do
             string "Press 3 or 5 to make something happen."
           end
-        }
+        end
 
-        let(:grammar) {
-         RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'acceptdigits' do
+        let(:grammar) do
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'acceptdigits' do
             rule id: 'acceptdigits' do
               one_of do
                 allowed_digits.each { |d| item { d.to_s } }
               end
             end
           end
-        }
+        end
 
         let(:output_component) {
           Punchblock::Component::Output.new :ssml => ssml.to_s
@@ -399,7 +621,7 @@ module Adhearsion
 
         #test does pass and method works, but not sure if the empty method is a good idea
         it "plays the correct output" do
-          def subject.write_and_await_response(input_component)
+          def controller.write_and_await_response(input_component)
             # it is actually a no-op here
           end
 
@@ -420,7 +642,7 @@ module Adhearsion
         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 subject.write_and_await_response(input_component)
+          def controller.write_and_await_response(input_component)
             input_component.trigger_event_handler Punchblock::Event::Complete.new
           end
 
@@ -435,54 +657,78 @@ module Adhearsion
 
           expect_component_complete_event
           flexmock(Punchblock::Component::Output).new_instances.should_receive(:stop!)
-          subject.should_receive(:execute_component_and_await_completion).once.with(output_component)
+          expect_component_execution output_component
           subject.stream_file(prompt, allowed_digits).should be == '5'
         end
-      end # describe #stream_file
-
-
-      describe "#interruptible_play!" do
-        let(:output1)       { "one two" }
-        let(:output2)       { "three four" }
-        let(:non_existing)  { "http://adhearsion.com/nonexistingfile.mp3" }
+      end
 
-        it "plays two outputs in succession" do
-          subject.should_receive(:stream_file).twice
-          subject.interruptible_play! output1, output2
+      describe "#say" do
+        describe "with a RubySpeech document" do
+          it 'plays the correct SSML' do
+            ssml = RubySpeech::SSML.draw { string "Hello world" }
+            expect_ssml_output ssml
+            subject.say(ssml).should be_a Punchblock::Component::Output
+          end
         end
 
-        it "stops at the first play when input is received" do
-          subject.should_receive(:stream_file).once.and_return(2)
-          subject.interruptible_play! output1, output2
+        describe "with a string" do
+          it 'outputs the correct text' do
+            str = "Hello world"
+            ssml = RubySpeech::SSML.draw { string str }
+            expect_ssml_output ssml
+            subject.say(str).should be_a Punchblock::Component::Output
+          end
         end
 
-        it 'raises an exception when output is unsuccessful' do
-          subject.should_receive(:stream_file).once.and_raise Output::PlaybackError, "Output failed"
-          expect { subject.interruptible_play!(non_existing) }.to raise_error(Output::PlaybackError)
+        describe "converts the argument to a string" do
+          it 'calls output with a string' do
+            argument = 123
+            ssml = RubySpeech::SSML.draw { string '123' }
+            expect_ssml_output ssml
+            subject.say(argument).should be_a Punchblock::Component::Output
+          end
         end
-      end # describe interruptible_play!
+      end
 
-      describe "#interruptible_play" do
-        let(:output1)       { "one two" }
-        let(:output2)       { "three four" }
-        let(:non_existing)  { "http://adhearsion.com/nonexistingfile.mp3" }
+      describe "#speak" do
+        it "should be an alias for #say" do
+          subject.method(:speak).should be == subject.method(:say)
+        end
+      end
 
-        it "plays two outputs in succession" do
-          subject.should_receive(:interruptible_play!).twice
-          subject.interruptible_play output1, output2
+      describe "#say!" do
+        describe "with a RubySpeech document" do
+          it 'plays the correct SSML' do
+            ssml = RubySpeech::SSML.draw { string "Hello world" }
+            expect_async_ssml_output ssml
+            subject.say!(ssml).should be_a Punchblock::Component::Output
+          end
         end
 
-        it "stops at the first play when input is received" do
-          subject.should_receive(:interruptible_play!).once.and_return(2)
-          subject.interruptible_play output1, output2
+        describe "with a string" do
+          it 'outputs the correct text' do
+            str = "Hello world"
+            ssml = RubySpeech::SSML.draw { string str }
+            expect_async_ssml_output ssml
+            subject.say!(str).should be_a Punchblock::Component::Output
+          end
         end
 
-        it "should not raise an exception when output is unsuccessful" do
-          subject.should_receive(:stream_file).once.and_raise Output::PlaybackError, "Output failed"
-          lambda { subject.interruptible_play non_existing }.should_not raise_error(Output::PlaybackError)
+        describe "converts the argument to a string" do
+          it 'calls output with a string' do
+            argument = 123
+            ssml = RubySpeech::SSML.draw { string '123' }
+            expect_async_ssml_output ssml
+            subject.say!(argument).should be_a Punchblock::Component::Output
+          end
         end
-      end # describe interruptible_play
+      end
 
+      describe "#speak!" do
+        it "should be an alias for #say!" do
+          subject.method(:speak!).should be == subject.method(:say!)
+        end
+      end
     end
   end
 end