adhearsion 1.0.1 → 1.0.2

data/spec/initializer/configuration_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+
+module ConfigurationTestHelper
+  def default_config(&block)
+    Adhearsion::Configuration.new do |config|
+      config.enable_asterisk
+      yield config if block_given?
+    end
+  end
+end
+
+describe "Configuration defaults" do
+  include ConfigurationTestHelper
+  attr_reader :config
+
+  before(:each) do
+    @config = default_config
+  end
+
+  it "incoming calls are answered by default" do
+    config.automatically_answer_incoming_calls.should be true
+  end
+
+  it "calls are ended when hung up" do
+    config.end_call_on_hangup.should be true
+  end
+
+  it "if an error occurs, a call is hungup" do
+    config.end_call_on_error.should be true
+  end
+
+  it "asterisk is enabled by default" do
+    config.asterisk_enabled?.should be true
+  end
+
+  it "default asterisk configuration is available" do
+    config.asterisk.kind_of?(Adhearsion::Configuration::AsteriskConfiguration).should be true
+  end
+
+  it "database access is NOT enabled by default" do
+    config.database_enabled?.should be false
+  end
+
+  it "ldap access is NOT enabled by default" do
+    config.ldap_enabled?.should be false
+  end
+
+  it "freeswith is NOT enabled by default" do
+    config.freeswitch_enabled?.should be false
+  end
+
+  it "AMI is NOT enabled by default" do
+    config.asterisk.ami_enabled?.should be false
+  end
+
+  it "Drb is NOT enabled by default" do
+    config.drb_enabled?.should be false
+  end
+
+  it "XMPP is NOT enabled by default" do
+    config.xmpp_enabled?.should be false
+  end
+end
+
+describe "Asterisk AGI configuration defaults" do
+  attr_reader :config
+
+  before(:each) do
+    @config = Adhearsion::Configuration::AsteriskConfiguration.new
+  end
+
+  it "asterisk configuration sets default listening port" do
+    config.listening_port.should be Adhearsion::Configuration::AsteriskConfiguration.default_listening_port
+  end
+
+  it "asterisk configuration sets default listening host" do
+    config.listening_host.should == Adhearsion::Configuration::AsteriskConfiguration.default_listening_host
+  end
+end
+
+describe 'Logging configuration' do
+
+  attr_reader :config
+  before :each do
+    @config = Adhearsion::Configuration.new
+  end
+
+  after :each do
+    Adhearsion::Logging.logging_level = :fatal
+  end
+
+  it 'the logging level should translate from symbols into Log4r constants' do
+    Adhearsion::Logging.logging_level.should_not be Log4r::WARN
+    config.logging :level => :warn
+    Adhearsion::Logging.logging_level.should be Log4r::WARN
+  end
+
+end
+
+describe "AMI configuration defaults" do
+  attr_reader :config
+
+  before(:each) do
+    @config = Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.new
+  end
+
+  it "ami configuration sets default port" do
+    config.port.should be Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.default_port
+  end
+
+  it "ami allows you to configure a username and a password, both of which default to nil" do
+    config.username.should be nil
+    config.password.should be nil
+  end
+end
+
+describe "Rails configuration defaults" do
+  it "should require the path to the Rails app in the constructor" do
+    config = Adhearsion::Configuration::RailsConfiguration.new :path => "path here doesn't matter right now", :env => :development
+    config.rails_root.should_not be nil
+  end
+
+  it "should expand_path() the first constructor parameter" do
+    rails_root = "gui"
+    flexmock(File).should_receive(:expand_path).once.with(rails_root)
+    config = Adhearsion::Configuration::RailsConfiguration.new :path => rails_root, :env => :development
+  end
+end
+
+describe "Database configuration defaults" do
+
+  before(:each) do
+    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
+    Adhearsion::Configuration.configure {}
+  end
+
+  it "should store the constructor's argument in connection_options()" do
+    sample_options = { :adapter => "sqlite3", :dbfile => "foo.sqlite3" }
+    config = Adhearsion::Configuration::DatabaseConfiguration.new(sample_options)
+    config.connection_options.should be sample_options
+  end
+  it "should remove the :orm key from the connection options" do
+    sample_options = { :orm => :active_record, :adapter => "mysql", :host => "::1",
+                       :user => "a", :pass => "b", :database => "ahn" }
+    config = Adhearsion::Configuration::DatabaseConfiguration.new(sample_options.clone)
+    config.orm.should be sample_options.delete(:orm)
+    config.connection_options.should == sample_options
+  end
+end
+
+describe "Freeswitch configuration defaults" do
+  attr_reader :config
+
+  before(:each) do
+    @config = Adhearsion::Configuration::FreeswitchConfiguration.new
+  end
+
+  it "freeswitch configuration sets default listening port" do
+    config.listening_port.should be Adhearsion::Configuration::FreeswitchConfiguration.default_listening_port
+  end
+
+  it "freeswitch configuration sets default listening host" do
+    config.listening_host.should == Adhearsion::Configuration::FreeswitchConfiguration.default_listening_host
+  end
+end
+
+describe "XMPP configuration defaults" do
+  attr_reader :config
+
+  it "xmpp configuration sets default port when server is set, but no port" do
+    config = Adhearsion::Configuration::XMPPConfiguration.new :jid => "test@example.com", :password => "somepassword", :server => "example.com"
+    config.port.should be Adhearsion::Configuration::XMPPConfiguration.default_port
+  end
+
+  it "should raise when port is specified, but no server" do
+    begin
+      config = Adhearsion::Configuration::XMPPConfiguration.new :jid => "test@example.com", :password => "somepassword", :port => "5223"
+    rescue ArgumentError => e
+      e.message.should == "Must supply a :server argument as well as :port to the XMPP initializer!"
+    end
+  end
+end
+
+describe "Configuration scenarios" do
+  include ConfigurationTestHelper
+
+  it "enabling AMI using all its defaults" do
+    config = enable_ami
+
+    config.asterisk.ami_enabled?.should be true
+    config.asterisk.ami.should be_a_kind_of Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration
+  end
+
+  it "enabling AMI with custom configuration overrides the defaults" do
+    overridden_port = 911
+    config = enable_ami :port => overridden_port
+    config.asterisk.ami.port.should be overridden_port
+  end
+
+  it "enabling Drb without any configuration" do
+    config = enable_drb
+    config.drb.should_not be nil
+    config.drb.should be_a_kind_of Adhearsion::Configuration::DrbConfiguration
+  end
+
+  it "enabling Drb with a port specified sets the port" do
+    target_port = 911
+    config = enable_drb :port => target_port
+    config.drb.port.should == target_port
+  end
+
+  private
+    def enable_ami(*overrides)
+      default_config do |config|
+        config.asterisk.enable_ami(*overrides)
+      end
+    end
+
+    def enable_drb(*overrides)
+      default_config do |config|
+        config.enable_drb *overrides
+      end
+    end
+end
+
+describe "AHN_CONFIG" do
+  before(:each) do
+    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
+  end
+
+  it "Running configure sets configuration to Adhearsion::AHN_CONFIG" do
+    Adhearsion.const_defined?(:AHN_CONFIG).should be false
+    Adhearsion::Configuration.configure do |config|
+      # Nothing needs to happen here
+    end
+
+    Adhearsion.const_defined?(:AHN_CONFIG).should be true
+    Adhearsion::AHN_CONFIG.should be_a_kind_of(Adhearsion::Configuration)
+  end
+end
+
+describe "DRb configuration" do
+  it "should not add any ACL rules when :raw_acl is passed in" do
+    config = Adhearsion::Configuration::DrbConfiguration.new :raw_acl => :this_is_an_acl
+    config.acl.should be :this_is_an_acl
+  end
+
+  it "should, by default, allow only localhost connections" do
+    config = Adhearsion::Configuration::DrbConfiguration.new
+    config.acl.should == %w[allow 127.0.0.1]
+  end
+
+  it "should add ACL 'deny' rules before 'allow' rules" do
+    config = Adhearsion::Configuration::DrbConfiguration.new :allow => %w[1.1.1.1  2.2.2.2],
+                                                             :deny  => %w[9.9.9.9]
+    config.acl.should == %w[deny 9.9.9.9 allow 1.1.1.1 allow 2.2.2.2]
+  end
+
+  it "should allow both an Array and a String to be passed as an allow/deny ACL rule" do
+    config = Adhearsion::Configuration::DrbConfiguration.new :allow => "1.1.1.1", :deny => "9.9.9.9"
+    config.acl.should == %w[deny 9.9.9.9 allow 1.1.1.1]
+  end
+
+  it "should have a default host and port" do
+    config = Adhearsion::Configuration::DrbConfiguration.new
+    config.host.should_not be nil
+    config.port.should_not be nil
+  end
+
+end

