sevenscale-adhearsion 0.7.1003 → 0.8.0

data/spec/initializer/test_configuration.rb

@@ -1,267 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-context "Configuration defaults" do
-  include ConfigurationTestHelper
-  attr_reader :config
-  
-  setup do
-    @config = default_config
-  end
-  
-  test "incoming calls are answered by default" do
-    assert config.automatically_answer_incoming_calls
-  end
-  
-  test "calls are ended when hung up" do
-    assert config.end_call_on_hangup
-  end
-  
-  test "if an error occurs, a call is hungup" do
-    assert config.end_call_on_error
-  end
-  
-  test "asterisk is enabled by default" do
-    assert config.asterisk_enabled?
-  end
-  
-  test "default asterisk configuration is available" do
-    assert_kind_of Adhearsion::Configuration::AsteriskConfiguration, config.asterisk
-  end
-  
-  test "database access is NOT enabled by default" do
-    assert !config.database_enabled?
-  end
-  
-  test "freeswith is NOT enabled by default" do
-    assert !config.freeswitch_enabled?
-  end
-  
-  test "AMI is NOT enabled by default" do
-    assert !config.asterisk.ami_enabled?
-  end
-  
-  test "Drb is NOT enabled by default" do
-    assert !config.drb_enabled?
-  end
-end
-
-context "Asterisk AGI configuration defaults" do
-  attr_reader :config
-  
-  setup do
-    @config = Adhearsion::Configuration::AsteriskConfiguration.new
-  end
-  
-  test "asterisk configuration sets default listening port" do
-    config.listening_port.should.equal Adhearsion::Configuration::AsteriskConfiguration.default_listening_port
-  end
-  
-  test "asterisk configuration sets default listening host" do
-    config.listening_host.should.equal Adhearsion::Configuration::AsteriskConfiguration.default_listening_host
-  end
-end
-
-context 'Logging configuration' do
-  
-  attr_reader :config
-  before :each do
-    @config = Adhearsion::Configuration.new
-  end
-  
-  after :each do
-    Adhearsion::Logging.logging_level = :fatal
-  end
-  
-  test 'the logging level should translate from symbols into Log4r constants' do
-    Adhearsion::Logging.logging_level.should.not.equal Log4r::WARN
-    config.logging :level => :warn
-    Adhearsion::Logging.logging_level.should.equal Log4r::WARN
-  end
-  
-end
-
-context "AMI configuration defaults" do
-  attr_reader :config
-  
-  setup do
-    @config = Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.new
-  end
-  
-  test "ami configuration sets default port" do
-    config.port.should.equal Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.default_port
-  end
-  
-  test "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
-
-context "Rails configuration defaults" do
-  test "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
-  
-  test "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
-  
-  test "should ensure that the environment provided is one supported by Rails" do
-    the_following_code {
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :this_is_not_a_rails_env
-    }.should.raise ArgumentError
-    
-    the_following_code {
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :development
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :production
-      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :test
-    }.should.not.raise ArgumentError
-  end
-  
-  test "should convert the environment into a Symbol" do
-    Adhearsion::Configuration::RailsConfiguration::SUPPORTED_RAILS_ENVIRONMENTS.should.not.be.empty
-    Adhearsion::Configuration::RailsConfiguration::SUPPORTED_RAILS_ENVIRONMENTS.each do |env|
-      config = Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => env.to_s
-      config.environment.should.equal env
-    end
-  end
-end
-
-context "Database configuration defaults" do
-  
-  setup 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.equal 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.equal sample_options.delete(:orm)
-    config.connection_options.should.equal sample_options
-  end
-end
-
-context "Freeswitch configuration defaults" do
-  attr_reader :config
-  
-  setup do
-    @config = Adhearsion::Configuration::FreeswitchConfiguration.new
-  end
-  
-  test "freeswitch configuration sets default listening port" do
-    config.listening_port.should.equal Adhearsion::Configuration::FreeswitchConfiguration.default_listening_port
-  end
-  
-  test "freeswitch configuration sets default listening host" do
-    config.listening_host.should.equal Adhearsion::Configuration::FreeswitchConfiguration.default_listening_host
-  end
-end
-
-context "Configuration scenarios" do
-  include ConfigurationTestHelper
-  
-  test "enabling AMI using all its defaults" do
-    config = enable_ami
-    
-    assert config.asterisk.ami_enabled?
-    config.asterisk.ami.should.be.kind_of Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration
-  end
-  
-  test "enabling AMI with custom configuration overrides the defaults" do
-    overridden_port = 911
-    config = enable_ami :port => overridden_port
-    config.asterisk.ami.port.should.equal overridden_port
-  end
-  
-  test "enabling Drb without any configuration" do
-    config = enable_drb
-    assert config.drb
-    config.drb.should.be.kind_of Adhearsion::Configuration::DrbConfiguration
-  end
-  
-  test "enabling Drb with a port specified sets the port" do
-    target_port = 911
-    config = enable_drb :port => target_port
-    config.drb.port.should.be.equal 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
-
-context "AHN_CONFIG" do
-  setup do
-    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
-  end
-  
-  test "Running configure sets configuration to Adhearsion::AHN_CONFIG" do
-    assert !Adhearsion.const_defined?(:AHN_CONFIG)
-    Adhearsion::Configuration.configure do |config|
-      # Nothing needs to happen here
-    end
-    
-    assert Adhearsion.const_defined?(:AHN_CONFIG)
-    Adhearsion::AHN_CONFIG.should.be.kind_of(Adhearsion::Configuration)
-  end
-end
-
-context "DRb configuration" do
-  test "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.equal :this_is_an_acl
-  end
-  
-  test "should, by default, allow only localhost connections" do
-    config = Adhearsion::Configuration::DrbConfiguration.new
-    config.acl.should == %w[allow 127.0.0.1]
-  end
-  
-  test "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
-  
-  test "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
-  
-  test "should have a default host and port" do
-    config = Adhearsion::Configuration::DrbConfiguration.new
-    config.host.should.not.equal nil
-    config.port.should.not.equal nil
-  end
-  
-end
-
-BEGIN {
-  module ConfigurationTestHelper
-    def default_config(&block)
-      Adhearsion::Configuration.new do |config|
-        config.enable_asterisk
-        yield config if block_given?
-      end
-    end
-  end
-}

