eric-adhearsion 0.7.999

data/spec/voip/freeswitch/test_oes_server.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+require File.dirname(__FILE__) + "/../dsl/dispatcher_spec_helper"
+require 'adhearsion/voip/freeswitch/oes_server'
+
+
+describe "Adhearsion::VoIP::FreeSwitch::OesServer::OesDispatcher" do
+  include StandardDispatcherBehavior
+  setup { @dispatcher_class = Adhearsion::VoIP::FreeSwitch::OesServer::OesDispatcher }
+end

data/spec/voip/test_call_routing.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+context "Call routing rule generation" do
+  include CallRoutingTestHelper
+  
+  attr_reader :provider_one, :provider_two, :patterns
+
+  setup do
+    @provider_one = provider_named(:one)
+    @provider_two = provider_named(:two)
+    @patterns     = [/pattern/, /does not/, /matter/]
+  end
+
+  test "specifying a single pattern routed to a single provider properly stores that pattern and its provider in the generated route rule" do
+    pattern = %r(does not matter)
+    rule    = route(pattern, :to => provider_one)
+    rule.patterns.should.equal [pattern]
+    rule.providers.should.equal [provider_one]
+  end
+
+  test "specifying multiple patterns routed to a single provider stores all of them in the generated route rule" do
+    first, second, third = patterns
+    rule                 = route(first, second,  third, :to => provider_one)
+    rule.patterns.should.equal [*patterns]
+    rule.providers.should.equal [provider_one]
+  end
+  
+  test "specifying multiple patterns routed to multiple providers stores all of them in the generated route rule, listing providers in the ordered specified" do
+    first, second, third = patterns
+    rule = route(first, second, third, :to => [provider_one, provider_two])
+    rule.patterns.should.equal [*patterns]
+    rule.providers.should.equal [provider_one, provider_two]
+  end
+end
+
+context "Route calculation" do
+  include CallRoutingTestHelper
+  attr_reader :provider_one, :provider_two
+  
+  setup do
+    rules.clear
+    @provider_one = provider_named(:one)
+    @provider_two = provider_named(:two)
+  end
+  
+  test "Defining a rule adds it to the router rules" do
+    provider = provider_one
+    pattern  = /123/
+    define_rules do
+      route pattern, :to => provider
+    end
+    rules.size.should.equal 1
+    rule = rules.first
+    rule.providers.should.equal [provider]
+    rule.patterns.should.equal [pattern]
+  end
+  
+  test "Definiting multiple rules adds them to the router rules" do
+    provider_for_rule_1 = provider_one
+    provider_for_rule_2 = provider_two
+    pattern_for_rule_1  = /123/
+    pattern_for_rule_2  = /987/
+    
+    define_rules do
+      route pattern_for_rule_1, :to => provider_for_rule_1
+      route pattern_for_rule_2, :to => provider_for_rule_2
+    end
+    
+    rules.size.should.equal 2
+    
+    rule_1 = rules.first
+    rule_1.providers.should.equal [provider_for_rule_1]
+    rule_1.patterns.should.equal [pattern_for_rule_1]
+    
+    rule_2 = rules.last
+    rule_2.providers.should.equal [provider_for_rule_2]
+    rule_2.patterns.should.equal [pattern_for_rule_2]
+  end
+  
+  test "Provider is found in the simplest case of having only one pattern and one provider" do
+    target_provider = provider_one
+    define_rules do
+      route /123/, :to => target_provider
+    end
+    calculate_route_for(1234).should.equal [target_provider]
+  end
+  
+  test "Provider is found when the specified pattern matches a rule that is not the first rule" do
+    provider_for_rule_1 = provider_one
+    provider_for_rule_2 = provider_two
+    pattern_for_rule_1  = /123/
+    pattern_for_rule_2  = /987/
+    
+    define_rules do
+      route pattern_for_rule_1, :to => provider_for_rule_1
+      route pattern_for_rule_2, :to => provider_for_rule_2
+    end
+    
+    target_provider = provider_for_rule_2
+    calculate_route_for(9876).should.equal [target_provider]
+  end
+end
+
+BEGIN {
+  module CallRoutingTestHelper
+    private
+      def route(*args, &block)
+        Adhearsion::VoIP::CallRouting::Rule.new(*args, &block)
+      end
+
+      def provider_named(name)
+        Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(name)
+      end
+      
+      def define_rules(&block)
+        Adhearsion::VoIP::CallRouting::Router.define(&block)
+      end
+      
+      def calculate_route_for(end_point)
+        Adhearsion::VoIP::CallRouting::Router.calculate_route_for(end_point)
+      end
+      
+      def rules
+        Adhearsion::VoIP::CallRouting::Router.rules
+      end
+  end
+}