data/spec/initializer/loading_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+require 'adhearsion/initializer/database'
+require 'adhearsion/initializer/asterisk'
+require 'adhearsion/initializer/rails'
+require 'adhearsion/initializer/xmpp'
+require 'active_record'
+
+module DatabaseInitializationTestHelper
+
+  def start_database_initializer
+    start_database_initializer_with_options :adapter => "sqlite3", :dbfile => "foobar.sqlite3"
+  end
+
+  def start_database_initializer_with_options(options)
+    Adhearsion::Configuration.configure { |config| config.enable_database(options) }
+    Adhearsion::Initializer::DatabaseInitializer.start
+  end
+
+  def tempfile_with_contents(contents)
+    Tempfile.new("bogus_model").tap do |file|
+      file.puts contents
+      file.flush
+    end
+  end
+
+  def sample_user_model
+    <<-CODE
+      class User < ActiveRecord::Base
+        validates_uniqueness_of :name
+      end
+    CODE
+  end
+end
+
+module AsteriskInitializerTestHelper
+  def initialize_asterisk_with_defaults
+    initialize_asterisk_with_options Hash.new
+  end
+  def initialize_asterisk_with_options(options)
+    flexmock(Adhearsion::Initializer::AsteriskInitializer).should_receive(:join_server_thread_after_initialized)
+    Adhearsion::Configuration.configure { |config| config.enable_asterisk(options) }
+    Adhearsion::Initializer::AsteriskInitializer.start
+  end
+end
+
+module RailsInitializerTestHelper
+
+  def initialize_rails_with_options(options)
+    rails_options = flexmock "Rails options mock", options
+    flexstub(Adhearsion::AHN_CONFIG).should_receive(:rails).once.and_return(rails_options)
+    Adhearsion::Initializer::RailsInitializer.start
+  end
+
+  def stub_file_checking_methods!
+    flexstub(File).should_receive(:directory?).and_return true
+    flexstub(File).should_receive(:exists?).and_return true
+  end
+
+  def stub_before_call_hook!
+    flexstub(Adhearsion::Events.framework_theatre).should_receive(:register_namespace_name).with([:asterisk, :before_call]).and_return
+  end
+
+end
+
+describe "The database initializer" do
+
+  include DatabaseInitializationTestHelper
+
+  after :each do
+    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined? :AHN_CONFIG
+  end
+
+  it "starts a connection through ActiveRecord" do
+    connection_options = { :adapter => "sqlite3",
+                           :dbfile => "foo.sqlite3" }
+    flexmock(Adhearsion::Initializer::DatabaseInitializer).should_receive(:require_models).once
+    flexmock(ActiveRecord::Base).should_receive(:establish_connection).with(connection_options)
+
+    start_database_initializer_with_options connection_options
+  end
+
+  it "should make any required models available in the main namespace" do
+    bogus_model = tempfile_with_contents sample_user_model
+    flexmock(Adhearsion::Configuration).new_instances.should_receive(:files_from_setting).once.
+        with("paths", "models").and_return [bogus_model.path]
+    start_database_initializer
+    User.superclass.should be ActiveRecord::Base
+  end
+
+end
+
+describe "The Asterisk initializer" do
+
+  include AsteriskInitializerTestHelper
+
+  it "starts the AGI server" do
+    initialize_asterisk_with_defaults
+    flexmock(Adhearsion::VoIP::Asterisk::AGI::Server).new_instances.should_receive(:start).once
+  end
+
+  it "starts the AGI server with any overridden settings" do
+    overrides        = {:host => "127.0.0.1", :port => 7788}
+    config_overrides = {:listening_host => overrides[:host], :listening_port => overrides[:port]}
+    initialize_asterisk_with_options config_overrides
+    flexmock(Adhearsion::VoIP::Asterisk::AGI::Server).new_instances.should_receive(:start).once.with(overrides)
+  end
+
+end
+
+describe "The Rails initializer" do
+
+  include RailsInitializerTestHelper
+
+  it "should load the config/environment.rb file within the rails_root path" do
+    rails_root     = "/path/to/rails/app"
+    environment_rb = rails_root + '/config/environment.rb'
+    flexmock(Adhearsion::Initializer::RailsInitializer).should_receive(:require).once.with environment_rb
+    stub_file_checking_methods!
+    stub_before_call_hook!
+    initialize_rails_with_options :rails_root => rails_root, :environment => :development
+  end
+
+  it "should raise an exception if the database is initialized at the same time" do
+    flexstub(Adhearsion::AHN_CONFIG).should_receive(:database_enabled?).and_return true
+    flexmock(Adhearsion::Initializer::RailsInitializer).should_receive(:require).and_return
+    stub_file_checking_methods!
+    stub_before_call_hook!
+    the_following_code {
+      initialize_rails_with_options :rails_root => '/tmp', :environment => :development
+    }.should raise_error
+  end
+
+  it "should set the RAILS_ENV to be the argument passed in" do
+    flexmock(Adhearsion::Initializer::RailsInitializer).should_receive(:require).once.and_return
+    stub_file_checking_methods!
+    stub_before_call_hook!
+    initialize_rails_with_options :rails_root => '/tmp', :environment => :development
+    raise Test::Unit::AssertionFailed, 'ENV["RAILS_ENV"] should have been set but was not.' unless ENV['RAILS_ENV'] == "development"
+  end
+
+  it 'should create a BeforeCall hook (presumably to verify the active connections)' do
+    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :require
+    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :load_rails
+    stub_file_checking_methods!
+    flexmock(Adhearsion::Events).should_receive(:register_callback).once.with([:asterisk, :before_call], Proc)
+    initialize_rails_with_options :rails_root => '/path/somewhere', :environment => :development
+  end
+
+end