data/spec/initializer/test_loading.rb

@@ -1,162 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-require 'adhearsion/initializer/database'
-require 'adhearsion/initializer/asterisk'
-require 'adhearsion/initializer/rails'
-require 'active_record'
-
-context "The database initializer" do
-  
-  include DatabaseInitializationTestHelper
-  
-  test "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
-  
-  test "should make any required models available in the main namespace" do
-    bogus_model = tempfile_with_contents sample_user_model
-    flexmock(Adhearsion::Initializer::DatabaseInitializer).should_receive(:all_models).and_return([bogus_model.path])
-    start_database_initializer
-    User.superclass.should.equal ActiveRecord::Base
-  end
-  
-  test 'should enable ActiveRecord concurrency' do
-    bogus_model = tempfile_with_contents sample_user_model
-    flexmock(Adhearsion::Initializer::DatabaseInitializer).should_receive(:all_models).and_return([bogus_model.path])
-    start_database_initializer
-    ActiveRecord::Base.send(:class_variable_get, :@@allow_concurrency).should.be true
-  end
-  
-end
-
-context "The Asterisk initializer" do
-  
-  include AsteriskInitializerTestHelper
-  
-  test "starts the AGI server" do
-    initialize_asterisk_with_defaults
-    flexmock(Adhearsion::VoIP::Asterisk::AGI::Server).new_instances.should_receive(:start).once
-  end
-  
-  test "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
-
-context "The Rails initializer" do
-  
-  include RailsInitializerTestHelper
-  
-  test "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
-  
-  test "should raise an exception if the database is initialized at the same time" do
-    flexmock(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
-  end
-  
-  test "should set the RAILS_ENV to be the argument passed in" do
-    flexmock(ENV).should_receive(:[]=).once.with("RAILS_ENV", "development")
-    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
-  end
-  
-  test 'should enable ActiveRecord concurrency' do
-    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :require
-    flexstub(Adhearsion::Initializer::RailsInitializer).should_receive :load_rails
-    stub_file_checking_methods!
-    stub_before_call_hook!
-    initialize_rails_with_options :rails_root => '/path/somewhere', :environment => :development
-    ActiveRecord::Base.send(:class_variable_get, :@@allow_concurrency).should.equal true
-  end
-  
-  test '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::Hooks::BeforeCall).should_receive(:create_hook).once
-    initialize_rails_with_options :rails_root => '/path/somewhere', :environment => :development
-  end
-  
-end
-
-BEGIN {
-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)
-    returning Tempfile.new("bogus_model") 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::Hooks::BeforeCall).should_receive :create_hook
-  end
-  
-end
-
-}