data/spec/voip/test_dialplan_manager.rb

@@ -0,0 +1,372 @@
+require File.dirname(__FILE__) + "/../test_helper"
+require 'adhearsion/voip/dsl/dialplan/parser'
+
+context "Dialplan::Manager handling" do
+  
+  include DialplanTestingHelper
+  
+  attr_accessor :manager, :call, :context_name, :mock_context
+  
+  before do
+    @context_name = :some_context_name
+    @mock_context = flexmock('a context')
+    
+    hack_to_work_around_parser_coupling
+    mock_dial_plan_lookup_for_context_name
+    flexmock(Adhearsion::DialPlan::Loader).should_receive(:load_dial_plan).and_return{flexmock("loaded contexts", :contexts => nil)}
+    @manager = Adhearsion::DialPlan::Manager.new
+    @call    = new_call_for_context context_name
+    
+    # Sanity check context name being set
+    call.context.should.equal context_name
+  end
+  
+  test "Given a Call, the manager finds the call's desired entry point/context" do
+    manager.entry_point_for(call).should.equal mock_context
+  end
+  
+  test "The manager handles a call by executing the proper context" do
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:run).once  
+    manager.handle(call)
+  end
+  
+  test "should raise a NoContextError exception if the targeted context is not found" do
+    the_following_code {
+      flexmock(manager).should_receive(:entry_point_for).and_return nil
+      manager.handle call
+    }.should.raise(Adhearsion::DialPlan::Manager::NoContextError)
+  end
+  
+  test 'should send :answer to the execution environment if Adhearsion::AHN_CONFIG.automatically_answer_incoming_calls is set' do
+    mock_ahn_config = flexmock 'a mock of the Adhearsion::Configuration object that is normally set when an app is initialized'
+    mock_ahn_config.should_receive(:automatically_answer_incoming_calls).once.and_return true
+    flexmock(Adhearsion::Configuration).should_receive(:new).once.and_return(mock_ahn_config)
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:answer).once.and_throw :answered_call!
+    Adhearsion::Configuration.configure
+    the_following_code {
+      manager.handle(call)
+    }.should.throw :answered_call!
+  end
+  
+  test 'should not send :answer to the executuon environment if Adhearsion::AHN_CONFIG.automatically_answer_incoming_calls is NOT set' do
+    
+    mock_ahn_config = flexmock 'a mock of the Adhearsion::Configuration object that is normally set when an app is initialized'
+    mock_ahn_config.should_receive(:automatically_answer_incoming_calls).once.and_return false
+    
+    entry_point = Adhearsion::DialPlan::DialplanContextProc.new(:does_not_matter) {}
+    flexmock(manager).should_receive(:entry_point_for).once.with(call).and_return(entry_point)
+    
+    flexmock(Adhearsion::Configuration).should_receive(:new).once.and_return(mock_ahn_config)
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:entry_point).and_return entry_point
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:answer).never
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:instance_eval).and_throw :doing_dialplan
+    
+    Adhearsion::Configuration.configure
+    manager.handle(call)
+  end
+  
+  private
+    def hack_to_work_around_parser_coupling
+      flexmock(Adhearsion::Paths).should_receive(:manager_for?).and_return(true)
+      flexmock(Adhearsion::VoIP::DSL::Dialplan::DialplanParser).should_receive(:all_dialplans).and_return([])
+    end
+    
+    def mock_dial_plan_lookup_for_context_name
+      flexmock(Adhearsion::DialPlan).new_instances.should_receive(:lookup).with(context_name).and_return(mock_context)
+    end
+end
+
+context "DialPlan::Manager's handling a failed call" do
+  
+  include DialplanTestingHelper
+  
+  test 'should check if the call has failed and then instruct it to extract the reason from the environment' do
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:variable).with("REASON").once.and_return '3'
+    call = Adhearsion::Call.new(nil, {'extension' => "failed"})
+    call.should.be.failed_call
+    flexmock(Adhearsion::DialPlan).should_receive(:new).once.and_return flexmock("bogus DialPlan which should never be used")
+    begin
+      Adhearsion::DialPlan::Manager.handle(call)
+    rescue Adhearsion::FailedExtensionCallException => error
+      error.call.failed_reason.should == Adhearsion::Call::ASTERISK_FRAME_STATES[3]
+    end
+  end
+end
+
+context "DialPlan::Manager's handling a hungup call" do
+  
+  include DialplanTestingHelper
+  
+  test 'should check if the call was a hangup meta-AGI call and then raise a HangupExtensionCallException' do
+    call = Adhearsion::Call.new(nil, {'extension' => "h"})
+    call.should.be.hungup_call
+    flexmock(Adhearsion::DialPlan).should_receive(:new).once.and_return flexmock("bogus DialPlan which should never be used")
+    the_following_code {
+      Adhearsion::DialPlan::Manager.handle(call)
+    }.should.raise Adhearsion::HungupExtensionCallException
+  end
+  
+end
+
+context "DialPlan" do
+  
+  attr_accessor :loader, :loader_instance, :dial_plan
+  
+  before do
+    @loader = Adhearsion::DialPlan::Loader
+    @loader_instance = @loader.new
+    flexmock(Adhearsion::DialPlan::Loader).should_receive(:load_dial_plan).once.and_return(@loader_instance)
+    @dial_plan   = Adhearsion::DialPlan.new(Adhearsion::DialPlan::Loader)
+  end
+  
+  test "When a dial plan is instantiated, the dialplans are loaded and stored for lookup" do
+    dial_plan.instance_variable_get("@entry_points").should.not.be.nil
+  end
+  
+  test "Can look up an entry point from a dial plan" do
+    context_name = 'this_context_is_better_than_your_context'
+    loader_instance.contexts[context_name] = lambda { puts "o hai" }
+    dial_plan.lookup(context_name).should.not.be.nil
+  end
+end
+
+context "DialPlan loader" do
+  
+  include DialplanTestingHelper
+  
+  test "loading a single context" do
+    loader = load(<<-DIAL_PLAN)
+      one {
+        raise 'this block should not be evaluated'
+      }
+    DIAL_PLAN
+    
+    loader.contexts.keys.size.should.equal 1
+    loader.contexts.keys.first.should.equal :one
+  end
+  
+  test "loading multiple contexts loads all contexts" do
+    loader = load(<<-DIAL_PLAN)
+      one {
+        raise 'this block should not be evaluated'
+      }
+      
+      two {
+        raise 'this other block should not be evaluated either'
+      }
+    DIAL_PLAN
+    
+    loader.contexts.keys.size.should.equal 2
+    loader.contexts.keys.map(&:to_s).sort.should.equal %w(one two)
+  end
+  
+  test 'loading a dialplan with a syntax error' do
+    the_following_code {
+      load "foo { &@(*!&(*@*!@^!^%@%^! }"
+    }.should.raise SyntaxError
+  end
+  
+  test "loading a dial plan from a file" do
+    loader = nil
+    the_following_code {
+      AHN_ROOT.using_base_path(File.expand_path(File.dirname(__FILE__) + '/../fixtures')) do
+        loader = Adhearsion::DialPlan::Loader.load_dial_plan
+      end
+    }.should.not.raise
+    
+    loader.contexts.keys.size.should.equal 1
+    loader.contexts.keys.first.should.equal :sample_context
+  end
+  
+end
+
+context "The inbox-related dialplan methods" do
+  
+  include DialplanTestingHelper
+  
+  test "with_next_message should execute its block with the message from the inbox" do
+    mock_call = new_call_for_context :entrance
+    [:one, :two, :three].each { |message| mock_call.inbox << message }
+    
+    dialplan = %{ entrance {  with_next_message { |message| throw message } } }
+    executing_dialplan(:entrance => dialplan, :call => mock_call).should.throw :one
+  end
+
+  
+  test "messages_waiting? should return false if the inbox is empty" do
+    mock_call = new_call_for_context :entrance
+    dialplan = %{ entrance { throw messages_waiting? ? :yes : :no } }
+    executing_dialplan(:entrance => dialplan, :call => mock_call).should.throw :no
+  end
+  
+  test "messages_waiting? should return false if the inbox is not empty" do
+    mock_call = new_call_for_context :entrance
+    mock_call.inbox << Object.new
+    dialplan = %{ entrance { throw messages_waiting? ? :yes : :no } }
+    executing_dialplan(:entrance => dialplan, :call => mock_call).should.throw :yes
+  end
+
+end
+
+
+context "ExecutionEnvironemnt" do
+  attr_accessor :call, :entry_point
+  
+  include DialplanTestingHelper
+
+  before do
+    variables = { :context => "zomgzlols", :caller_id => "Ponce de Leon" }
+    @call = Adhearsion::Call.new(nil, variables)
+    @entry_point = lambda {}
+  end
+  
+  test "On initialization, ExecutionEnvironments extend themselves with behavior specific to the voip platform which originated the call" do
+    Adhearsion::DialPlan::ExecutionEnvironment.included_modules.should.not.include(Adhearsion::VoIP::Asterisk::Commands)
+    execution_environent = Adhearsion::DialPlan::ExecutionEnvironment.new(call, entry_point)
+    execution_environent.metaclass.included_modules.should.include(Adhearsion::VoIP::Asterisk::Commands)
+  end
+  
+  test "An executed context should raise a NameError error when a missing constant is referenced" do
+    the_following_code do
+      call = new_call_for_context :context_with_missing_constant
+      mock_dialplan_with "context_with_missing_constant { ThisConstantDoesntExist }"
+      manager = new_manager_with_entry_points_loaded_from_dialplan_contexts
+      manager.handle call
+    end.should.raise NameError
+    
+  end
+  
+  test "should define variables accessors within itself" do
+    environment = Adhearsion::DialPlan::ExecutionEnvironment.new(@call, entry_point)
+    call.variables.should.not.be.empty
+    call.variables.each do |key, value|
+      environment.send(key).should.equal value
+    end
+  end
+  
+  test "should define accessors for other contexts in the dialplan" do
+    call = new_call_for_context :am_not_for_kokoa!
+    bogus_dialplan = <<-DIALPLAN
+      am_not_for_kokoa! {}
+      icanhascheezburger? {}
+      these_context_names_do_not_really_matter {}
+    DIALPLAN
+    
+    mock_dialplan_with bogus_dialplan
+    manager = Adhearsion::DialPlan::Manager.new
+    manager.dial_plan.entry_points = manager.dial_plan.loader.load_dial_plan.contexts
+    manager.dial_plan.entry_points.should.not.be.empty
+    
+    manager.handle call
+    
+    %w(these_context_names_do_not_really_matter icanhascheezburger? am_not_for_kokoa!).each do |context_name|
+      manager.context.respond_to?(context_name).should.equal true
+    end
+  end
+  
+end
+
+context "Dialplan control statements" do
+  
+  include DialplanTestingHelper
+  
+  test "Manager should catch ControlPassingExceptions" do
+    dialplan = %{
+      foo { raise Adhearsion::VoIP::DSL::Dialplan::ControlPassingException.new(bar) }
+      bar {}
+    }
+    executing_dialplan(:foo => dialplan).should.not.raise
+  end
+  
+  test "Proc#+@ should not return to its originating context" do
+    dialplan = %{
+      andere {}
+      zuerst {
+        +andere
+        throw :after_control_statement
+      }
+    }
+    executing_dialplan(:zuerst => dialplan).should.not.throw
+  end
+  test "All dialplan contexts should be available at context execution time" do
+    dialplan = %{
+      context_defined_first {
+        throw :i_see_it if context_defined_second
+      }
+      context_defined_second {}
+    }
+    executing_dialplan(:context_defined_first => dialplan).should.throw :i_see_it
+  end
+  test "Proc#+@ should execute the other context" do
+    dialplan = %{
+      eins {
+        +zwei
+        throw :eins
+      }
+      zwei {
+        throw :zwei
+      }
+    }
+    executing_dialplan(:eins => dialplan).should.throw :zwei
+  end
+  
+  test "new constants should still be accessible within the dialplan" do
+    ::Jicksta = :Jicksta
+    dialplan = %{
+      constant_test {
+        Jicksta.should.equal:Jicksta
+      }
+    }
+    executing_dialplan(:constant_test => dialplan).should.not.raise
+  end
+  
+end
+
+context "VoIP platform operations" do
+  test "can map a platform name to a module which holds its platform-specific operations" do
+    Adhearsion::VoIP::Commands.for(:asterisk).should == Adhearsion::VoIP::Asterisk::Commands
+  end
+end
+
+context 'ContextNameCollector' do
+  test '::build should raise a SyntaxError when the dialplan String contains one' do
+    the_following_code {
+      Adhearsion::DialPlan::Loader::ContextNameCollector.build "foo { ((((( *@!^*@&*^!^@ }"
+    }.should.raise SyntaxError
+  end
+end
+
+BEGIN {
+module DialplanTestingHelper
+  def load(dial_plan_as_string)
+    Adhearsion::DialPlan::Loader.load(dial_plan_as_string)
+  end
+  
+  def mock_dialplan_with(string)
+    flexstub(Adhearsion::DialPlan::Loader).should_receive(:read_dialplan_file).and_return(string)
+  end
+  
+  def new_manager_with_entry_points_loaded_from_dialplan_contexts
+    returning Adhearsion::DialPlan::Manager.new do |manager|
+      manager.dial_plan.entry_points = manager.dial_plan.loader.load_dial_plan.contexts
+    end
+  end
+  
+  def executing_dialplan(options)
+    call         = options.delete(:call)
+    context_name = options.keys.first
+    dialplan     = options[context_name]
+    call       ||= new_call_for_context context_name
+    
+    mock_dialplan_with dialplan
+    lambda do
+      Adhearsion::DialPlan::Manager.new.handle call
+    end
+  end
+  
+  def new_call_for_context(context)
+    Adhearsion::Call.new(StringIO.new, :context => context)
+  end
+end
+
+}

