adhearsion 1.0.1 → 1.0.2

data/spec/voip/dsl/dialing_dsl_spec.rb

@@ -0,0 +1,270 @@
+require 'spec_helper'
+require 'adhearsion/voip/dsl/dialing_dsl'
+
+# Keep the monkey patches in a module and load that into Regexp
+# eigenclasses during a before(:all) block?
+
+describe "RouteRule Regexp assembling" do
+
+  it "should compile two Regexps" do
+    first, last = /jay/, /phillips/
+    r = first | last
+    r.patterns.should == [first, last]
+  end
+
+  it "should compile three or more Regexps" do
+    first, second, third = /lorem/, /ipsum/, /dolar/
+    r = first | second | third
+    r.patterns.should == [first, second, third]
+  end
+
+end
+
+describe "RouteRule assembling with one provider definition" do
+
+  before :each do
+    @provider = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:icanhascheezburger?)
+  end
+
+  it "should store one pattern properly" do
+    pattern = /lorem/
+    route = pattern >> @provider
+    route.patterns.should == [pattern]
+  end
+
+  it "should store three patterns properly" do
+    first, second, third = /lorem/, /ipsum/, /dolar/
+    route = first | second | third >> @provider
+    route.patterns.should == [first, second, third]
+    route.providers.should == [@provider]
+  end
+
+end
+
+describe "RouteRule assembling with multiple patterns and multiple provider definitions" do
+
+  before(:each) do
+    1.upto 3 do |i|
+      instance_variable_set "@prov_#{i}",
+        Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new("prov_#{i}")
+      instance_variable_set "@pattern_#{i}", /^#{i * 100}$/
+    end
+  end
+
+  it "should store the patterns properly" do
+    route_1 = @pattern_1 | @pattern_2 | @pattern_3 >> @prov_1 >> @prov_2 >> @prov_3
+    route_1.patterns.should == [@pattern_1, @pattern_2, @pattern_3]
+
+    route_2 = @pattern_2 | @pattern_3 | @pattern_1 >> @prov_3 >> @prov_2 >> @prov_1
+    route_2.patterns.should == [@pattern_2, @pattern_3, @pattern_1]
+  end
+
+  it "should store the providers properly" do
+    route_1 = @pattern_1 | @pattern_2 | @pattern_3 >> @prov_1 >> @prov_2 >> @prov_3
+    route_1.providers.should == [@prov_1, @prov_2, @prov_3]
+
+    route_2 = @pattern_2 | @pattern_3 | @pattern_1 >> @prov_3 >> @prov_2 >> @prov_1
+    route_2.patterns.should == [@pattern_2, @pattern_3, @pattern_1]
+  end
+end
+
+describe "The DialingDSL class internals" do
+
+  it "should allow Asterisk-like patterns" do
+    Adhearsion::VoIP::DSL::DialingDSL.class_eval do
+      _('23XX')
+    end.should be_an_instance_of Regexp
+  end
+
+  it "should define all of the VoIP constants" do
+    lambda do
+      Adhearsion::VoIP::Constants.constants.each do |constant|
+        eval "Adhearsion::VoIP::DSL::DialingDSL::#{constant}"
+      end
+    end.should_not raise_error NameError
+  end
+
+  # it "should define a DUNDI constant"
+
+  it "should synchronize access to the trunking information for Thread safety"
+
+end
+
+describe "The provider DSL's 'provider' macro" do
+
+  it "should make the providers available in the order they were received" do
+    provider_holder = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    provider_holder.class_eval do
+      provider(:tweedledee) {}
+      provider(:tweedledum) {}
+    end
+    provider_holder.providers.map { |x| x.name }.should == [:tweedledee, :tweedledum]
+  end
+  it "should define a singleton method for the provider name given", :focus => true do
+    dsl_class = Class.new(Adhearsion::VoIP::DSL::DialingDSL)
+    dsl_class.class_eval do
+      class_variable_get(:@@providers).size.should == 0
+
+      provider(:icanhascheezburger?) {}
+
+      class_variable_get(:@@providers).size.should == 1
+    end
+    dsl_class.should respond_to(:icanhascheezburger?)
+  end
+  it "should not define a class-wide method for the provider name given" do
+    dsl_class = Class.new(Adhearsion::VoIP::DSL::DialingDSL)
+    dsl_class.class_eval do
+      provider(:icanhascheezburger?) {}
+    end
+    Adhearsion::VoIP::DSL::DialingDSL.class_eval do
+      class_variable_defined?(:@@providers).should == false
+    end
+    Adhearsion::VoIP::DSL::DialingDSL.should_not respond_to(:icanhascheezburger?)
+  end
+  it "should yield a ProviderDefinition object" do
+    possible_provider_definition = nil
+    Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
+      provider(:blah) { |pd| possible_provider_definition = pd }
+    end
+    possible_provider_definition.should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition)
+  end
+  it "should raise an error when no block is given" do
+    the_following_code do
+      Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
+        provider :explode
+      end
+    end.should raise_error ArgumentError
+  end
+end
+
+describe "The provider DSL's monkey patches to Regexp" do
+  it "should return a RouteRule when using Regexp#| with another Regexp" do
+    (// | //).should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  it "should return a RouteRule when chaining three Regexp's with the | operator" do
+    (// | // | //).should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  it "should return a RouteRule when Regexp#| is given a RouteRule" do
+    route_rule = Adhearsion::VoIP::DSL::DialingDSL::RouteRule.new :patterns => //
+    (// | route_rule).should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  it "should return a RouteRule when Regexp#>> is given a ProviderDefinition" do
+    (/1/ >> Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:foo)).
+      should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  it "should return a RouteRule when Regexp#>>() receives a ProviderDefinition" do
+    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:london)
+    (/foo/ >> definition).should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+  end
+  it "should raise an exception when Regexp#| receives something other than a RouteRule" do
+    bad_args = [ 0..100, 20, 45.55, {}, [] ]
+    bad_args.each do |arg|
+      the_following_code { /foo/ | arg }.should raise_error ArgumentError
+    end
+  end
+  it "should raise an exception when Regexp#>>() receives anything other than a ProviderDefintion or RouteRule" do
+    bad_args = [ 0..100, 20, 45.55, {}, [] ]
+    bad_args.each do |arg|
+      the_following_code { /foo/ >> arg }.should raise_error ArgumentError
+    end
+  end
+end
+
+describe "A RouteRule" do
+  it "should expose chained ProviderDefinitions properly" do
+    one, two, three = definitions = %w"foo bar qaz".map do |name|
+      Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new name
+    end
+    route = /^911$/ >> one >> two >> three
+    route.should be_a_kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
+    route.providers.should == definitions
+  end
+  it "should define attr_readers for providers and patterns" do
+    route = Adhearsion::VoIP::DSL::DialingDSL::RouteRule.new
+    route.should respond_to(:patterns)
+    route.should respond_to(:providers)
+  end
+end
+
+describe "The provider order modifiers" do
+   it "should support randomizing trunks", :ignore => true do
+    dsl = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    dsl.class_eval do
+      provider(:l33thost) {}
+      provider(:h4xxhost) {}
+      route /\d+\*548/ >> random(l33thost, h4xxhost)
+    end
+    dsl.routes.first.provider_definitions.first.should be_a_kind_of(
+      Adhearsion::VoIP::DSL::DialingDSL::RandomRouteRule
+    )
+  end
+end
+
+describe "The provider DSL's 'route' builder" do
+  it "should register routes in the order received" do
+    dsl = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    dsl.class_eval do
+      provider(:kewlphone) {}
+      [/1?4445556666/, /123/, /\d+\*548/].each do |r|
+        route r >> kewlphone
+      end
+    end
+    dsl.routes.map { |x| x.patterns }.flatten.should == [/1?4445556666/, /123/, /\d+\*548/]
+  end
+end
+
+describe "A ProviderDefinition" do
+  it "should store any arbitrary property" do
+    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new :foo
+    definition.qaz = :something
+    definition.qaz.should == :something
+  end
+  it "should define a >>() method" do
+    Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:arghh).should respond_to(:>>)
+  end
+
+  it "should format numbers properly" do
+    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:arghh)
+    definition.protocol = "SIP"
+    definition.format_number_for_platform("14445556666", :asterisk).should == "SIP/arghh/14445556666"
+    definition.protocol = "SCCP"
+    definition.format_number_for_platform("16663331111", :asterisk).should == "SCCP/arghh/16663331111"
+
+  end
+end
+
+describe "Routing with the interpreted route definitions" do
+  it "should use the first matching regular expression" do
+    dsl = Class.new Adhearsion::VoIP::DSL::DialingDSL
+    dsl.class_eval do
+      provider(:bad)  {}
+      provider(:good) {}
+      route /^111$/ | /^222$/ | /^333$/ >> good >> bad
+    end
+
+    found = dsl.calculate_routes_for(333)
+
+    1.should be found.size
+    found.first.size.should be 2
+  end
+
+end
+
+# @example = Class.new Adhearsion::VoIP::DSL::DialingDSL
+# @example.class_eval do
+#
+#   provider:kewlphone do |trunk|
+#     trunk.protocol :sip
+#     trunk.host     "voip.nufone.com"
+#     trunk.username "phonedude"
+#     trunk.password "secret"
+#     trunk.enters   :internal
+#   end
+#
+#   route US_NUMBER | US_LOCAL_NUMBER >> voip_ms >> nufone
+#
+#   route INTL_NUMBER >> random(voip_ms, nufone)
+#
+#   # route _('NXX') >> DUNDI
+#
+# end

