eric-adhearsion 0.7.999 → 0.8.0

data/spec/test_component_manager.rb

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

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

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

data/spec/test_helper.rb

@@ -1,94 +0,0 @@
-Dir.chdir File.join(File.dirname(__FILE__), '..')
-require 'rubygems'
-def require_or_report_dependency(require_name, gem_name)
-  begin
-    require require_name
-  rescue LoadError 
-    report_dependency!(gem_name)
-  end
-end
-
-def report_dependency!(name)
-  puts;puts 
-  puts "You need #{name} to run these tests:  gem install #{name}"
-  puts;puts
-  exit!
-end
-
-require_or_report_dependency('test/spec', 'test-spec')
-require_or_report_dependency('flexmock/test_unit', 'flexmock')
-require_or_report_dependency('active_support', 'activesupport')
-# require_or_report_dependency('ruby-debug', 'ruby-debug')
-require_or_report_dependency('rubigen', 'rubigen')
-
-require 'pp'
-require 'stringio'
-
-$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
-$: << File.expand_path('lib')
-$: << File.dirname(__FILE__)
-
-require 'adhearsion'
-class Adhearsion::Initializer
-  def asterisk_enabled?
-    false
-  end
-end
-
-
-
-
-class Test::Unit::TestCase  
-  
-  alias_method :the_following_code, :lambda
-  def self.test(*args, &block)
-    if block_given?
-      specify(args, &block)
-    else
-      disabled_test(*args)
-    end
-  end
-  
-  def self.disabled_test(*args, &block)
-    xspecify(*args, &block)
-  end
-  
-end
-
-module InitializerStubs
-  
-  UNWANTED_BEHAVIOR = {
-    Adhearsion::Initializer                       => [:initialize_log_file, :switch_to_root_directory, :daemonize!],
-    Adhearsion::Hooks::AfterInitialized.metaclass => [:create_hook, :trigger_hooks]
-  } unless defined? UNWANTED_BEHAVIOR
-  
-  def with_new_initializer_with_no_path_changing_behavior
-    stub_unwanted_behavior
-    Adhearsion::Initializer.new('path does not matter')
-    yield if block_given?
-    unstub_directory_changing_behavior
-  end
-  
-  def stub_unwanted_behavior
-    UNWANTED_BEHAVIOR.each do |stub_victim_class, undesired_methods|
-      undesired_methods.each do |undesired_method_name|
-        stub_victim_class.send(:alias_method, "pre_stubbed_#{undesired_method_name}", undesired_method_name)
-        stub_victim_class.send(:define_method, undesired_method_name) { |*args| }
-      end
-    end
-  end
-  
-  def unstub_directory_changing_behavior
-    UNWANTED_BEHAVIOR.each do |stub_victim_class, undesired_methods|
-      undesired_methods.each do |undesired_method_name|
-        stub_victim_class.send(:alias_method, undesired_method_name, "pre_stubbed_#{undesired_method_name}")
-      end
-    end
-  end
-end
-
-Adhearsion::Initializer.ahn_root = File.dirname(__FILE__) + '/fixtures'
-require 'spec/silence' unless ENV['SHOW_DISABLED']
-
-require 'adhearsion/voip/asterisk'
-require 'adhearsion/component_manager'

data/spec/test_hooks.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + "/test_helper.rb"
-
-# context "Adhearsion::Hooks::TearDown when initializing a project" do
-#   include InitializerStubs
-#   test "should trap TERM and INT signals" do
-#     flexmock(Adhearsion::Hooks::TearDown).should_receive(:catch_termination_signals).at_least.once
-#     with_new_initializer_with_no_path_changing_behavior {}
-#   end
-# end
-
-# module StandardHookBehavior
-#   def test_standard_hook_behavior
-#     @hook.should.respond_to(:trigger_hooks)
-#     @hook.should.respond_to(:create_hook)
-#   end
-# end
-
-# for hook in Adhearsion::Hooks.constants.map { |c| (Adhearsion::Hooks.const_get c) }
-#   describe hook.to_s do
-#     include StandardHookBehavior
-#     before(:each) { @hook = hook }
-#   end
-# end
-
-context "A HookWithArguments" do
-  test "should pass the arguments to trigger_hooks() along to each registered block" do
-    hook_manager = Adhearsion::Hooks::HookWithArguments.new
-    hook_manager.create_hook do |foo, bar|
-      foo.should.equal :foo
-      bar.should.equal :bar
-      throw :inside_hook
-    end
-    the_following_code {
-      hook_manager.trigger_hooks(:foo, :bar)
-    }.should.throw :inside_hook
-  end
-end

data/spec/test_host_definitions.rb

