adhearsion 1.0.1 → 1.0.2

data/spec/voip/asterisk/menu_command/matchers_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'adhearsion/voip/menu_state_machine/menu_builder'
+require 'adhearsion/voip/menu_state_machine/matchers'
+
+describe "MatchCalculator" do
+  it "the build_with_pattern() method should return an appropriate subclass instance based on the pattern's class" do
+    Adhearsion::VoIP::MatchCalculator.build_with_pattern(1..2, :main).should be_an_instance_of Adhearsion::VoIP::RangeMatchCalculator
+  end
+
+end
+
+describe "The RangeMatchCalculator" do
+
+  it "matching with a Range should handle the case of two potential matches in the range" do
+    digits_that_begin_with_eleven = [110..119, 1100..1111].map { |x| Array(x) }.flatten
+
+    calculator = Adhearsion::VoIP::RangeMatchCalculator.new 11..1111, :match_payload_doesnt_matter
+    match = calculator.match 11
+    match.exact_matches.should == [11]
+    match.potential_matches.should == digits_that_begin_with_eleven
+  end
+
+  it 'return values of #match should be an instance of CalculatedMatch' do
+    calculator = Adhearsion::VoIP::RangeMatchCalculator.new 1..9, :match_payload_doesnt_matter
+    calculator.match(0).should be_an_instance_of Adhearsion::VoIP::CalculatedMatch
+    calculator.match(1000).should be_an_instance_of Adhearsion::VoIP::CalculatedMatch
+  end
+
+end
+
+describe "FixnumMatchCalculator" do
+  attr_reader :match_payload
+  before(:each) do
+    @match_payload = :main
+  end
+
+  it "a potential match scenario" do
+    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(444, match_payload)
+    match = calculator.match 4
+    match.potential_match?.should be true
+    match.exact_match?.should_not be true
+    match.potential_matches.should == [444]
+  end
+
+  it 'a multi-digit exact match scenario' do
+    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(5555, match_payload)
+    calculator.match(5555).exact_match?.should be true
+  end
+
+  it 'a single-digit exact match scenario' do
+    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(1, match_payload)
+    calculator.match(1).exact_match?.should be true
+  end
+
+  it 'the context name given to the calculator should be passed on to the CalculatedMatch' do
+    match_payload = :icanhascheezburger
+    calculator = Adhearsion::VoIP::FixnumMatchCalculator.new(1337, match_payload)
+    calculator.match(1337).match_payload.should be match_payload
+  end
+
+end
+
+describe "StringMatchCalculator" do
+
+  attr_reader :match_payload
+  before(:each) do
+    @match_payload = :doesnt_matter
+  end
+
+  it "numerical digits mixed with special digits" do
+
+    %w[5*11#3 5*** ###].each do |str|
+      calculator = Adhearsion::VoIP::StringMatchCalculator.new(str, match_payload)
+
+      match_case = calculator.match str[0,2]
+      match_case.exact_match?.should_not be true
+      match_case.potential_match?.should be true
+      match_case.potential_matches.should == [str]
+
+      match_case = calculator.match str
+      match_case.exact_match?.should be true
+      match_case.potential_match?.should_not be true
+      match_case.exact_matches.should == [str]
+    end
+  end
+
+  it "matching the special DTMF characters such as * and #" do
+    %w[* #].each do |special_digit|
+      calculator = Adhearsion::VoIP::StringMatchCalculator.new(special_digit, match_payload)
+      match_case = calculator.match special_digit
+      match_case.potential_match?.should_not be true
+      match_case.exact_match?.should be true
+      match_case.exact_matches.first.should == special_digit
+    end
+  end
+
+end

data/spec/voip/call_routing_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+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
+
+describe "Call routing rule generation" do
+  include CallRoutingTestHelper
+
+  attr_reader :provider_one, :provider_two, :patterns
+
+  before(:each) do
+    @provider_one = provider_named(:one)
+    @provider_two = provider_named(:two)
+    @patterns     = [/pattern/, /does not/, /matter/]
+  end
+
+  it "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 == [pattern]
+    rule.providers.should == [provider_one]
+  end
+
+  it "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 == [*patterns]
+    rule.providers.should == [provider_one]
+  end
+
+  it "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 == [*patterns]
+    rule.providers.should == [provider_one, provider_two]
+  end
+end
+
+describe "Route calculation" do
+  include CallRoutingTestHelper
+  attr_reader :provider_one, :provider_two
+
+  before(:each) do
+    rules.clear
+    @provider_one = provider_named(:one)
+    @provider_two = provider_named(:two)
+  end
+
+  it "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 be 1
+    rule = rules.first
+    rule.providers.should == [provider]
+    rule.patterns.should == [pattern]
+  end
+
+  it "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 be 2
+
+    rule_1 = rules.first
+    rule_1.providers.should == [provider_for_rule_1]
+    rule_1.patterns.should == [pattern_for_rule_1]
+
+    rule_2 = rules.last
+    rule_2.providers.should == [provider_for_rule_2]
+    rule_2.patterns.should == [pattern_for_rule_2]
+  end
+
+  it "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 == [target_provider]
+  end
+
+  it "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 == [target_provider]
+  end
+end

data/spec/voip/dialplan_manager_spec.rb

@@ -0,0 +1,468 @@
+require 'spec_helper'
+require 'adhearsion/voip/dsl/dialplan/parser'
+
+module DialplanTestingHelper
+
+  def load(dial_plan_as_string)
+    Adhearsion::DialPlan::Loader.load(dial_plan_as_string)
+  end
+
+  def mock_dialplan_with(string)
+    string_io = StringIO.new(string)
+    def string_io.path
+      "dialplan.rb"
+    end
+    flexstub(Adhearsion::AHN_CONFIG).should_receive(:files_from_setting).with("paths", "dialplan").and_return ["dialplan.rb"]
+    flexstub(File).should_receive(:new).with("dialplan.rb").and_return string_io
+    flexstub(File).should_receive(:read).with('dialplan.rb').and_return string
+  end
+
+  def new_manager_with_entry_points_loaded_from_dialplan_contexts
+    Adhearsion::DialPlan::Manager.new.tap do |manager|
+      manager.dial_plan.entry_points = manager.dial_plan.loader.load_dialplans.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
+
+describe "Dialplan::Manager handling" do
+
+  include DialplanTestingHelper
+
+  attr_accessor :manager, :call, :context_name, :mock_context
+
+  before :each do
+    @context_name = :some_context_name
+    @mock_context = flexmock('a context')
+
+    mock_dial_plan_lookup_for_context_name
+
+    flexmock(Adhearsion::DialPlan::Loader).should_receive(:load_dialplans).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 be context_name
+  end
+
+  it "Given a Call, the manager finds the call's desired entry point based on the originating context" do
+    manager.entry_point_for(call).should be mock_context
+  end
+
+  it "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
+
+  it "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_error(Adhearsion::DialPlan::Manager::NoContextError)
+  end
+
+  it 'should send :answer to the execution environment if Adhearsion::AHN_CONFIG.automatically_answer_incoming_calls is set' do
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).new_instances.should_receive(:answer).once.and_throw :answered_call!
+    Adhearsion::Configuration.configure do |config|
+      config.automatically_answer_incoming_calls = true
+    end
+    the_following_code {
+      manager.handle call
+    }.should throw_symbol :answered_call!
+  end
+
+  it 'should NOT send :answer to the execution environment if Adhearsion::AHN_CONFIG.automatically_answer_incoming_calls is NOT set' do
+    Adhearsion::Configuration.configure do |config|
+      config.automatically_answer_incoming_calls = false
+    end
+
+    entry_point = Adhearsion::DialPlan::DialplanContextProc.new(:does_not_matter) { "Do nothing" }
+    flexmock(manager).should_receive(:entry_point_for).once.with(call).and_return(entry_point)
+
+    execution_env = Adhearsion::DialPlan::ExecutionEnvironment.create(call, nil)
+    flexmock(execution_env).should_receive(:entry_point).and_return entry_point
+    flexmock(execution_env).should_receive(:answer).never
+
+    flexmock(Adhearsion::DialPlan::ExecutionEnvironment).should_receive(:new).once.and_return execution_env
+
+    Adhearsion::Configuration.configure
+    manager.handle call
+  end
+
+  private
+
+  def mock_dial_plan_lookup_for_context_name
+    flexstub(Adhearsion::DialPlan).new_instances.should_receive(:lookup).with(context_name).and_return(mock_context)
+  end
+
+end
+
+describe "DialPlan::Manager's handling a failed call" do
+
+  include DialplanTestingHelper
+
+  it '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.failed_call?.should be true
+    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
+
+describe "Call tagging" do
+
+  include DialplanTestingHelper
+
+  after :all do
+    Adhearsion.active_calls.clear!
+  end
+
+  it 'tagging a call with a single Symbol' do
+    the_following_code {
+      call = new_call_for_context "roflcopter"
+      call.tag :moderator
+    }.should_not raise_error
+  end
+
+  it 'tagging a call with multiple Symbols' do
+    the_following_code {
+      call = new_call_for_context "roflcopter"
+      call.tag :moderator
+      call.tag :female
+    }.should_not raise_error
+  end
+
+  it 'Call#tagged_with? with one tag' do
+    call = new_call_for_context "roflcopter"
+    call.tag :guest
+    call.tagged_with?(:guest).should be true
+    call.tagged_with?(:authorized).should be false
+  end
+
+  it "Call#remove_tag" do
+    call = new_call_for_context "roflcopter"
+    call.tag :moderator
+    call.tag :female
+    call.remove_tag :female
+    call.tag :male
+    call.tags.should == [:moderator, :male]
+  end
+
+  it 'Call#tagged_with? with many tags' do
+    call = new_call_for_context "roflcopter"
+    call.tag :customer
+    call.tag :authorized
+    call.tagged_with?(:customer).should be true
+    call.tagged_with?(:authorized).should be true
+  end
+
+  it 'tagging a call with a non-Symbol, non-String object' do
+    bad_objects = [123, Object.new, 888.88, nil, true, false, StringIO.new]
+    bad_objects.each do |bad_object|
+      the_following_code {
+        new_call_for_context("roflcopter").tag bad_object
+      }.should raise_error ArgumentError
+    end
+  end
+
+  it "finding calls by a tag" do
+    Adhearsion.active_calls.clear!
+
+    calls = Array.new(5) { new_call_for_context "roflcopter" }
+    calls.each { |call| Adhearsion.active_calls << call }
+
+    tagged_call = calls.last
+    tagged_call.tag :moderator
+
+    Adhearsion.active_calls.with_tag(:moderator).should == [tagged_call]
+  end
+
+end
+
+describe "DialPlan::Manager's handling a hungup call" do
+
+  include DialplanTestingHelper
+
+  it '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.hungup_call?.should be true
+    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_error Adhearsion::HungupExtensionCallException
+  end
+
+end
+
+describe "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_dialplans).once.and_return(@loader_instance)
+    @dial_plan = Adhearsion::DialPlan.new(@loader)
+  end
+
+  it "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
+
+  it "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
+
+describe "DialPlan loader" do
+
+  include DialplanTestingHelper
+
+  it "loading a single context" do
+    loader = load(<<-DIAL_PLAN)
+      one {
+        raise 'this block should not be evaluated'
+      }
+    DIAL_PLAN
+
+    loader.contexts.keys.size.should be 1
+    loader.contexts.keys.first.should be :one
+  end
+
+  it "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 be 2
+    loader.contexts.keys.map(&:to_s).sort.should == %w(one two)
+  end
+
+  it 'loading a dialplan with a syntax error' do
+    the_following_code {
+      load "foo { &@(*!&(*@*!@^!^%@%^! }"
+    }.should raise_error SyntaxError
+  end
+
+  it "loading a dial plan from a file" do
+    loader = nil
+    Adhearsion::AHN_CONFIG.ahnrc = {"paths" => {"dialplan" => "dialplan.rb"}}
+    the_following_code {
+      AHN_ROOT.using_base_path(File.expand_path(File.dirname(__FILE__) + '/../fixtures')) do
+        loader = Adhearsion::DialPlan::Loader.load_dialplans
+      end
+    }.should_not raise_error
+
+    loader.contexts.keys.size.should be 1
+    loader.contexts.keys.first.should be :sample_context
+  end
+
+end
+
+describe "The inbox-related dialplan methods" do
+
+  include DialplanTestingHelper
+
+  it "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_symbol :one
+  end
+
+  it "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_symbol :no
+  end
+
+  it "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_symbol :yes
+  end
+
+end
+
+
+describe "ExecutionEnvironment" 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
+
+  it "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.create(call, entry_point)
+    execution_environent.metaclass.included_modules.should include(Adhearsion::VoIP::Asterisk::Commands)
+  end
+
+  it "An executed context should raise a NameError error when a missing constant is referenced" do
+    the_following_code do
+      flexmock(Adhearsion::AHN_CONFIG).should_receive(:automatically_answer_incoming_calls).and_return false
+      context = :context_with_missing_constant
+      call = new_call_for_context context
+      mock_dialplan_with "#{context} { ThisConstantDoesntExist }"
+      Adhearsion::DialPlan::Manager.new.handle call
+    end.should raise_error NameError
+
+  end
+
+  it "should define variables accessors within itself" do
+    environment = Adhearsion::DialPlan::ExecutionEnvironment.create(@call, entry_point)
+    call.variables.empty?.should be false
+    call.variables.each do |key, value|
+      environment.send(key).should be value
+    end
+  end
+
+  it "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.empty?.should_not be true
+
+    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 be true
+    end
+
+  end
+
+end
+
+describe "Dialplan control statements" do
+
+  include DialplanTestingHelper
+
+  it "Manager should catch ControlPassingExceptions" do
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:automatically_answer_incoming_calls).and_return false
+    dialplan = %{
+      foo { raise Adhearsion::VoIP::DSL::Dialplan::ControlPassingException.new(bar) }
+      bar {}
+    }
+    executing_dialplan(:foo => dialplan).should_not raise_error
+  end
+
+  it "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_symbol :i_see_it
+  end
+
+  test_dialplan_inclusions = true
+  if Object.const_defined?("JRUBY_VERSION")
+    require 'adhearsion/version'
+    curver = Adhearsion::PkgVersion.new(JRUBY_VERSION)
+    minver = Adhearsion::PkgVersion.new("1.6.0")
+    if curver < minver
+      # JRuby contains a bug that breaks some of the menu functionality
+      # See: https://adhearsion.lighthouseapp.com/projects/5871/tickets/92-menu-method-under-jruby-does-not-appear-to-work
+      test_dialplan_inclusions = false
+    end
+  end
+
+  if test_dialplan_inclusions
+    it "Proc#+@ should execute the other context" do
+      dialplan = %{
+        eins {
+          +zwei
+          throw :eins
+        }
+        zwei {
+          throw :zwei
+        }
+      }
+      executing_dialplan(:eins => dialplan).should throw_symbol :zwei
+    end
+
+    it "Proc#+@ should not return to its originating context" do
+    dialplan = %{
+      andere {}
+      zuerst {
+        +andere
+        throw :after_control_statement
+      }
+    }
+    executing_dialplan(:zuerst => dialplan).should_not raise_error
+  end
+  end
+
+
+  it "new constants should still be accessible within the dialplan" do
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:automatically_answer_incoming_calls).and_return false
+    ::Jicksta = :Jicksta
+    dialplan = %{
+      constant_test {
+        Jicksta.should == :Jicksta
+      }
+    }
+    executing_dialplan(:constant_test => dialplan).should_not raise_error
+  end
+
+end
+
+describe "VoIP platform operations" do
+  it "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
+
+describe 'DialPlan::Loader' do
+  it '::build should raise a SyntaxError when the dialplan String contains one' do
+    the_following_code {
+      Adhearsion::DialPlan::Loader.load "foo { ((((( *@!^*@&*^!^@ }"
+    }.should raise_error SyntaxError
+  end
+end