data/spec/voip/dsl/dispatcher_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/dispatcher_spec_helper'
+require 'adhearsion/voip/dsl/dialplan/dispatcher'
+
+
+describe "A EventCommand" do
+
+  it "should allow a block that's set to response_block()" do
+    block = lambda {}
+    cmd = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "foo", &block
+    cmd.response_block.should be(block)
+  end
+
+  it "should return specified return type with returns()" do
+    return_type = Numeric
+    cmd = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "foo", :returns => return_type
+    cmd.returns.should be(return_type)
+  end
+
+end
+
+describe "The abstract CommandDispatcher" do
+
+  it "should make an attribute reader for context()" do
+    context = "foo"
+    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new String, context
+    d.context.should be(context)
+  end
+
+  it "should instantiate a new instance of the specified factory" do
+    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new Hash
+    d.factory.should be_a_kind_of(Hash)
+  end
+
+  it "should pass the context to the factory when instantiating it" do
+    context = "shazbot"
+    klass = flexmock "a class that has one argument in its constructor"
+    klass.should_receive(:new).with(context)
+    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new klass, context
+  end
+
+  it "should not allow calling dispatch!() directly" do
+    dispatcher = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new MyFactory
+    lambda do
+      dispatcher.dispatch! nil
+    end.should raise_error(NotImplementedError)
+  end
+
+  it "should pass a method and any args onto its CommandFactory" do
+
+    weird_args = [1, 2, ["foo", nil], Object.new, 12.3..13.4]
+
+    bogus_command = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "123"
+
+    dispatcher = NilDispatcher.new MyFactory
+    flexmock(dispatcher.factory).should_receive(:monkey).with(*weird_args).and_return bogus_command
+    dispatcher.monkey(*weird_args)
+
+  end
+
+  it "should continue executing response_blocks until nil is returned" do
+    actual_executions, target_executions = 0, 5
+    response = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "1" do |response|
+      if response > target_executions
+        nil
+      else
+        actual_executions += 1
+        Adhearsion::VoIP::DSL::Dialplan::EventCommand.new(response + 1)
+      end
+    end
+    mock_factory_class = Class.new do
+      def initialize(*args)
+      end
+      def testplz
+        response
+      end
+    end
+    dispatcher = EvalDispatcher.new(mock_factory_class)
+    flexmock(dispatcher.factory).should_receive(:testplz).and_return(response)
+    dispatcher.testplz
+    actual_executions.should be(target_executions)
+  end
+end

