voicemail 0.2.0 → 1.0.0.beta

data/spec/voicemail/mailbox_controller_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe Voicemail::MailboxController 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
-        expect { controller.run }.to raise_error ArgumentError
-      end
-    end
-
-    context "with a present mailbox parameter in metadata" do
-      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
-        it "plays the mailbox greeting message" do
-          should_play config.mailbox.greeting_message
-          subject.should_receive(:authenticate).and_return(true)
-          subject.should_receive(:play_number_of_messages).and_return(true)
-          subject.should_receive(:main_menu).and_return(true)
-          controller.run
-        end
-      end
-    end
-
-    describe "#authenticate" do
-      it "authenticates an user that enters the correct pin" do
-        should_ask(config.mailbox.please_enter_pin, terminator: "#", timeout: config.prompt_timeout).once.and_return(1234)
-        controller.authenticate.should == true
-      end
-
-      it "tell a user his pin is wrong and retries" do
-        subject.should_receive(:ask).times(2).and_return(1111, 1234)
-        should_play config.mailbox.pin_wrong
-        controller.authenticate.should == true
-      end
-
-      it "fails with a message if the user enters a wrong PIN the set number of times" do
-        subject.should_receive(:ask).times(3).and_return(1111, 2222, 3333)
-        subject.should_receive(:play).with(config.mailbox.pin_wrong).times(3)
-        controller.authenticate.should == false
-      end
-    end
-
-    describe "#play_number_of_messages" do
-      it "plays the number of new messages if there is at least one" do
-        storage_instance.should_receive(:count_new_messages).once.with(mailbox[:id]).and_return(3)
-        should_play(config.mailbox.number_before).ordered
-        subject.should_receive(:play_numeric).ordered.with(3)
-        should_play(config.mailbox.number_after).ordered
-        controller.play_number_of_messages
-      end
-
-      it "does play the no messages audio if there are none" do
-        storage_instance.should_receive(:count_new_messages).once.with(mailbox[:id]).and_return(0)
-        should_play(config.messages.no_new_messages).ordered
-        controller.play_number_of_messages
-      end
-    end
-
-    describe "#main_menu" do
-      it "passes to MainMenuController" do
-        subject.should_receive(:pass).once.with(Voicemail::MailboxMainMenuController, mailbox: mailbox[:id])
-        controller.main_menu
-      end
-    end
-  end
-end

data/spec/voicemail/mailbox_messages_controller_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-
-module Voicemail
-  describe MailboxMessagesController do
-    include VoicemailControllerSpecHelper
-
-    let(:call) { flexmock('Call') }
-    let(:config) { Voicemail::Plugin.config }
-    let(:metadata) do
-      { :mailbox => '100' }
-    end
-    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 => "/path/to/file"
-      }
-    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
-
-    describe "#message_loop" do
-      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
-        controller.message_loop
-      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
-        controller.message_loop
-      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]
-        controller.handle_message message
-      end
-    end
-  end
-end

data/spec/voicemail/mailbox_play_message_controller_spec.rb

@@ -1,70 +0,0 @@
-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:      "/path/to/file"
-    }
-  end
-
-  describe "#archive_message" do
-    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])
-      controller.archive_message
-    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).and_return(message)
-      should_play config.messages.message_received_on
-      subject.should_receive(:play_time).once.with(message[:received], format: config.datetime_format)
-      should_play config.messages.from
-      subject.should_receive(:say_characters).once.with "39335135335"
-      controller.intro_message
-    end
-  end
-
-  describe "#play_message" do
-    it "plays the message, followed by the menu" do
-      subject.should_receive(:current_message).once.and_return(message)
-      subject.should_receive(:menu).once.with(message[:uri], config.messages.menu,
-        { timeout: config.menu_timeout, tries: config.menu_tries }, Proc)
-      subject.play_message
-    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/voicemail_controller_spec.rb

@@ -1,76 +0,0 @@
-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 force_183 is set and there's no mailbox" do
-      let(:mailbox) { nil }
-
-      before { config.force_183 = true  }
-      after  { config.force_183 = false }
-
-      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
-        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(:handle_recording).and_return(true)
-            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(:handle_recording).and_return(true)
-            controller.run
-          end
-        end
-
-        context "handling a recording" do
-          let(:recording_component) { flexmock 'Record' }
-          let(:file_path)           { "/path/to/file" }
-
-          it "saves the recording" do
-            recording_component.should_receive("complete_event.recording.uri").and_return(file_path)
-            subject.should_receive(:record).with(config.recording.to_hash.merge(interruptible: true, direction: :recv)).and_return(recording_component)
-            storage_instance.should_receive(:save_recording).with(mailbox[:id], call.from, file_path)
-            should_play
-            controller.run
-          end
-        end
-      end
-    end
-  end
-end