adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/host_definitions_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-require 'adhearsion/host_definitions'
-
-describe 'HostDefinition' do
-
-  after :each do
-    Adhearsion::HostDefinition.clear_definitions!
-  end
-
-  it 'when loading from a YAML array, it should pass each nested Hash to the constructor' do
-    hosts = [
-      {:host => "hostname1", :username => "user", :password => "password"},
-      {:host => "hostname2", :username => "user", :password => "password"},
-      {:host => "hostname3", :username => "user", :password => "password"}
-    ]
-    flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(hosts[0])
-    flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(hosts[1])
-    flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(hosts[2])
-    Adhearsion::HostDefinition.import_from_yaml hosts.to_yaml
-  end
-
-  it 'should set the @name property to a new UUID when no name is given' do
-    definition = {:host => "hostname", :username => "user", :password => "pass"}
-    Adhearsion::HostDefinition.new(definition).name.should =~ /^[a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}$/i
-  end
-
-  it 'when loading from YAML keys, it should pass each nested Hash to the constructor with the key as :name' do
-    definitions = { :pbx1 => {},
-                    :pbx2 => {},
-                    :pbx3 => {} }
-    definitions.each_pair do |key,value|
-      flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(value.merge(:name => key))
-    end
-    Adhearsion::HostDefinition.import_from_data_structure(definitions)
-  end
-
-  it 'should have an Array class variable named definitions' do
-    Adhearsion::HostDefinition.definitions.should be_a_kind_of Array
-  end
-
-  it 'should add each HostDefinition to a class variable named @@definitions when instantiated' do
-    Adhearsion::HostDefinition.definitions.size.should be 0
-    Adhearsion::HostDefinition.new :name => "foobar", :host => "hostname", :username => "user", :password => "password"
-    Adhearsion::HostDefinition.definitions.size.should be 1
-    Adhearsion::HostDefinition.clear_definitions!
-    Adhearsion::HostDefinition.definitions.size.should be 0
-  end
-
-  it 'should raise a HostDefinitionException when a password and a key are given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:username => "user", :host => "foobar", :key => "doesntmatter", :password => "pass")
-    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
-  end
-
-  it 'should raise a HostDefinitionException when no password or key is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:username => "user", :host => "foobar")
-    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
-  end
-
-  it 'should raise a HostDefinitionException when no username is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:host => "host", :password => "password")
-    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
-  end
-
-  it 'should raise a HostDefinitionException when no "host" key is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:username => "foobar", :password => "password")
-    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
-  end
-
-  it 'should raise a HostDefinitionException when an unrecognized key is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:username => "foobar", :password => "password", :host => "blah", :thiskeyisnotrecognized => nil)
-    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
-  end
-
-end

data/spec/adhearsion/initializer/configuration_spec.rb

@@ -1,291 +0,0 @@
-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
-    Adhearsion::Logging::AdhearsionLogger.outputters = [Log4r::Outputter.stdout]
-    Adhearsion::Logging::AdhearsionLogger.formatters = [Log4r::DefaultFormatter]
-  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
-
-  it 'outputters should be settable' do
-    Adhearsion::Logging::AdhearsionLogger.outputters.should == [Log4r::Outputter.stdout]
-    config.logging :outputters => Log4r::Outputter.stderr
-    Adhearsion::Logging::AdhearsionLogger.outputters.should == [Log4r::Outputter.stderr]
-  end
-
-  it 'formatters should be settable' do
-    Adhearsion::Logging::AdhearsionLogger.formatters.map(&:class).should == [Log4r::DefaultFormatter]
-    config.logging :formatters => Log4r::ObjectFormatter
-    Adhearsion::Logging::AdhearsionLogger.formatters.map(&:class).should == [Log4r::ObjectFormatter]
-  end
-
-  it 'a global formatter should be settable' do
-    Adhearsion::Logging::AdhearsionLogger.outputters << Log4r::Outputter.stdout
-    Adhearsion::Logging::AdhearsionLogger.formatters.map(&:class).should == [Log4r::DefaultFormatter, Log4r::DefaultFormatter]
-    config.logging :formatter => Log4r::ObjectFormatter
-    Adhearsion::Logging::AdhearsionLogger.formatters.map(&:class).should == [Log4r::ObjectFormatter, Log4r::ObjectFormatter]
-  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/adhearsion/initializer/loading_spec.rb

@@ -1,154 +0,0 @@
-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 expect_establish_connection
-    flexmock(ActiveRecord::Base).should_receive :establish_connection
-  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
-    expect_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]
-    expect_establish_connection
-    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