sevenscale-adhearsion 0.7.1000

data/spec/test_helper.rb

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

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

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

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

data/spec/test_logging.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+context 'The ahn_log command' do
+  
+  test 'should add the ahn_log method to the global namespace' do
+    ahn_log.should.be Adhearsion::Logging::DefaultAdhearsionLogger
+  end
+  
+  test "should log to the standard Adhearsion logger when given arguments" do
+    message = "o hai. ur home erly."
+    flexmock(Log4r::Logger['ahn']).should_receive(:info).once.with(message)
+    ahn_log message
+  end
+  
+  test 'should create a new logger when given method_missing' do
+    ahn_log.micromenus 'danger will robinson!'  
+    Log4r::Logger['micromenus'].should.not.be nil
+  end
+  
+  test 'should define a singleton method on itself of any name found by method_missing' do
+    ahn_log.agi "SOMETHING IMPORTANT HAPPENED"
+    Adhearsion::Logging::AdhearsionLogger.instance_methods.should.include 'agi'
+  end
+  
+  test "dynamically generated loggers should support logging with blocks" do
+    # I had to comment out this test because Flexmock makes it impossible to#
+    # set up an expectation for receiving blocks.
+    
+    # proc_to_log = lambda { [1,2,3].reverse.join }
+    # 
+    # info_catcher = flexmock "A logger that responds to info()"
+    # info_catcher.should_receive(:info).once.with(&proc_to_log)
+    # 
+    # flexmock(Log4r::Logger).should_receive(:[]).with('log4r')
+    # flexmock(Log4r::Logger).should_receive(:[]).once.with('ami').and_return info_catcher
+    # 
+    # ahn_log.ami(&proc_to_log)
+  end
+  
+  test 'new loggers created by method_missing() should be instances of AdhearsionLogger' do
+    ahn_log.qwerty.should.be.kind_of Adhearsion::Logging::AdhearsionLogger
+  end
+  
+end
+
+# Essential for running the tests
+context 'Logger level changing' do
+  
+  after :each do
+    Adhearsion::Logging.logging_level = :info
+  end
+  
+  after :all do
+    Adhearsion::Logging.logging_level = :fatal # Silence them again
+  end
+  
+  test 'changing the logging level should affect all loggers' do
+    loggers = [ahn_log.one, ahn_log.two, ahn_log.three]
+    loggers.map(&:level).should.not == [Log4r::WARN] * 3
+    Adhearsion::Logging.logging_level = :warn
+    loggers.map(&:level).should == [Log4r::WARN] * 3
+  end
+  
+  test 'a new logger should have the global Adhearsion logging level' do
+    ahn_log.foo.level.should.equal Log4r::INFO
+    Adhearsion::Logging.logging_level = :fatal
+    ahn_log.brand_new.level.should.equal Log4r::FATAL
+  end
+  
+  test '#silence!() should change the level to be FATAL' do
+    flexmock(Adhearsion::Logging::DefaultAdhearsionLogger).should_receive(:level=).once.with(Log4r::FATAL)
+    Adhearsion::Logging.silence!
+  end
+  
+  test '#unsilence!() should change the level to be INFO' do
+    flexmock(Adhearsion::Logging::DefaultAdhearsionLogger).should_receive(:level=).once.with(Log4r::INFO)
+    Adhearsion::Logging.unsilence!
+  end
+  
+end

data/spec/test_relationship_properties.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/test_helper.rb"
+require 'adhearsion/core_extensions/relationship_properties'
+
+describe "Module#relationships" do
+  
+  describe "Overriding relationships in subclasses" do
+  
+    it "should be overridable in subclasses" do
+      super_class = Class.new do
+        relationships :storage_medium => Array
+      end
+      sub_class = Class.new(super_class) do
+        relationships :storage_medium => Hash
+      end
+      super_class.new.send(:storage_medium).should.equal Array
+      sub_class.new.send(:storage_medium).should.equal Hash
+    end
+
+    it "should not affect other defined relationships" do
+      super_class = Class.new do
+        relationships :io_class => TCPSocket, :error_class => StandardError
+      end
+      sub_class = Class.new(super_class) do
+        relationships :error_class => RuntimeError
+      end
+      super_class.new.send(:io_class).should.equal TCPSocket
+      sub_class.new.send(:io_class).should.equal TCPSocket
+    end
+
+  end
+  
+  it "should be accessible within instance methods of that Class as another instance method" do
+    klass = Class.new do
+      relationships :struct => Struct
+      def new_struct
+        struct.new
+      end
+    end
+  end
+  
+  it "should be accessible in subclasses" do
+    super_class = Class.new do
+      relationships :number_class => Bignum
+    end
+    
+    Class.new(super_class) do
+      def number_class_name
+        number_class.name
+      end
+    end.new.number_class_name.should == "Bignum"
+    
+  end
+  
+end

data/spec/voip/asterisk/ami_response_definitions.rb

@@ -0,0 +1,23 @@
+def ami(m, &block) context("AMI", "##{m}", &block) end
+
+ami:ping do
+  test "should return the number of seconds before a response if reachable"
+  test "should raise a PingError if unreachable"
+end
+
+ami:agents do
+  test "should return an Array of Agent objects"
+  test "should convert the logged-in time to a Ruby DateTime"
+  test "should convert the logged-in status to a Symbol"
+  test "should work with known logged-in statuses"
+  test "should convert unrecognized logged-in statuses to :unknown"
+end
+
+ami:queues do
+  
+end
+
+ami:state_of_extension do
+  test "should take one argument"
+  test "should "
+end