data/spec/initializer/test_paths.rb

@@ -1,43 +0,0 @@
-require File.dirname(__FILE__) + "/../test_helper"
-
-describe "Adhearsion::Paths" do
-  
-  #TODO: All this crap will go away
-  disabled_test "should find all files when given a glob" do
-    inside_initialized_app do |path|
-      tmps = %w"foo.rb BA\ R.gem _q_a_z_.c"
-      tmps.each { |f| FileUtils.touch "#{path}/helpers/#{f}" }
-      found_helpers = all_helpers
-      all_helpers.should.not.be.empty
-      all_helpers.map! {|f| File.basename f }
-      all_helpers.each { |f| all_helpers.should.include(f) }
-    end
-  end
-  test "should find files when several globs are given"
-
-  test "should allow the removal of path managers" do
-    Adhearsion::Paths.manager_for :helpers, :directory => "helpers"
-    Adhearsion::Paths.remove_manager_for :helpers
-  end
-end
-
-describe "The .ahnrc " do
-  test "should allow ERb"
-  test "should create methods for every path declared"
-  test "should add all_x and x_path methods to main namespace and pluralize names" do
-    Adhearsion::Paths.manager_for "helper", :directory => "helpers"
-    should.respond_to(:all_helpers)
-    should.respond_to(:helper_path)
-  end
-  test "should have an init key"
-  test "should allow a String to the init key"
-  test "should default the init key to config/startup.rb"
-  test "should allow an Array to the init key"
-end
-
-describe "Adhearsion's paths syntax sugar" do
-  test "should calculate helper paths properly"
-  test "should find log files properly"
-  test "should find helper config paths properly"
-  test "should return the configuration for a helper properly"
-end

data/spec/sample.rb

@@ -1,9 +0,0 @@
-events.ahn.before_call.each do |event|
-	defer :handle_something, :limit => 3 do
-	  event.
-	end
-end
-
-events.freeswitch.event_socket.each do |event|
-
-end

data/spec/silence.rb

@@ -1,10 +0,0 @@
-#
-# Seeing the dump of pending specs every time you run them is distracting.
-# This file lets you skip pending specs.
-class Test::Unit::TestResult
-  def add_disabled(name)
-    #nothing!
-  end
-end
-
-Adhearsion::Logging.silence!

data/spec/test_ahn_command.rb

