eric-adhearsion 0.7.999

data/spec/initializer/test_loading.rb

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

@@ -0,0 +1,43 @@
+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/silence.rb

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

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

data/spec/test_code_quality.rb

@@ -0,0 +1,87 @@
+# #!/usr/bin/env spec
+# 
+# # TODO: Forget regexps. Use Rubinius.
+# # This spec is somewhat unique. It essentially reads the code
+# # and ensures the best practices are followed.
+# 
+# # TODO: Create a be_a_proper_method_definition assertion
+# # TODO: Create a syntax checking spec
+# # TODO: Report code that has spaces between the dot when defining the method on an object
+# 
+# module CodeQualityHelper
+#   # TODO: Allow strings with a Hash in them before it
+#   
+#   BadMethodRegexp = /def\s+([$@]?[a-zA-Z_][\w_]*\s*\.\s*)?[a-zA-Z_][\w_]*[=!?]?[^(^\Z]/
+#   @root = File.dirname(__FILE__) + "/.."
+#   
+#   def ruby_files
+#     @ruby_files ||= Dir[@root + "/**/*.rb"].map { |f| File.expand_path f }
+#   end
+#   
+# end
+# 
+# describe "My 'bad method definition' finding regular expression" do
+#   
+#   # ATTENTION: If this spec ever blows up for a method definition it shouldn't,
+#   # please add the definition that caused it to explode here as an assertion.
+#   # It would also be nice to fix the regular expression too :)
+#   
+#   include CodeQualityHelper
+#   
+#   it "should NOT match method definitions with no arguments" do
+#     "def foo".should !~ CodeQualityHelper::BadMethodRegexp
+#     " def    monkey   ".should !~ CodeQualityHelper::BadMethodRegexp
+#     ' unless "#{bar}".empty? then def @zebra.spock '.should !~ CodeQualityHelper::BadMethodRegexp
+#   end
+#   
+#   it "should NOT match method definitions with arguments and parenthesis" do
+#     "def foo(bar)".should !~ CodeQualityHelper::BadMethodRegexp
+#     "\tdef $MONKEY . foo( bar, qaz = blam!) ".should !~ CodeQualityHelper::BadMethodRegexp
+#     "if(this) then def $MONKEY . foo( qaz = blam!, *args, &b) ".should !~ CodeQualityHelper::BadMethodRegexp
+#     " @something.each do |x| def something".should !~ CodeQualityHelper::BadMethodRegexp
+#   end
+#   
+#   it "should match method definitions with a space between the name and parenthesis" do
+#     "def foo (bar)".should =~ CodeQualityHelper::BadMethodRegexp
+#     "def  \t m \t (*args)".should =~ CodeQualityHelper::BadMethodRegexp
+#   end
+#   
+#   it "should match method definitions with no parenthesis around its arguments" do
+#     "def foo bar".should =~ CodeQualityHelper::BadMethodRegexp
+#     "\tif $x then def foo bar # Commentacular".should =~ CodeQualityHelper::BadMethodRegexp
+#   end
+# end
+# 
+# describe "All method definitions" do
+#   
+#   include CodeQualityHelper
+#   
+#   before:all do
+#     @root = File.dirname(__FILE__) + "/.."
+#   end
+#   
+#   it "should have parenthesis around their arguments" do
+#     ruby_files.each do |file|
+#       puts file
+#       File.read(file).grep(CodeQualityHelper::BadMethodRegexp).should be_empty
+#     end
+#   end
+# end
+# 
+# # describe "The syntax of all Ruby source files" do
+# #   
+# #   include CodeQualityHelper
+# #   
+# #   before:all do
+# #     @root = File.dirname(__FILE__) + "/.."
+# #   end
+# #   
+# #   it "should be valid" do
+# #     incorrect = ruby_files.map { |f| File.expand_path f }.select do |file|
+# #       `ruby -c #{file}`
+# #       not $?.success?
+# #     end
+# #     
+# #     incorrect.should be_empty
+# #   end
+# # end