data/spec/voip/dsl/dispatcher_spec_helper.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+require 'adhearsion/voip/dsl/dialplan/dispatcher'
+
+module StandardDispatcherBehavior
+  def xtest_standard_dispatcher_behavior
+    #"This it looks bogus.  Not finished?  Let's not check in failing specs ever if we can help it."
+    returned_event_command = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "ilikesexypants"
+    linking_event_command = Adhearsion::VoIP::DSL::Dialplan::EventCommand.new "ihavesexypants" do
+      returned_event_command
+    end
+
+    dispatcher = @dispatcher_class.new MyFactory
+    dispatcher.should_receive(:dispatch!).with(linking_event_command, returned_event_command).and_return(linking_event_command, returned_event_command)
+    # returned_event_command.should_receive(:command_block).and_return nil
+    dispatcher.dispatch! linking_event_command
+  end
+end
+
+class NilDispatcher < Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher
+  def dispatch!(string)
+    # Would send it off to the PBX here (or prepend something to the String)
+  end
+end
+
+class EvalDispatcher < Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher
+  def dispatch!(event)
+    eval event.app.to_s
+  end
+end
+
+class MyFactory
+
+  def initialize(context)
+    @context = context
+  end
+
+  def sequence
+    all = []
+    EventCommand.new("2", :response => Numeric) do |response|
+      all << response
+      all.size > 3 ? all : nil
+    end
+  end
+end