@@ -1,149 +0,0 @@
-require File.dirname(__FILE__) + "/test_helper"
-require 'adhearsion/cli'
-
-module AhnCommandSpecHelper
-  def simulate_args(*args)
-    ARGV.clear
-    ARGV.concat args
-  end
-  
-  def capture_stdout(&block)
-    old = $stdout
-    $stdout = io = StringIO.new
-    yield
-  ensure
-    $stdout = old
-    return io.string
-  end
-  
-  def new_tmp_dir(filename=String.random)
-    File.join Dir.tmpdir, filename
-  end
-  
-  
-end
-
-context 'The Ahn Command helper' do
-  
-  include AhnCommandSpecHelper
-  
-  test "args are simulated properly" do
-    before = ARGV.clone
-    simulate_args "create", "/tmp/blah"
-    ARGV.should.not.equal before
-  end
-  
-  test "STDOUT should be captured" do
-    capture_stdout do
-      puts "wee"
-    end.should.equal "wee\n"
-  end
-  
-end
-
-context "A simulated use of the 'ahn' command" do
-  
-  include AhnCommandSpecHelper
-  
-  test "USAGE is defined" do
-    assert Adhearsion::CLI::AhnCommand.const_defined?('USAGE')
-  end
-  
-  test "arguments to 'create' are executed properly properly" do
-    some_path = "/path/somewhere"
-    simulate_args "create", some_path
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:create).once.with(some_path, :default)
-    capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
-  end
-  
-  test "arguments to 'start' are executed properly properly" do
-    some_path = "/tmp/blargh"
-    simulate_args "start", some_path
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(some_path, false, nil)
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-  
-  test "should execute arguments to 'start' for daemonizing properly" do
-    somewhere = "/tmp/blarghh"
-    simulate_args "start", 'daemon', somewhere
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(somewhere, true, nil)
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-  
-  test 'parse_arguments should recognize start with daemon properly' do
-    path = '/path/to/somesuch'
-    arguments = ["start", 'daemon', path]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, path, true, nil]
-  end
-  
-  test 'should recognize start with daemon and pid file properly' do
-    project_path  = '/second/star/on/the/right'
-    pid_file_path = '/straight/on/til/morning'
-    arguments = ["start", "daemon", project_path, "--pid-file=#{pid_file_path}"]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, project_path, true, pid_file_path]
-  end
-  
-  test 'parse_arguments should recognize start without daemon properly' do
-    path = '/path/to/somewhere'
-    arguments = ['start', path]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, path, false, nil]
-  end
-  
-  test "if no path is provided, running Ahn command blows up" do
-    the_following_code {
-      Adhearsion::CLI::AhnCommand.parse_arguments(['start'])
-    }.should.raise Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
-  end
-  
-  test "printing the version" do
-    capture_stdout do
-      simulate_args 'version'
-      Adhearsion::CLI::AhnCommand.execute!
-    end.should =~ Regexp.new(Regexp.escape(Adhearsion::VERSION::STRING))
-  end
-  
-  test "printing the help" do
-    capture_stdout do
-      simulate_args 'help'
-      Adhearsion::CLI::AhnCommand.execute!
-    end.should =~ Regexp.new(Regexp.escape(Adhearsion::CLI::AhnCommand::USAGE))
-  end
-  
-  test "reacting to unrecognized commands" do
-    the_following_code {
-      simulate_args "alpha", "beta"
-      Adhearsion::CLI::AhnCommand.execute!
-    }.should.raise(Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand)
-  end
-  
-  test "giving a path that doesn't contain a project raises an exception" do
-    the_following_code {
-      simulate_args "start", "/asjdfas/sndjfabsdfbqwb/qnjwejqbwh"
-      Adhearsion::CLI::AhnCommand.execute!
-    }.should.raise(Adhearsion::CLI::AhnCommand::CommandHandler::PathInvalid)
-  end
-  
-  test "giving an unrecognized project name raises an exception" do
-    the_following_code {
-      nonexistent_app_name, nonexistent_path = "a2n8y3gny2", "/tmp/qjweqbwas"
-      simulate_args "create:#{nonexistent_app_name}", nonexistent_path
-      Adhearsion::CLI::AhnCommand.execute!
-    }.should.raise Adhearsion::CLI::AhnCommand::CommandHandler::UnknownProject
-  end
-end
-
-context 'A real use of the "ahn" command' do
-  
-  include AhnCommandSpecHelper
-  
-  test "the 'create' command" do
-    the_following_code {
-      tmp_path = new_tmp_dir
-      simulate_args "create", tmp_path
-      RubiGen::Base.default_options.merge! :quiet => true
-      capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
-      File.exists?(File.join(tmp_path, ".ahnrc")).should.be true
-    }.should.not.raise
-  end
-  
-end