data/spec/initializer/paths_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module PathsTestHelper
+  def mock_ahnrc_with(raw_yaml)
+    Adhearsion::AHN_CONFIG.ahnrc = raw_yaml
+  end
+end
+
+describe "Files from config" do
+
+  include PathsTestHelper
+
+  it "the old way of doing paths should not still be around" do
+    should_not respond_to(:all_helpers)
+    should_not respond_to(:helper_path)
+  end
+
+  it "should work when only one filename is present" do
+    mock_ahnrc_with "paths:\n    init: foobar.rb"
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_glob).once.with("foobar.rb").and_return "foobar.rb"
+    Adhearsion::AHN_CONFIG.files_from_setting("paths", "init").should ==["foobar.rb"]
+  end
+
+  it "should only expand a glob if the filename contains *"
+
+  it "should work when an Array of filenames is present" do
+    files = %w[jay.rb thomas.rb phillips.rb]
+    flexstub(Dir).should_receive(:glob).with(*files).and_return(*files)
+    yaml = <<-YML
+paths:
+  init:
+#{
+    files.map { |f| "    - #{f}" }.join("\n")
+}
+    YML
+    Adhearsion::AHN_CONFIG.ahnrc = yaml
+
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_glob).once.with("jay.rb").and_return "jay.rb"
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_glob).once.with("thomas.rb").and_return "thomas.rb"
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_glob).once.with("phillips.rb").and_return "phillips.rb"
+
+    Adhearsion::AHN_CONFIG.files_from_setting("paths", "init").should == files
+  end
+
+  it "should work when one glob filename is present" do
+    files = %w[foo.rb bar.rb qaz.rb]
+    flexmock(Dir).should_receive(:glob).once.with(/\*.rb$/).and_return files
+    yaml = <<-YML
+    paths:
+      init:
+        -*.rb
+    YML
+    Adhearsion::AHN_CONFIG.ahnrc = yaml
+    Adhearsion::AHN_CONFIG.files_from_setting("paths", "init").should == %w[foo.rb bar.rb qaz.rb]
+  end
+
+  it "should work when an Array of globs are present" do
+    files = %w[aaa.rb aba.rb aca.rb]
+    flexstub(Dir).should_receive(:glob).with(*files).and_return(*files)
+    yaml = <<-YML
+paths:
+  init:
+#{
+    files.map { |filename| "    - #{filename}" }.join("\n") + "\n"
+}
+    YML
+    Adhearsion::AHN_CONFIG.ahnrc = yaml
+    files.each do |file|
+      flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_glob).once.with(file).and_return file
+    end
+    Adhearsion::AHN_CONFIG.files_from_setting("paths", "init").should == files
+  end
+
+end