data/spec/voip/test_numerical_string.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+require 'adhearsion/voip/dsl/numerical_string'
+require 'adhearsion/voip/constants'
+
+context "A NumericalString" do
+  test "NumericalString should appear to be behave like a Fixnum in a case statement" do
+    assert 123 === numerical_string_for("123")
+    assert 987 === numerical_string_for("0987")
+  end
+  
+  test "NumericalString should appear to behave like a String in a case statement" do
+    assert "123"  === numerical_string_for("123")
+    assert "0987" === numerical_string_for("0987")
+  end
+  
+  test "when compared against a Range that contains the numeric equivalent, the NumericalString is seen as a member" do
+    assert((100..200) === numerical_string_for("150"))
+    assert((100..200) === numerical_string_for("0150"))
+    assert !((100..200) === numerical_string_for("1000000"))
+  end
+  
+  test "comparing against a regular expression works" do
+    assert %r|^\d+$| === numerical_string_for("027316287")
+  end
+  
+  test "checking if a string representation of a number starts with a leading zero" do
+    with_leading_zeros    = %w(01 01234 01.23 01.2)
+    without_leading_zeros = %w(1 1.2 0 0.0)
+    
+    with_leading_zeros.each do |number|
+      assert numerical_string.starts_with_leading_zero?(number), number
+    end
+    
+    without_leading_zeros.each do |number|
+      assert !numerical_string.starts_with_leading_zero?(number), number
+    end
+  end
+    
+  private
+    def numerical_string
+      Adhearsion::VoIP::DSL::NumericalString
+    end
+    
+    def numerical_string_for(string)
+      numerical_string.new(string)
+    end
+end

