voicemail 0.2.0 → 1.0.0.beta

data/spec/voicemail/{mailbox_main_menu_controller_spec.rb → call_controllers/mailbox_main_menu_controller_spec.rb}

@@ -26,10 +26,17 @@ describe Voicemail::MailboxMainMenuController do
     end
   end
 
-  describe "#listen_to_messages" do
+  describe "#listen_to_new_messages" do
     it "invokes MailboxMessagesController" do
       should_invoke Voicemail::MailboxMessagesController, mailbox: mailbox[:id]
-      controller.listen_to_messages
+      controller.listen_to_new_messages
+    end
+  end
+
+  describe "#listen_to_saved_messages" do
+    it "invokes MailboxMessagesController" do
+      should_invoke Voicemail::MailboxMessagesController, mailbox: mailbox[:id], new_or_saved: :saved
+      controller.listen_to_saved_messages
     end
   end
 end

data/spec/voicemail/call_controllers/mailbox_messages_controller_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module Voicemail
+  describe MailboxMessagesController do
+    include VoicemailControllerSpecHelper
+
+    let(:call)     { flexmock('Call') }
+    let(:config)   { Voicemail::Plugin.config }
+    let(:metadata) { {mailbox: '100', new_or_saved: message_type} }
+
+    let(:mailbox) do
+      {
+        :id => 100,
+        :pin => 1234,
+        :greeting_message => nil,
+        :send_email => true,
+        :email_address => "lpradovera@mojolingo.com"
+      }
+    end
+    let(:message) do
+      {
+        :id => 123,
+        :from => "+39-335135335",
+        :received => Time.local(2012, 5, 1, 9, 0, 0),
+        :uri => "file:///path/to/file.mp3"
+      }
+    end
+
+    let(:storage_instance) { flexmock('StorageInstance') }
+
+    let(:controller){ Voicemail::MailboxMessagesController.new call, metadata }
+    subject { flexmock controller }
+
+    before(:each) do
+      storage_instance.should_receive(:get_mailbox).with(metadata[:mailbox]).and_return(mailbox)
+      flexmock(Storage).should_receive(:instance).and_return(storage_instance)
+    end
+
+
+    context "with new messages" do
+      let(:message_type) { :new }
+
+      describe "#message_loop" do
+        after { controller.message_loop }
+
+        it "calls #next_message if there are new messages" do
+          storage_instance.should_receive(:count_new_messages).once.with(mailbox[:id]).and_return(3)
+          subject.should_receive(:next_message).once
+        end
+
+        it "plays a message and goes to the main menu if there are no new messages" do
+          storage_instance.should_receive(:count_new_messages).once.with(mailbox[:id]).and_return(0)
+          subject.should_receive(:play).with(config.messages.no_new_messages).once
+          subject.should_receive(:main_menu).once
+        end
+      end
+
+      describe "#next_message" do
+        it "gets the next message and calls #handle_message" do
+          storage_instance.should_receive(:next_new_message).once.with(mailbox[:id]).and_return(message)
+          subject.should_receive(:handle_message).once.with(message)
+          subject.should_receive(:message_loop).once
+          controller.next_message
+        end
+      end
+
+      describe "#handle_message" do
+        it "invokes MailboxPlayMessageController" do
+          should_invoke Voicemail::MailboxPlayMessageController, message: message, mailbox: mailbox[:id], new_or_saved: :new, storage: storage_instance
+          controller.handle_message message
+        end
+      end
+    end
+
+    context "with saved messages" do
+      let(:message_type) { :saved }
+
+      describe "#message_loop" do
+        after { controller.message_loop }
+
+        it "calls #next_message if there are saved messages" do
+          storage_instance.should_receive(:count_saved_messages).once.with(mailbox[:id]).and_return(3)
+          subject.should_receive(:next_message).once
+        end
+
+        it "plays a message and goes to the main menu if there are no saved messages" do
+          storage_instance.should_receive(:count_saved_messages).once.with(mailbox[:id]).and_return(0)
+          subject.should_receive(:play).with(config.messages.no_saved_messages).once
+          subject.should_receive(:main_menu).once
+        end
+      end
+
+      describe "#next_message" do
+        it "gets the next message and calls #handle_message" do
+          storage_instance.should_receive(:next_saved_message).once.with(mailbox[:id]).and_return(message)
+          subject.should_receive(:handle_message).once.with(message)
+          subject.should_receive(:message_loop).once
+          controller.next_message
+        end
+      end
+
+      describe "#handle_message" do
+        it "invokes MailboxPlayMessageController" do
+          should_invoke Voicemail::MailboxPlayMessageController, message: message, mailbox: mailbox[:id], new_or_saved: :saved, storage: storage_instance
+          controller.handle_message message
+        end
+      end
+    end
+  end
+end

