voicemail 0.1.0

data/lib/voicemail/storage_pstore.rb

@@ -0,0 +1,93 @@
+require 'pstore'
+
+module Voicemail
+  class StoragePstore
+    attr_accessor :store
+
+    def initialize
+      @store = PStore.new config.storage.pstore_location
+      setup_schema
+    end
+
+    def get_mailbox(mailbox_id)
+      store.transaction true do
+        store[:mailboxes][mailbox_id]
+      end
+    end
+
+    def count_new_messages(mailbox_id)
+      store.transaction true do
+        store[:recordings][mailbox_id].size
+      end
+    end
+
+    def next_new_message(mailbox_id)
+      store.transaction true do
+        store[:recordings][mailbox_id].first
+      end
+    end
+
+    def archive_message(mailbox_id, message_id)
+      store.transaction do
+        item = store[:recordings][mailbox_id].select { |i| i[:id] == message_id }
+        rec = item.first
+        if rec
+          store[:archived][mailbox_id] << rec
+          store[:recordings][mailbox_id].delete(rec)
+        end
+      end
+    end
+
+    def delete_message(mailbox_id, message_id)
+      File.unlink(rec[:uri]) if File.exists?(rec[:uri])
+      store[:recordings][mailbox_id].delete(rec)
+    end
+
+    def save_greeting_for_mailbox(mailbox_id, recording_uri)
+      store.transaction do
+        store[:mailboxes][mailbox_id][:greeting_message] = recording_uri
+      end
+    end
+
+    def change_pin_for_mailbox(mailbox_id, new_pin)
+      store.transaction do
+        store[:mailboxes][mailbox_id][:pin] = new_pin
+      end
+    end
+
+    def save_recording(mailbox_id, from, recording_uri)
+      store.transaction do
+        recording = {
+          id:       SecureRandom.uuid,
+          from:     from,
+          received: Time.now,
+          uri:      recording_uri.gsub(/file:\/\//, '')
+        }
+        logger.fatal "store[:recordings][#{mailbox_id}] << recording"
+        store[:recordings][mailbox_id] << recording
+        logger.info "Saving recording: #{recording.inspect}"
+      end
+    end
+
+    def create_mailbox
+    end
+
+    private
+
+    def setup_schema
+      store.transaction do
+        store[:mailboxes]   ||= {}
+        store[:recordings]  ||= {}
+        store[:archived]    ||= {}
+
+        store[:mailboxes][1]  = {greeting_message: "Hello.", id: 1, pin: '1234'}
+        store[:recordings][1] ||= []
+        store[:archived][1] ||= []
+      end
+    end
+
+    def config
+      Voicemail::Plugin.config
+    end
+  end
+end

data/lib/voicemail/version.rb

@@ -0,0 +1,3 @@
+module Voicemail
+  VERSION = "0.1.0"
+end

data/lib/voicemail/voicemail_controller.rb

@@ -0,0 +1,32 @@
+module Voicemail
+  class VoicemailController < ApplicationController
+    def run
+      answer
+      if mailbox
+        play_greeting
+        handle_recording
+      else
+        mailbox_not_found
+      end
+    end
+
+    def play_greeting
+      play mailbox[:greeting_message] || config.default_greeting
+    end
+
+    def handle_recording
+      @from = call.from
+      record_comp = record config.recording.to_hash.merge(interruptible: true, max_duration: 30_000, direction: :recv)
+      save_recording record_comp.complete_event.recording.uri
+    end
+
+    def mailbox_not_found
+      play config.mailbox_not_found
+      hangup
+    end
+
+    def save_recording(uri)
+      storage.save_recording mailbox[:id], @from, uri
+    end
+  end
+end

data/lib/voicemail.rb

@@ -0,0 +1,14 @@
+module Voicemail; end
+require "voicemail/version"
+require "voicemail/storage_pstore"
+require "voicemail/storage"
+require "voicemail/application_controller"
+require "voicemail/voicemail_controller"
+require "voicemail/mailbox_controller"
+require "voicemail/mailbox_main_menu_controller"
+require "voicemail/mailbox_messages_controller"
+require "voicemail/mailbox_play_message_controller"
+require "voicemail/mailbox_set_greeting_controller"
+require "voicemail/mailbox_set_pin_controller"
+
+require "voicemail/plugin"

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'adhearsion'
+require 'flexmock'
+require 'voicemail'
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.tty = true
+
+  config.mock_framework = :flexmock
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/voicemail_controller_spec_helper.rb

@@ -0,0 +1,39 @@
+module VoicemailControllerSpecHelper
+  def self.included(test_case)
+    test_case.let(:from)    { "sip:user@server.com" }
+    test_case.let(:call)    { flexmock 'Call', from: from }
+    test_case.let(:config)  { Voicemail::Plugin.config }
+    test_case.let(:greeting_message) { nil }
+    test_case.let(:mailbox) do
+      {
+        id:               100,
+        pin:              1234,
+        greeting_message: greeting_message,
+        send_email:       true,
+        email_address:    'lpradovera@mojolingo.com'
+      }
+    end
+    test_case.let(:storage_instance) { flexmock 'StorageInstance' }
+    test_case.let(:metadata) do
+      { :mailbox => '100', :storage => storage_instance }
+    end
+
+    test_case.subject(:controller) { flexmock test_case.described_class.new(call, metadata) }
+
+    test_case.before(:each) do
+      storage_instance.should_receive(:get_mailbox).with(metadata[:mailbox]).and_return(mailbox)
+    end
+  end
+
+  def should_play(*args)
+    subject.should_receive(:play).once.tap { |exp| exp.with(*args) if args.count > 0 }
+  end
+
+  def should_ask(*args)
+    subject.should_receive(:ask).with(*args).once
+  end
+
+  def should_invoke(*args)
+    subject.should_receive(:invoke).once.with(*args)
+  end
+end

data/spec/voicemail/mailbox_controller_spec.rb

@@ -0,0 +1,79 @@
+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_main_menu_controller_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Voicemail::MailboxMainMenuController do
+  include VoicemailControllerSpecHelper
+
+  describe "#main_menu" do
+    it "calls #menu with the proper parameters" do
+      subject.should_receive(:menu).once.with(config.mailbox.menu_greeting,
+          { timeout: config.menu_timeout,
+            tries: config.menu_tries }, Proc)
+      controller.main_menu
+    end
+  end
+
+  describe "#set_greeting" do
+    it "invokes MailboxSetGreetingController" do
+      should_invoke Voicemail::MailboxSetGreetingController, mailbox: mailbox[:id]
+      controller.set_greeting
+    end
+  end
+
+  describe "#set_pin" do
+    it "invokes MailboxSetGreetingController" do
+      should_invoke Voicemail::MailboxSetPinController, mailbox: mailbox[:id]
+      controller.set_pin
+    end
+  end
+
+  describe "#listen_to_messages" do
+    it "invokes MailboxMessagesController" do
+      should_invoke Voicemail::MailboxMessagesController, mailbox: mailbox[:id]
+      controller.listen_to_messages
+    end
+  end
+end

data/spec/voicemail/mailbox_messages_controller_spec.rb

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,70 @@
+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(:execute).once.with("SayDigits", "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/mailbox_set_greeting_controller_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Voicemail::MailboxSetGreetingController do
+  include VoicemailControllerSpecHelper
+
+  describe "#section_menu" do
+    it "calls #menu with the proper parameters" do
+      subject.should_receive(:menu).once.with(config.set_greeting.prompt,
+          { timeout: config.menu_timeout,
+            tries: config.menu_tries }, Proc)
+      controller.section_menu
+    end
+  end
+
+  describe "#listen_to_current_greeting" do
+    context "without a greeting message" do
+      it "plays the default greeting if one is not specified" do
+        should_play config.set_greeting.no_personal_greeting
+        subject.should_receive(:section_menu).once.and_return(true)
+        controller.listen_to_current_greeting
+      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(:section_menu).once.and_return(true)
+        controller.listen_to_current_greeting
+      end
+    end
+  end
+
+  describe "#record_greeting" 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
+      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, max_duration: 30_000)).and_return(recording_component)
+      should_play file_path
+      subject.should_receive(:menu).once.with(config.set_greeting.after_record,
+          { timeout: config.menu_timeout,
+            tries: config.menu_tries }, Proc)
+      controller.record_greeting
+    end
+  end
+
+  describe "#save_greeting" do
+    let(:file_path) { "/path/to/file" }
+
+    it "saves the greeting and goes to the main menu" do
+      subject.should_receive(:temp_recording).once.and_return(file_path)
+      storage_instance.should_receive(:save_greeting_for_mailbox).with(mailbox[:id], file_path)
+      subject.should_receive(:main_menu)
+      controller.save_greeting
+    end
+  end
+end