data/spec/test_component_manager.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+context "Adding call context to components" do
+  include CallContextComponentTestHelpers
+  
+  attr_reader :sample_component
+  
+  setup do
+    @sample_component = new_componenet_class_named(sample_component_name)
+  end
+  
+  test "Component name is added to list of components that will have call contexts injected into them" do
+    components_with_call_context.should.be.empty
+    the_following_code {
+      sample_component.add_call_context
+    }.should.not.raise
+    
+    components_with_call_context.should.not.be.empty
+    Adhearsion::ComponentManager.components_with_call_context[sample_component_name].component_class.should.equal sample_component
+  end
+  
+  private
+    def components_with_call_context
+      Adhearsion::ComponentManager.components_with_call_context.keys
+    end
+    
+    def sample_component_name
+      'SampleComponent'
+    end
+end
+
+context "Referencing a component class in a dial plan context" do
+  include CallContextComponentTestHelpers
+  
+  test "the class constant should be available in the scope of a call context" do
+    sample_component_class = new_componenet_class_named('SampleComponent2')
+    sample_component_class.add_call_context
+
+    loader = load_dial_plan(<<-DIAL_PLAN)
+      some_context {
+        SampleComponent2
+      }
+    DIAL_PLAN
+    
+    flexmock(Adhearsion::DialPlan::Loader).should_receive(:load_dial_plan).and_return(loader)
+    tested_call = Adhearsion::Call.new(nil, :context => :some_context)
+    mock_config = flexmock 'a Configuration which communicates automatically_answer_incoming_calls properly',
+                    :automatically_answer_incoming_calls => false
+    flexmock(Adhearsion::Configuration).should_receive(:new).once.and_return mock_config
+    Adhearsion::Configuration.configure
+    
+    the_following_code {
+      handle(tested_call)
+    }.should.not.raise
+  end
+  
+  test "the call context is injected into any instances of the component class" do
+    sample_component_class = new_componenet_class_named('SampleComponent3')
+    sample_component_class.add_call_context :as => :call_context_variable_name
+
+    loader = load_dial_plan(<<-DIAL_PLAN)
+      some_context {
+        new_sample_component3.call_context_variable_name
+      }
+    DIAL_PLAN
+    
+    flexmock(Adhearsion::DialPlan::Loader).should_receive(:load_dial_plan).and_return(loader)
+    sample_call = Adhearsion::Call.new(nil, :context => :some_context)
+    mock_config = flexmock 'a Configuration which communicates automatically_answer_incoming_calls properly',
+                    :automatically_answer_incoming_calls => false
+    flexmock(Adhearsion::Configuration).should_receive(:new).once.and_return mock_config
+    Adhearsion::Configuration.configure
+    
+    the_following_code {
+      handle(sample_call)
+    }.should.not.raise
+  end
+  
+  private
+    def load_dial_plan(dial_plan_as_string)
+      Adhearsion::DialPlan::Loader.load(dial_plan_as_string)
+    end
+    
+    def handle(call)
+      Adhearsion::DialPlan::Manager.handle(call)
+    end
+end
+
+BEGIN {
+  module CallContextComponentTestHelpers
+    def new_componenet_class_named(component_name)
+      component_namespace = Adhearsion::Components::ComponentModule.new('passed in component does not matter here')
+      Adhearsion::Components::Component.prepare_component_class(component_namespace, component_name)
+      component_namespace.const_get(component_name)
+    end
+  end
+}

data/spec/test_constants.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+context "The Adhearsion module" do
+  # This test is of questionable benefit
+  test "should have a VERSION constant" do
+    assert(Adhearsion.const_defined?(:VERSION), "VERSION constant should be defined")
+  end
+end

data/spec/test_drb.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+# The way I envisoned publishing this DRb:
+#
+# publish :globally do/end
+# publish :with => :drb do/end
+
+context "Publishing an interface" do  
+  test "should be allowed with a class method" do
+    Class.new.class_eval do
+      include Adhearsion::Publishable
+      publish :through => :interface do
+        def self.bar
+          [1, 2, 3]
+        end
+      end
+    end
+    Adhearsion::DrbDoor.instance.interface.bar.should.equal [1, 2, 3]
+  end
+
+  test "should be allowed with an alternate interface" do
+    Class.new.class_eval do
+      include Adhearsion::Publishable
+      publish :through => :api do
+        def self.bar
+          [2, 3, 4]
+        end
+      end
+    end
+    Adhearsion::DrbDoor.instance.api.bar.should.equal [2, 3, 4]
+  end
+  
+  test "should be allowed with a metaclass block" do
+    Class.new.class_eval do
+      include Adhearsion::Publishable
+      publish :through => :interface do
+        class << self
+          def bar
+            [3, 2, 1]
+          end
+        end
+      end
+    end
+    Adhearsion::DrbDoor.instance.interface.bar.should.equal [3, 2, 1]
+  end
+  
+  test "should be allowed from within the metaclass block" do
+    # Class.new.class_eval do
+    #   include Publishable
+    #   class << self
+    #     publish :through => :interface do
+    #       def baz
+    #         [4, 5, 6]
+    #       end
+    #     end
+    #   end
+    # end
+    # Adhearsion::DrbDoor.instance.interface.baz.should.equal [4, 5, 6]
+  end
+end
+
+context "Invoking an interface" do
+  test "should raise an exception if the method is not found" do
+    the_following_code do
+      Adhearsion::DrbDoor.instance.interface.foobar.should.equal [1, 2, 3]
+    end.should.raise NoMethodError
+  end
+
+  test "should raise an exception if the interface is not found" do
+    the_following_code do
+      Adhearsion::DrbDoor.instance.bad_interface.bar.should.equal [1, 2, 3]
+    end.should.raise NoMethodError
+  end
+end
+
+context "Invoking an interface method via DRb" do
+  require 'drb'
+  before do
+    @door = DRb.start_service "druby://127.0.0.1:9050", Adhearsion::DrbDoor.instance
+  end
+
+  test "should return the proper result" do
+    client = DRbObject.new nil, DRb.uri
+    client.interface.bar.should.equal [3, 2, 1]
+  end
+
+  test "should raise an exception for a non-existent interface" do
+    client = DRbObject.new nil, DRb.uri
+    the_following_code do
+      client.interface.bad_interface.should.equal [3, 2, 1]
+    end.should.raise NoMethodError
+  end
+
+  test "should raise an exception for a non-existent method" do
+    client = DRbObject.new nil, DRb.uri
+    the_following_code do
+      client.interface.interface.foobar.equal [3, 2, 1]
+    end.should.raise NoMethodError
+  end
+
+  after do
+    DRb.stop_service
+  end
+end