data/spec/voicemail/call_controllers/mailbox_play_message_controller_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Voicemail::MailboxPlayMessageController do
+  include VoicemailControllerSpecHelper
+
+  let(:message) do
+    {
+      id:       123,
+      from:     "+39-335135335",
+      received: Time.local(2012, 5, 1, 9, 0, 0),
+      uri:      "file:///path/to/file.mp3"
+    }
+  end
+
+  describe "#archive_or_unarchive_message" do
+
+    after { controller.archive_or_unarchive_message }
+
+    context "with a new message" do
+      before { subject.new_or_saved = :new }
+
+      it "archives the message" do
+        subject.should_receive(:current_message).once.and_return message
+        storage_instance.should_receive(:archive_message).once.with mailbox[:id], message[:id]
+      end
+    end
+
+    context "with a saved message" do
+      before { subject.new_or_saved = :saved }
+
+      it "unarchives the message" do
+        subject.should_receive(:current_message).once.and_return message
+        storage_instance.should_receive(:unarchive_message).once.with mailbox[:id], message[:id]
+      end
+    end
+  end
+
+  describe "#delete_message" do
+    it "deletes the message" do
+      subject.should_receive(:current_message).once.and_return(message)
+      storage_instance.should_receive(:delete_message).once.with(mailbox[:id], message[:id])
+      controller.delete_message
+    end
+  end
+
+  describe "#intro_message" do
+    it "plays the message introduction" do
+      subject.should_receive(:current_message).once.and_return message
+      should_invoke Voicemail::MailboxPlayMessageIntroController, message: message, mailbox: 100, storage: storage_instance
+      controller.intro_message
+    end
+  end
+
+  describe "#play_message" do
+    after { subject.play_message }
+
+    context "with a new message" do
+      before { subject.new_or_saved = :new }
+
+      it "plays the message, followed by the new message menu" do
+        subject.should_receive(:current_message).once.and_return message
+        subject.should_receive(:menu).once.with message[:uri], config.messages.menu_new,
+          { timeout: config.menu_timeout, tries: config.menu_tries }, Proc
+      end
+    end
+
+    context "with a saved message" do
+      before { subject.new_or_saved = :saved }
+
+      it "plays the message, followed by the saved message menu" do
+        subject.should_receive(:current_message).once.and_return message
+        subject.should_receive(:menu).once.with message[:uri], config.messages.menu_saved,
+          { timeout: config.menu_timeout, tries: config.menu_tries }, Proc
+      end
+    end
+  end
+
+  describe "#load_message" do
+
+    context "with a message" do
+      let(:metadata) { {message: "foo"} }
+
+      it "loads the messge" do
+        subject.load_message
+        subject.current_message.should == "foo"
+      end
+    end
+
+    context "with no message passed" do
+      let(:metadata) { {message: nil} }
+
+      it "raises an error" do
+        expect { subject.load_message }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/spec/voicemail/call_controllers/mailbox_play_message_intro_controller_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Voicemail::MailboxPlayMessageIntroController do
+  include VoicemailControllerSpecHelper
+
+  let(:some_time) { Time.local 2012, 5, 1, 9, 0, 0 }
+  let(:message) do
+    {
+      id:       123,
+      from:     "+123",
+      received: some_time,
+      uri:      "file:///path/to/file.mp3"
+    }
+  end
+
+  before do
+    config.numeric_method = numeric_method
+    subject.should_receive(:current_message).and_return message
+  end
+
+  describe "#intro_message" do
+
+    after  { subject.intro_message }
+
+    context "with the default mode" do
+      let(:numeric_method) { :play_numeric}
+
+      it "plays the message introduction" do
+        should_play config.messages.message_received_on
+        subject.should_receive(:play_time).with some_time, format: config.datetime_format
+
+        should_play config.messages.from
+        subject.should_receive(:say_characters).with "123"
+      end
+    end
+
+    context "with ahnsay" do
+      let(:numeric_method) { :ahn_say }
+
+      it "plays the message introduction" do
+        should_play config.messages.message_received_on
+        subject.should_receive(:sounds_for_time).with(some_time, format: config.datetime_format).and_return ["timesounds", ".wav"]
+        should_play "timesounds", ".wav"
+
+        should_play config.messages.from
+        subject.should_receive(:sounds_for_digits).with("123").and_return ["digit1.wav", "digit2.wav"]
+        should_play "digit1.wav", "digit2.wav"
+      end
+    end
+
+    context "with i18n_string" do
+      let(:numeric_method) { :i18n_string }
+
+      it "plays the message introduction" do
+        flexmock(I18n).should_receive(:localize).with(some_time).and_return "some time"
+        flexmock(I18n).should_receive(:t).with("voicemail.messages.message_received_on_x", received_on: "some time").and_return "Message received on some time. "
+        flexmock(I18n).should_receive(:t).with("numbers.1").and_return "one "
+        flexmock(I18n).should_receive(:t).with("numbers.2").and_return "two "
+        flexmock(I18n).should_receive(:t).with("numbers.3").and_return "three"
+        flexmock(I18n).should_receive(:t).with("voicemail.messages.message_received_from_x", from: "one two three").and_return "Message received from one two three"
+
+        should_play "Message received on some time. "
+        should_play "Message received from one two three"
+      end
+    end
+  end
+
+  describe "#play_from_message with i18n_string and missing digit translations" do
+    let(:numeric_method) { :i18n_string }
+
+    after { subject.play_from_message }
+
+    it "falls back sanely" do
+      flexmock(I18n).should_receive(:t).with("numbers.1").and_return "translation missing"
+      flexmock(I18n).should_receive(:t).with("numbers.2").and_return "translation missing"
+      flexmock(I18n).should_receive(:t).with("numbers.3").and_return "translation missing"
+      flexmock(I18n).should_receive(:t).with("voicemail.messages.message_received_from_x", from: "123").and_return "Message received from 123."
+      should_play "Message received from 123."
+    end
+  end
+end