@@ -1,79 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper.rb')
-require 'adhearsion/host_definitions'
-
-context 'HostDefinition' do
-  
-  after :each do
-    Adhearsion::HostDefinition.clear_definitions!
-  end
-  
-  test '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
-  
-  test '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
-  
-  test '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
-  
-  test 'should have an Array class variable named definitions' do
-    Adhearsion::HostDefinition.definitions.should.be.kind_of Array
-  end
-  
-  test 'should add each HostDefinition to a class variable named @@definitions when instantiated' do
-    Adhearsion::HostDefinition.definitions.size.should.equal 0
-    Adhearsion::HostDefinition.new :name => "foobar", :host => "hostname", :username => "user", :password => "password"
-    Adhearsion::HostDefinition.definitions.size.should.equal 1
-    Adhearsion::HostDefinition.clear_definitions!
-    Adhearsion::HostDefinition.definitions.size.should.equal 0
-  end
-  
-  test '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 Adhearsion::HostDefinition::HostDefinitionException
-  end
-  
-  test 'should raise a HostDefinitionException when no password or key is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:username => "user", :host => "foobar")
-    }.should.raise Adhearsion::HostDefinition::HostDefinitionException
-  end
-  
-  test 'should raise a HostDefinitionException when no username is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:host => "host", :password => "password")
-    }.should.raise Adhearsion::HostDefinition::HostDefinitionException
-  end
-  
-  test 'should raise a HostDefinitionException when no "host" key is given' do
-    the_following_code {
-      Adhearsion::HostDefinition.new(:username => "foobar", :password => "password")
-    }.should.raise Adhearsion::HostDefinition::HostDefinitionException
-  end
-  
-  test '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 Adhearsion::HostDefinition::HostDefinitionException
-  end
-  
-end

data/spec/test_initialization.rb

@@ -1,105 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "Adhearsion::Initializer" do
-  
-  include InitializerStubs
-  # TODO: create a specification for aliases
-  
-  before :each do
-    Adhearsion.send(:remove_const, 'AHN_CONFIG') if Adhearsion.const_defined? 'AHN_CONFIG'
-    Adhearsion::AHN_CONFIG = Adhearsion::Configuration.new
-  end
-  
-  test "initialization will start with only a path given" do
-    with_new_initializer_with_no_path_changing_behavior do
-      Adhearsion::Initializer.new path
-    end
-  end
- 
-  test "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
-    with_new_initializer_with_no_path_changing_behavior do
-       flexmock(File).should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w', Proc)
-       ahn = Adhearsion::Initializer.new path, :pid_file => true
-       ahn.pid_file[0, path.length].should.equal(path)
-     end
-   end
-   
-   test "should NOT create a pid file in the app's path when given 'false' as the pid_file hash key argument" do
-     with_new_initializer_with_no_path_changing_behavior do
-       ahn = Adhearsion::Initializer.new path, :pid_file => false
-       assert_nil ahn.pid_file
-     end
-   end
-   
-   test "should create a pid file in the app's path by default when daemonizing" do
-     with_new_initializer_with_no_path_changing_behavior do
-       flexmock(File).should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w', Proc)
-       ahn = Adhearsion::Initializer.new path, :daemon => true
-       ahn.pid_file[0, path.size].should.equal(path)
-     end
-   end
-   
-   test "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
-     with_new_initializer_with_no_path_changing_behavior do
-       ahn = Adhearsion::Initializer.new path, :daemon => true, :pid_file => false
-       assert_nil ahn.pid_file
-     end
-   end
-   
-   test "should create a designated pid file when supplied a String path as :pid_file" do
-     random_file = "/tmp/AHN_TEST_#{rand 100000}.pid"
-     with_new_initializer_with_no_path_changing_behavior do
-       ahn = Adhearsion::Initializer.new path, :pid_file => random_file
-       ahn.pid_file.should.equal(random_file)
-       assert File.exists?(random_file)
-       File.delete random_file
-     end
-   end
-   
-   private
-     def path
-       '/any/ole/path'
-     end
-end
-
-context "AHN_ROOT" do
-  include InitializerStubs
-  setup do
-    Object.send(:remove_const, :AHN_ROOT) if defined? AHN_ROOT
-  end
-  
-  test "initializing will create the AHN_ROOT" do
-    with_new_initializer_with_no_path_changing_behavior do
-      ahn = Adhearsion::Initializer.new path
-      assert Object.constants.include?("AHN_ROOT")
-    end
-  end
-  
-  test "swapping out the base_path for the duration of the block" do
-    original_base_path = '.'
-    temporary_base     = '/foo'
-    
-    path = Adhearsion::PathString.new(original_base_path)
-    path.should.equal original_base_path
-    
-    path.using_base_path temporary_base do
-      path.should.equal temporary_base
-    end
-    path.should.equal original_base_path
-  end
-
-  test "creating the AHN_ROOT will set defaults" do
-    with_new_initializer_with_no_path_changing_behavior do
-      ahn = Adhearsion::Initializer.new path
-      full_path = File.expand_path(path)
-      AHN_ROOT.to_s.should.equal(full_path)
-      AHN_ROOT.component_path.should.equal(File.join(full_path, "components"))
-      AHN_ROOT.log_path.should.equal(File.join(full_path, "logs"))
-      AHN_ROOT.dialplan_path.should.equal(full_path)
-    end
-  end
-  private
-    def path
-      '/any/ole/path'
-    end
-end