data/spec/voip/test_phone_number.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/../test_helper"
+require 'adhearsion/voip/constants'
+require 'adhearsion/voip/dsl/numerical_string'
+
+
+# Use cases...
+# case extension
+#   when US_NUMBER
+#   when (100..200)
+#   when _('12Z')
+#   when 123
+#   when "123"
+# end
+
+describe "A PhoneNumber" do
+  
+  it "should have an ISN pattern-matching method" do
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("0115544332211").isn?.should == false
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("1*548").isn?.should == false
+  end
+  
+  it "should have a US local number pattern-matching method" do
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("18887776665555").local_number?.should == false
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("18887776665555").national_number?.should == false
+    
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("8887776665555").local_number?.should == false
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("8887776665555").national_number?.should == true
+     
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("4445555").local_number?.should == true
+    !! Adhearsion::VoIP::DSL::PhoneNumber.new("4445555").national_number?.should == false
+  end
+  
+  it "should convert from vanity numbers properly" do
+    Adhearsion::VoIP::DSL::PhoneNumber.from_vanity("1-800-FUDGEME").should == "18003834363"
+  end
+end

data/test/test_ahn_generator.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), "test_generator_helper.rb")
+
+class TestAhnGenerator < Test::Unit::TestCase
+  include RubiGen::GeneratorTestHelper
+
+  def setup
+    bare_setup
+  end
+  
+  def teardown
+    bare_teardown
+  end
+  
+  # Some generator-related assertions:
+  #   assert_generated_file(name, &block) # block passed the file contents
+  #   assert_directory_exists(name)
+  #   assert_generated_class(name, &block)
+  #   assert_generated_module(name, &block)
+  #   assert_generated_test_for(name, &block)
+  # The assert_generated_(class|module|test_for) &block is passed the body of the class/module within the file
+  #   assert_has_method(body, *methods) # check that the body has a list of methods (methods with parentheses not supported yet)
+  #
+  # Other helper methods are:
+  #   app_root_files - put this in teardown to show files generated by the test method (e.g. p app_root_files)
+  #   bare_setup - place this in setup method to create the APP_ROOT folder for each test
+  #   bare_teardown - place this in teardown method to destroy the TMP_ROOT or APP_ROOT folder after each test
+  
+  def test_generator_without_options
+    run_generator('ahn', [APP_ROOT], sources)
+    assert_directory_exists "components/simon_game/lib"
+    assert_directory_exists "components/simon_game/test"
+    assert_directory_exists "config"
+
+    assert_generated_file   "components/simon_game/configuration.rb"
+    assert_generated_file   "components/simon_game/lib/simon_game.rb"
+    assert_generated_file   "components/simon_game/test/test_helper.rb"
+    assert_generated_file   "components/simon_game/test/test_simon_game.rb"
+    assert_generated_file   "config/startup.rb"
+    assert_generated_file   "dialplan.rb"
+    assert_generated_file   "README"
+    assert_generated_file   "Rakefile"
+    
+    assert_generated_class  "components/simon_game/lib/simon_game" do |body|
+      assert_has_method body, "initialize"
+      assert_has_method body, "start"
+      assert_has_method body, "random_number"
+    end
+  end
+  
+  private
+  def sources
+    [RubiGen::PathSource.new(:test, File.join(File.dirname(__FILE__),"..", generator_path))
+    ]
+  end
+  
+  def generator_path
+    "app_generators"
+  end
+end