data/spec/voicemail/{mailbox_set_greeting_controller_spec.rb → call_controllers/mailbox_set_greeting_controller_spec.rb}

@@ -36,15 +36,33 @@ describe Voicemail::MailboxSetGreetingController do
     let(:recording_component) { flexmock 'Record' }
     let(:file_path) { "/path/to/file" }
 
-    it "plays the appropriate sounds, records, plays back recording, and calls the recording menu" do
+    before do
       should_play config.set_greeting.before_record
-      recording_component.should_receive("complete_event.recording.uri").and_return(file_path)
-      subject.should_receive(:record).once.with(config.set_greeting.recording.to_hash.merge(interruptible: true)).and_return recording_component
+      recording_component.should_receive("complete_event.recording.uri").and_return file_path
       subject.should_receive(:play_audio).with file_path
-      subject.should_receive(:menu).once.with(config.set_greeting.after_record,
-          { timeout: config.menu_timeout,
-            tries: config.menu_tries }, Proc)
+      subject.should_receive(:menu).once.with config.set_greeting.after_record, {timeout: config.menu_timeout, tries: config.menu_tries}, Proc
+    end
+
+    after do
       controller.record_greeting
+      config.use_mailbox_opts_for_recording = false
+    end
+
+    context "without mailbox settings" do
+      it "plays the appropriate sounds, records, plays back recording, and calls the recording menu" do
+        subject.should_receive(:record).once.with(config.recording.to_hash).and_return recording_component
+      end
+    end
+
+    context "with mailbox settings" do
+      let(:mailbox) { {id: 100, record_options: {final_timeout: 31}} }
+
+      before { config.use_mailbox_opts_for_recording = true }
+
+      it "records using the mailbox's record options" do
+        expected_options = {direction: :send, final_timeout: 31, interruptible: true, max_duration: 30, start_beep: true, stop_beep: false}
+        subject.should_receive(:record).once.with(expected_options).and_return recording_component
+      end
     end
   end
 