data/spec/voip/dsl/parser_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+require 'adhearsion/voip/dsl/dialplan/parser'
+
+describe "The Adhearsion VoIP dialplan parser" do
+
+  it "should return a list of dialplans properly from dialplan code" do
+    file = "foobar.rb"
+    flexstub(Adhearsion::AHN_CONFIG).should_receive(:files_from_setting).once.with("paths", "dialplan").and_return [file]
+
+    flexmock(File).should_receive(:exists?).with(file).and_return true
+    flexmock(File).should_receive(:read).once.with(file).and_return <<-DIALPLAN
+      internal {
+        play "hello-world"
+      }
+      monkeys {
+        play "tt-monkeys"
+      }
+    DIALPLAN
+    contexts = Adhearsion::VoIP::DSL::Dialplan::DialplanParser.get_contexts
+    contexts.keys.size.should be(2)
+    contexts.keys.should include(:internal)
+    contexts.keys.should include(:monkeys)
+    contexts.each_pair do |context, struct|
+      struct.should be_a_kind_of(OpenStruct)
+      %w"file name block".each do |method|
+        struct.should respond_to(method)
+      end
+    end
+  end
+
+  it "should warn when no dialplan paths were in the .ahnrc file" do
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_setting).once.with("paths", "dialplan").and_return []
+    flexmock(ahn_log.dialplan).should_receive(:warn).once.with(String)
+
+    # Not loading it here is the same as it not existing in the "paths" sub-Hash
+    Adhearsion::VoIP::DSL::Dialplan::DialplanParser.get_contexts
+  end
+
+end
+
+describe "The Adhearsion VoIP dialplan interpreter" do
+
+  it "should make dialplan contexts available within the context's block" do
+    file = "contexts_from_code_helper_pseudo_dialplan.rb"
+    flexstub(Adhearsion::AHN_CONFIG).should_receive(:files_from_setting).once.with("paths", "dialplan").and_return [file]
+
+    flexmock(File).should_receive(:exists?).with(file).and_return true
+    flexmock(File).should_receive(:read).with(file).and_return "foo { cool_method }"
+
+    contexts = Adhearsion::VoIP::DSL::Dialplan::DialplanParser.get_contexts
+
+    contexts.each_pair do |name, struct|
+      contexts.meta_def(name) { struct.code }
+    end
+
+    # Simulate incoming request
+    contexts = contexts.clone
+
+    call_variables = { "callerid" => "14445556666", "context"  => "foo" }
+
+    call_variables.each_pair do |key, value|
+      contexts.meta_def(key) { value }
+      contexts.instance_variable_set "@#{key}", value
+    end
+
+  end
+
+end