sevenscale-adhearsion 0.7.1003 → 0.8.0

data/spec/test_code_quality.rb

@@ -1,87 +0,0 @@
-# #!/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

@@ -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_events.rb

@@ -1,136 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-
-context 'Definitions within an events.rb file' do
-  
-  include EventsSubsystemTestHelper
-  
-  before :each do
-    Adhearsion::Events.reinitialize_framework_events_container!
-  end
-  
-  test 'calling each() on a registrar defines a RegisteredEventCallback' do
-    
-    mock_file_access_with_text %{ events.framework.before_call.each { |event| event } }
-    
-    framework_events_container.register_namespace_path(:framework).register_callback_name(:before_call)
-    callbacks = framework_events_container.callbacks_at_path :framework, :before_call
-    load_events_file_from_mocked_filesystem
-    
-    callbacks.size.should.equal 1
-    callbacks.first.should.be.kind_of Adhearsion::Events::RegisteredEventCallback
-  end
-  
-  test 'the each() method does not exist on the object returned by events()' do
-    the_following_code {
-      load_code_from_mocked_filesystem %{ events.each {} }
-    }.should.raise NoMethodError
-  end
-  
-  test 'addressing a non-existent path raises an Exception' do
-    [%{ events.monkeys! }, %{events.framework.icanhascheezburger}, %{events.framework}].each do |bad_code|
-      the_following_code {
-        load_code_from_mocked_filesystem bad_code
-      }.should.raise Adhearsion::Events::UndefinedEventNamespace
-    end
-  end
-  
-end
-
-
-# Hierarchy tests?
-
-context 'Executing synchronous events defined within an events.rb file' do
-  
-  before :each do
-    Adhearsion::Events.reinitialize_framework_events_container!
-  end
-  
-  test 'an exception in a callback should be passed to ahn_log.events.error' do
-    flexmock(ahn_log.events).should_receive(:error).once.with(/lolrus/)
-    Adhearsion::Events.register_namespace_path(:ceiling_cat).register_callback_name(:watches_you)
-    Adhearsion::Events.framework_events_container.events.ceiling_cat.watches_you.each { |prophecy| raise prophecy }
-    the_following_code {
-      Adhearsion::Events.framework_events_container.events.ceiling_cat.watches_you << "I has a lolrus!"
-    }.should.not.raise RuntimeError
-  end
-  
-  test 'events should execute the callbacks in the order in which they were defined' do
-    order_keeper = []
-    Adhearsion::Events.register_namespace_path(:foo, :bar).register_callback_name(:before_explosion)
-    Adhearsion::Events.framework_events_container.events.foo.bar.before_explosion.each { |event| order_keeper << 1 }
-    Adhearsion::Events.framework_events_container.events.foo.bar.before_explosion.each { |event| order_keeper << 2 }
-    
-    [:one, :two, :three].each do |number|
-      Adhearsion::Events.framework_events_container.events.foo.bar.before_explosion << number
-    end
-    order_keeper.should == [1,2] * 3
-  end
-end
-
-context 'Executing asynchronous events defined within an events.rb file' do
-  
-end
-
-context "Defining new namespaces and events within an EventsDefinitionContainer's object graph" do
-  
-  attr_reader :container
-  before :each do
-    @container = Adhearsion::Events::EventsDefinitionContainer.new
-  end
-  
-  test 'initializes a RootNamespace' do
-    container.root.should.be.kind_of Adhearsion::Events::RootEventNamespace
-  end
-  
-  test 'allows the registration of new namespaces' do
-    container.register_namespace_path(:framework).register_callback_name(:after_call)
-    container.callbacks_at_path(:framework, :after_call).empty?.should == true
-  end
-  
-  test 'the callback is executed with the proper message' do
-    container.register_namespace_path(:reporters).register_callback_name(:report)
-    message_from_block = :has_not_executed_yet
-    container.events.reporters.report(:foobar).each { |event| message_from_block = event }
-    container.events.reporters.report << :got_here
-    message_from_block.should.equal :got_here
-  end
-  
-end
-
-context 'NamespaceDefinitionCapturer' do
-  
-  attr_reader :namespace
-  before :each do
-    @namespace = flexmock 'a mock AbstractNamespace'
-  end
-  
-  test 'captures any method and returns a NamespaceDefinitionCapturer' do
-    nested_namespace = Adhearsion::Events::RegisteredEventNamespace.new(namespace)
-    namespace.should_receive(:[]).once.with(:foobarz).and_return nested_namespace
-    Adhearsion::Events::NamespaceDefinitionCapturer.new(namespace).foobarz.should.
-      be.kind_of(Adhearsion::Events::NamespaceDefinitionCapturer)
-  end
-  
-end
-
-BEGIN {
-  module EventsSubsystemTestHelper
-    def mock_file_access_with_text(text)
-      flexmock(File).should_receive(:read).once.and_return text
-    end
-    
-    def framework_events_container
-      Adhearsion::Events.framework_events_container
-    end
-    
-    def load_code_from_mocked_filesystem(code)
-      mock_file_access_with_text code
-      load_events_file_from_mocked_filesystem
-    end
-    
-    def load_events_file_from_mocked_filesystem
-      Adhearsion::Events.load_definitions_from_file "events.rb"
-    end
-    
-  end
-}