data/spec/voicemail/mailbox_set_pin_controller_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Voicemail::MailboxSetPinController do
+  include VoicemailControllerSpecHelper
+
+  describe "#section_menu" do
+    it "calls #menu with the proper parameters" do
+      subject.should_receive(:menu).once.with(config.set_pin.menu,
+          { timeout: config.menu_timeout,
+            tries: config.menu_tries }, Proc)
+      controller.section_menu
+    end
+  end
+
+  describe "#set_pin" do
+    let(:pin)               { "4321" }
+    let(:not_matching_pin)  { "1234" }
+    let(:short_pin)         { "9" }
+
+    it "makes the user enter a PIN and repeat it" do
+      should_ask(config.set_pin.prompt, terminator: "#").and_return(pin).ordered
+      should_ask(config.set_pin.repeat_prompt, terminator: "#").and_return(pin).ordered
+      should_play(config.set_pin.change_ok).ordered
+      storage_instance.should_receive(:change_pin_for_mailbox).with(mailbox[:id], pin).once.ordered
+      subject.should_receive(:main_menu).once
+      controller.set_pin
+    end
+
+    it "makes the user start over if the PIN is too short" do
+      should_ask(config.set_pin.prompt, terminator: "#").and_return(short_pin).ordered
+      should_ask(config.set_pin.repeat_prompt, terminator: "#").and_return(short_pin).ordered
+      should_play(config.set_pin.pin_error).ordered
+      should_ask(config.set_pin.prompt, terminator: "#").and_return(pin).ordered
+      should_ask(config.set_pin.repeat_prompt, terminator: "#").and_return(pin).ordered
+      should_play(config.set_pin.change_ok).ordered
+      storage_instance.should_receive(:change_pin_for_mailbox).with(mailbox[:id], pin).once.ordered
+      subject.should_receive(:main_menu).once
+      controller.set_pin
+    end
+
+    it "makes the user start over if the PIN does not match confirmation" do
+      should_ask(config.set_pin.prompt, terminator: "#").and_return(pin).ordered
+      should_ask(config.set_pin.repeat_prompt, terminator: "#").and_return(not_matching_pin).ordered
+      should_play(config.set_pin.match_error).ordered
+      should_ask(config.set_pin.prompt, terminator: "#").and_return(pin).ordered
+      should_ask(config.set_pin.repeat_prompt, terminator: "#").and_return(pin).ordered
+      should_play(config.set_pin.change_ok).ordered
+      storage_instance.should_receive(:change_pin_for_mailbox).with(mailbox[:id], pin).once.ordered
+      subject.should_receive(:main_menu).once
+      controller.set_pin
+    end
+  end
+end