data/spec/voicemail/call_controllers/voicemail_controller_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Voicemail::VoicemailController do
+  include VoicemailControllerSpecHelper
+
+  describe "#run" do
+    context "with a missing mailbox parameter in metadata" do
+      let(:metadata) { Hash.new }
+
+      it "should raise an error if there is no mailbox in the metadata" do
+        subject.should_receive(:answer).once
+        expect { controller.run }.to raise_error ArgumentError
+      end
+    end
+
+    context "When when_to_answer is :after_greeting and there's no mailbox" do
+      let(:mailbox) { nil }
+
+      before { config.when_to_answer = :after_greeting  }
+      after  { config.when_to_answer = :before_greeting }
+
+      it "should not answer" do
+        should_play config.mailbox_not_found
+        subject.should_receive(:hangup).once
+        controller.run
+      end
+    end
+
+    context "with a present mailbox parameter in metadata" do
+      before { subject.should_receive(:answer).once }
+
+      context "with an invalid mailbox" do
+        let(:mailbox) { nil }
+
+        it "plays the mailbox not found message and hangs up" do
+          should_play config.mailbox_not_found
+          subject.should_receive(:hangup).once
+          controller.run
+        end
+      end
+
+      context "with an existing mailbox" do
+        before { subject.should_receive(:hangup).once }
+
+        context "without a greeting message" do
+          it "plays the default greeting if one is not specified" do
+            should_play config.default_greeting
+            subject.should_receive :record_message
+            controller.run
+          end
+        end
+
+        context "with a specified greeting message" do
+          let(:greeting_message) { "Howdy!" }
+
+          it "plays the specific greeting message" do
+            should_play greeting_message
+            subject.should_receive :record_message
+            controller.run
+          end
+        end
+      end
+    end
+  end
+
+  describe "#record_message" do
+    context "handling a recording" do
+      let(:recording_component) { flexmock 'Record' }
+      let(:recording_object)    { flexmock 'complete_event.recording', uri: "http://some_file.wav" }
+
+      after { subject.record_message }
+
+      context "without allow_rerecording" do
+        before { config.allow_rerecording = false }
+
+        it "saves the recording" do
+          recording_component.should_receive("complete_event.recording").and_return recording_object
+          subject.should_receive(:record).with(config.recording.to_hash).and_return recording_component
+          storage_instance.should_receive(:save_recording).with mailbox[:id], call.from, recording_object
+        end
+      end
+
+      context "without allow_rerecording" do
+        before { config.allow_rerecording = true }
+
+        it "sets up a callback, plays a menu, and eventually saves the message" do
+          call.should_receive :on_end
+          recording_object.should_receive :uri
+          subject.should_receive(:menu)
+          recording_component.should_receive("complete_event.recording").and_return recording_object
+          subject.should_receive(:record).with(config.recording.to_hash).and_return recording_component
+          storage_instance.should_receive(:save_recording).with mailbox[:id], call.from, recording_object
+        end
+      end
+    end
+  end
+end