data/spec/test_helper.rb

@@ -1,106 +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)
-  2.times { puts }
-  puts "You need #{name} to run these tests:  gem install #{name}"
-  2.times { 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 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
-  
-  DEFAULT_AHNRC_DATA_STRUCTURE = YAML.load_file(
-    File.dirname(__FILE__) + "/../app_generators/ahn/templates/.ahnrc"
-  ) unless defined? DEFAULT_AHNRC_DATA_STRUCTURE
-  
-  UNWANTED_BEHAVIOR = {
-    Adhearsion::Initializer           => [:initialize_log_file, :switch_to_root_directory, :daemonize!],
-    Adhearsion::Initializer.metaclass => { :get_rules_from => DEFAULT_AHNRC_DATA_STRUCTURE },
-    Adhearsion::Hooks::AfterInitialized.metaclass => [:create_hook, :trigger_hooks]
-  } unless defined? UNWANTED_BEHAVIOR
-  
-  def stub_behavior_for_initializer_with_no_path_changing_behavior
-      stub_unwanted_behavior
-      yield if block_given?
-    ensure
-      unstub_directory_changing_behavior    
-  end
-  
-  def with_new_initializer_with_no_path_changing_behavior(&block)
-    stub_behavior_for_initializer_with_no_path_changing_behavior do
-      block.call Adhearsion::Initializer.start('path does not matter')
-    end
-  end
-  
-  def stub_unwanted_behavior
-    UNWANTED_BEHAVIOR.each do |stub_victim_class, undesired_methods|
-      undesired_methods.each do |undesired_method_name_or_key_value_pair|
-        undesired_method_name, method_implementation = case undesired_method_name_or_key_value_pair
-          when Array
-            [undesired_method_name_or_key_value_pair.first, lambda { undesired_method_name_or_key_value_pair.last } ]
-          else
-            [undesired_method_name_or_key_value_pair, lambda{ |*args| }]
-        end
-        stub_victim_class.send(:alias_method, "pre_stubbed_#{undesired_method_name}", undesired_method_name)
-        stub_victim_class.send(:define_method, undesired_method_name, &method_implementation)
-      end
-    end
-  end
-  
-  def unstub_directory_changing_behavior
-    UNWANTED_BEHAVIOR.each do |stub_victim_class, undesired_methods|
-      undesired_methods.each do |undesired_method_name|
-        undesired_method_name = undesired_method_name.first if undesired_method_name.kind_of? Array
-        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,15 +0,0 @@
-require File.dirname(__FILE__) + "/test_helper.rb"
-
-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