data/spec/voicemail/storage_pstore_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Voicemail
+  describe StoragePstore do
+    let(:mailbox) do
+      {
+        id:               100,
+        pin:              1234,
+        greeting_message: nil,
+        send_email:       true,
+        email_address:    'lpradovera@mojolingo.com'
+      }
+    end
+
+    let(:config) { Voicemail::Plugin.config }
+
+    subject :storage do
+      basedir = File.expand_path("../../../tmp/", __FILE__)
+      pstore_path = File.join(basedir, 'voicemail.pstore')
+      File.unlink(pstore_path) if File.exists?(pstore_path)
+      config.storage.pstore_location = pstore_path
+      StoragePstore.new.tap do |storage|
+        storage.store.transaction do
+          storage.store[:mailboxes][100] = mailbox
+        end
+        flexmock storage
+      end
+    end
+
+    it "is a PStore" do
+      storage.store.should be_a PStore
+    end
+
+    describe "#get_mailbox" do
+      it "returns the mailbox if it exists" do
+        storage.get_mailbox(100).should == mailbox
+      end
+
+      it "returns nil if the mailbox does not exist" do
+        storage.get_mailbox(400).should be_nil
+      end
+    end
+
+  end
+end

data/spec/voicemail/storage_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Voicemail::Storage do
+  describe "#instance" do
+    it "returns a StorageMain object" do
+      Voicemail::Storage.instance.should be_a Voicemail::StoragePstore
+    end
+
+    it "returns the same instance every time" do
+      Voicemail::Storage.instance.should be Voicemail::Storage.instance
+    end
+  end
+end