eric-adhearsion 0.7.999 → 0.8.0

data/spec/voip/asterisk/test_config_manager.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + "/../../test_helper"
-require 'adhearsion/voip/asterisk/config_manager'
-
-context "The configuration file parser behavior" do
-  
-  include ConfigurationManagerTestHelper
-  
-  test "should expose a sections array" do
-    manager = mock_config_manager
-    manager.sections.map(&:first).should.equal(["jicksta", "picard"])
-  end
-  
-  test "should ignore comments" do
-    context_names = %w(monkey data)
-    tested_key_name, tested_key_value_before_comment = "bar", "baz"
-    manager = mock_config_manager_for <<-CONFIG
-[monkey]
-#{tested_key_name}=#{tested_key_value_before_comment};thiscommentshouldnotbehere
-asdf=fdsa
-;[data]
-;ignored=asdf
-    CONFIG
-    manager.sections.map(&:first).should.equal [context_names.first]
-    manager[context_names.first].size.should.equal 2
-    manager[context_names.first][tested_key_name].should.equal tested_key_value_before_comment
-  end
-  
-  test "should match context names with dashes and underscores" do
-    context_names = %w"foo-bar qaz_b-a-z"
-    definition_string = <<-CONFIG
-[#{context_names.first}]
-platypus=no
-zebra=no
-crappyconfig=yes
-
-[#{context_names.last}]
-callerid="Jay Phillips" <133>
-    CONFIG
-    mock_config_manager_for(definition_string).sections.map(&:first).should.equal context_names
-  end
-  
-  test "should strip whitespace around keys and values" do
-    section_name = "hey-there-hot-momma"
-    tested_key_name, tested_key_value_before_comment = "bar", "i heart white space. SIKE!"
-    config_manager = mock_config_manager_for <<-CONFIG
-   \t[#{section_name}]                              
-  
-   thereis            =  a lot of whitespace after these                      
-
-    #{tested_key_name}   = \t\t\t #{tested_key_value_before_comment}                
-        
-    CONFIG
-    config_manager[section_name][tested_key_name].should.equal tested_key_value_before_comment
-  end
-  
-  test "should return a Hash of properties when searching for an existing section" do
-    result = mock_config_manager["jicksta"]
-    result.should.be.kind_of Hash
-    result.size.should.equal 3
-  end
-  
-  test "should return nil when searching for a non-existant section" do
-    mock_config_manager["i-so-dont-exist-dude"].should.be.nil
-  end
-  
-end
-
-context "The configuration file writer" do
-  
-  include ConfigurationManagerTestHelper
-  
-  attr_reader :config_manager
-  
-  setup do
-    @config_manager = mock_config_manager
-  end
-  
-  test "should remove an old section when replacing it" do
-    config_manager.delete_section "picard"
-    config_manager.sections.map(&:first).should.equal ["jicksta"]
-  end
-  
-  test "should add a new section to the end" do
-    section_name = "wittynamehere"
-    config_manager.new_section(section_name, :type => "friend",
-                                             :witty => "yes",  
-                                             :shaken => "yes", 
-                                             :stirred => "no")
-    new_section = config_manager.sections.last
-    new_section.first.should.equal section_name
-    new_section.last.size.should.equal 4
-  end
-end
-
-context "The configuration file generator" do 
-end
-
-BEGIN {
-module ConfigurationManagerTestHelper
-  
-  def mock_config_manager
-    mock_config_manager_for sample_standard_config
-  end
-  
-  def mock_config_manager_for(config_string)
-    returning new_config_manager_with("bogus filename") do |manager|
-      flexmock(manager).should_receive(:execute).and_return(config_string)
-    end
-  end
-  
-  def new_config_manager_with(filename)
-    Adhearsion::VoIP::Asterisk::ConfigurationManager.new(filename)
-  end
-  
-  def sample_standard_config
-    <<-CONFIG
-[jicksta]
-foo=bar
-qaz=qwerty
-baz=zxcvb
-[picard]
-type=friend
-insecure=very
-host=dynamic
-secret=blargh
-    CONFIG
-  end
-end
-}

data/spec/voip/dsl/dispatcher_spec_helper.rb

@@ -1,45 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_helper'
-
-require 'adhearsion/voip/dsl/dialplan/dispatcher'
-
-module StandardDispatcherBehavior  
-  def xtest_standard_dispatcher_behavior
-    #"This test 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/test_dialing_dsl.rb

@@ -1,268 +0,0 @@
-require File.dirname(__FILE__) + '/../../test_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
-  
-  test "should compile two Regexps" do
-    first, last = /jay/, /phillips/
-    r = first | last
-    r.patterns.should == [first, last]
-  end
-  
-  test "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
-  
-  test "should store one pattern properly" do
-    pattern = /lorem/
-    route = pattern >> @provider
-    route.patterns.should == [pattern]
-  end
-  
-  test "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
-  
-  test "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
-  
-  test "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
-  
-  test "should allow Asterisk-like patterns" do
-    Adhearsion::VoIP::DSL::DialingDSL.class_eval do
-      _('23XX')
-    end.should.be.instance_of Regexp
-  end
-  
-  test "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 NameError
-  end
-  
-  # test "should define a DUNDI constant"
-  
-  test "should synchronize access to the trunking information for Thread safety"
-  
-end
-
-describe "The provider DSL's 'provider' macro" do
-  
-  test "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
-  test "should define a singleton method for the provider name given" do
-    Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
-      class_variable_get(:@@providers).size.should == 0
-      
-      provider(:icanhascheezburger?) {}
-      
-      should.respond_to(:icanhascheezburger?)
-      class_variable_get(:@@providers).size.should == 1
-    end
-  end
-  test "should not define a class-wide method for the provider name given" do
-    Class.new(Adhearsion::VoIP::DSL::DialingDSL).class_eval do
-      provider(:icanhascheezburger?) {}
-    end
-    Adhearsion::VoIP::DSL::DialingDSL.class_eval do
-      class_variable_defined?(:@@providers).should == false
-      should.not.respond_to(:icanhascheezburger?)
-    end
-  end
-  test "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
-  test "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 ArgumentError
-  end
-end
-
-describe "The provider DSL's monkey patches to Regexp" do
-  test "should return a RouteRule when using Regexp#| with another Regexp" do
-    (// | //).should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
-  end
-  test "should return a RouteRule when chaining three Regexp's with the | operator" do
-    (// | // | //).should.be.a.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
-  end
-  test "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
-  test "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
-  test "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
-  test "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 ArgumentError
-    end
-  end
-  test "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 ArgumentError
-    end
-  end
-end
-
-describe "A RouteRule" do
-  test "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.kind_of(Adhearsion::VoIP::DSL::DialingDSL::RouteRule)
-    route.providers.should == definitions
-  end
-  test "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
-  disabled_test "should support randomizing trunks" 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
-  test "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
-  test "should store any arbitrary property" do
-    definition = Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new :foo
-    definition.qaz = :something
-    definition.qaz.should == :something
-  end
-  test "should define a >>() method" do
-    Adhearsion::VoIP::DSL::DialingDSL::ProviderDefinition.new(:arghh).should.respond_to(:>>)
-  end
-  
-  test "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
-  test "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)
-    
-    assert_equal 1, found.size
-    found.first.size.should.equal 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/test_dispatcher.rb

@@ -1,82 +0,0 @@
-require File.dirname(__FILE__) + '/dispatcher_spec_helper'
-require 'adhearsion/voip/dsl/dialplan/dispatcher'
-
-
-describe "A EventCommand" do
-  
-  test "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.equal(block)
-  end
-  
-  test "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.equal(return_type)
-  end
-  
-end
-
-describe "The abstract CommandDispatcher" do
-  
-  test "should make an attribute reader for context()" do
-    context = "foo"
-    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new String, context
-    d.context.should.equal(context)
-  end
-
-  test "should instantiate a new instance of the specified factory" do
-    d = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new Hash
-    d.factory.should.be.kind_of(Hash)
-  end
-  
-  test "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
-  
-  test "should not allow calling dispatch!() directly" do
-    dispatcher = Adhearsion::VoIP::DSL::Dialplan::CommandDispatcher.new MyFactory
-    lambda do
-      dispatcher.dispatch! nil
-    end.should.raise(NotImplementedError)
-  end
-  
-  test "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
-  
-  test "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.equal(target_executions)
-  end
-end