adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/voip/freeswitch/basic_connection_manager_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'adhearsion/voip/freeswitch/basic_connection_manager'
-
-include Adhearsion::VoIP::FreeSwitch
-
-describe "FreeSwitch BasicConnectionManager" do
-  attr_reader :manager, :io
-  before(:each) do
-    @io      = StringIO.new
-    @manager = BasicConnectionManager.new io
-  end
-
-  it "<<() should add two newlines" do
-    manager << "foobar"
-    io.string.should == "foobar\n\n"
-  end
-
-end
-
-describe "FreeSwitch BasicConnectionManager's header parser" do
-  it "YAML-like headers are read properly" do
-    header = {
-      "Foo-Bar"                  => "bar",
-      "Qaz-Monkey-Charlie-Zebra" => "qwerty"
-    }
-
-    string_header = header.inject("") do |string, (key, value)|
-      string + "#{key}: #{value}\n"
-    end
-
-    string_header << "\n"
-
-    manager = BasicConnectionManager.new StringIO.new(string_header)
-    manager.get_raw_header.should == string_header.strip
-
-    manager = BasicConnectionManager.new StringIO.new(string_header)
-    manager.get_header.should == header
-  end
-end

data/spec/adhearsion/voip/freeswitch/inbound_connection_manager_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'adhearsion/voip/freeswitch/inbound_connection_manager'
-include Adhearsion::VoIP::FreeSwitch
-
-describe "A FreeSwitch InboundConnectionManager" do
-
-  it "authenticatating with the given password" do
-    manager = InboundConnectionManager.new io_mock
-    manager.login password
-  end
-
-  it "a hash is accepted when creating a new InboundConnectionManager" do
-    host, port = "myhost.mydomain", 31337
-
-    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_return io_mock
-
-    InboundConnectionManager.new :host => host, :port => port, :pass => password
-  end
-
-  it "an IO is accepted when creating a new InboundConnectionManager"
-
-  private
-    def io_mock
-      @io_mock ||=
-        begin
-          io_mock = StringIO.new
-          flexmock(io_mock) do |io|
-            io.should_receive(:write).with("auth #{password}\n\n")
-            io.should_receive(:gets).and_return "connection: kthnx\n",
-              "\n", "login: +OK\n", "\n"
-          end
-          io_mock
-        end
-    end
-
-    def password
-      "supersecret"
-    end
-end

data/spec/adhearsion/voip/freeswitch/oes_server_spec.rb

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

data/spec/adhearsion/voip/numerical_string_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-require 'adhearsion/voip/dsl/numerical_string'
-require 'adhearsion/voip/constants'
-
-describe "A NumericalString" do
-  # FIXME: This test is fundamentally broken in Ruby 1.9.
-  # See https://adhearsion.lighthouseapp.com/projects/5871/tickets/127-ruby-19-and-numericalstring-comparisons-in-case-statements
-  # The suggested workaround is to cast the object to a string:
-  # case numerical_string_object.to_s
-  # when "0987" then ...
-  # end
-#  it "should appear to be behave like a Fixnum in a case statement" do
-#    case numerical_string_for("123")
-#      when 123 then true
-#      else false
-#    end.should be true
-#
-#    case numerical_string_for("0987")
-#      when 987 then true
-#      else false
-#    end.should be true
-#  end
-
-  it "should appear to behave like a String in a case statement" do
-    numerical_string_for("123").should === "123"
-    numerical_string_for("0987").should === "0987"
-  end
-
-  it "when compared against a Range that contains the numeric equivalent, the NumericalString is seen as a member" do
-    (100..200).should === numerical_string_for("150")
-    (100..200).should === numerical_string_for("0150")
-    (100..200).should_not === numerical_string_for("1000000")
-  end
-
-  it "comparing against a regular expression works" do
-    %r|^\d+$|.should === numerical_string_for("027316287")
-  end
-
-  it "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|
-      numerical_string.starts_with_leading_zero?(number).should_not be false
-    end
-
-    without_leading_zeros.each do |number|
-      numerical_string.starts_with_leading_zero?(number).should_not be true
-    end
-  end
-
-  private
-    def numerical_string
-      Adhearsion::VoIP::DSL::NumericalString
-    end
-
-    def numerical_string_for(string)
-      numerical_string.new(string)
-    end
-end

data/spec/adhearsion/voip/phone_number_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_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
-
-def should_be_nil_or_false(arg)
-  [nil, false].include?(arg).should == true
-end
-
-def should_not_be_nil_or_false(arg)
-  [nil, false].include?(arg).should == false
-end
-
-describe "A PhoneNumber" do
-
-  it "should have an ISN pattern-matching method" do
-    should_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("0115544332211").isn?
-    should_not_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("1*548").isn?
-  end
-
-  it "should have a US local number pattern-matching method" do
-    should_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("18887776665555").us_local_number?
-    should_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("18887776665555").us_national_number?
-
-    should_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("8887776665555").us_local_number?
-    should_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("8887776665555").us_national_number?
-
-    should_not_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("4445555").us_local_number?
-    should_be_nil_or_false Adhearsion::VoIP::DSL::PhoneNumber.new("4445555").us_national_number?
-  end
-
-  it "should convert from vanity numbers properly" do
-    Adhearsion::VoIP::DSL::PhoneNumber.from_vanity("1-800-FUDGEME").should == "18003834363"
-  end
-
-end

data/spec/support/the_following_code.rb

@@ -1,3 +0,0 @@
-class Object
-  alias :the_following_code :lambda
-end

data/spec/theatre/dsl_examples/simple_before_call.rb

@@ -1,7 +0,0 @@
-=begin YAML
-namespaces:
-  - ["asterisk", "before_call"]
-=end
-events.asterisk.before_call.each do |call|
-  call.variables[:channel]
-end

data/spec/theatre/dsl_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-class Example
-  attr_reader :name, :yaml, :metadata, :file
-
-  def initialize(name)
-    @name = name.to_sym
-    @file = File.expand_path(File.dirname(__FILE__) + "/dsl_examples/#{name}.rb")
-    @yaml = file_contents[/=begin YAML\n(.+?)\n=end/m, 1]
-    @metadata = @yaml.nil? ? nil : YAML.load(@yaml)
-  end
-
-  def file_contents
-    File.read @file
-  end
-
-  def register_namespaces_on(obj)
-    obj = obj.namespace_manager if obj.kind_of? Theatre::Theatre
-    namespaces = metadata["namespaces"]
-    if namespaces && namespaces.kind_of?(Array) && namespaces.any?
-      namespaces.each do |namespace|
-        obj.register_namespace_name namespace
-      end
-    end
-    obj
-  end
-end
-
-describe "CallbackDefinitionContainer" do
-
-  it "should successfully load the :simple_before_call example" do
-    example = Example.new(:simple_before_call)
-    theatre = Theatre::Theatre.new
-    example.register_namespaces_on theatre
-
-    flexmock(theatre.namespace_manager).should_receive(:register_callback_at_namespace).
-        with([:asterisk, :before_call], Proc).once
-
-    loader  = Theatre::CallbackDefinitionLoader.new(theatre)
-    loader.load_events_file example.file
-  end
-
-  it "should let you override the recorder method name" do
-    theatre = Theatre::Theatre.new
-    theatre.namespace_manager.register_namespace_name "/foo/bar/qaz"
-    flexmock(theatre.namespace_manager).should_receive(:register_callback_at_namespace).
-        with([:foo, :bar, :qaz], Proc).once
-
-    loader = Theatre::CallbackDefinitionLoader.new(theatre, :roflcopter)
-    loader.roflcopter.foo.bar.qaz.each {}
-  end
-
-end
-
-# High level specs to test the entire library.
-
-describe "Misuses of the Theatre" do
-
-  it "should not allow callbacks to be registered for namespaces which have not been registered" do
-    theatre = Theatre::Theatre.new
-    example = Example.new(:simple_before_call)
-
-    loader = Theatre::CallbackDefinitionLoader.new(theatre)
-    lambda do
-      loader.events.foo.each {}
-    end.should raise_error(Theatre::NamespaceNotFound)
-  end
-
-end

data/spec/theatre/invocation_spec.rb

@@ -1,182 +0,0 @@
-require 'spec_helper'
-
-GUID_REGEXP = /^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$/i
-
-module InvocationTestHelper
-  def new_invocation(payload=@payload)
-    Theatre::Invocation.new(@namespace, @block, @payload)
-  end
-end
-
-describe "The lifecycle of an Invocation" do
-
-  include InvocationTestHelper
-
-  before :all do
-    @block   = lambda {}
-    @payload = 123
-    @namespace = "/some/namespace"
-  end
-
-  it "should have an initial state of :new" do
-    new_invocation.current_state.should eql(:new)
-  end
-
-  it "should not have a @queued_time until state becomes :queued" do
-    invocation = new_invocation
-    invocation.queued_time.should eql(nil)
-    invocation.queued
-    invocation.queued_time.should be_instance_of(Time)
-    invocation.current_state.should eql(:queued)
-  end
-
-  it "should have a valid guid when instantiated" do
-    new_invocation.unique_id.should =~ GUID_REGEXP
-  end
-
-  it "should execute the callback when moving to the 'start' state" do
-    flexmock(@block).should_receive(:call).once
-    invocation = new_invocation
-    invocation.queued
-    invocation.start
-  end
-
-end
-
-describe "Using Invocations that've been ran through the Theatre" do
-
-  it "should pass the payload to the callback" do
-    destined_payload = [:i_feel_so_pretty, :OH, :SO, :PRETTY!]
-    expecting_callback = lambda do |payload|
-      payload.should equal(destined_payload)
-    end
-    invocation = Theatre::Invocation.new("/namespace/whatever", expecting_callback, destined_payload)
-    invocation.queued
-    invocation.start
-  end
-
-  it "should have a status of :error if an exception was raised and set the #error property" do
-    invocation = Theatre::Invocation.new("/namespace/whatever", lambda { raise ArgumentError, "this error is intentional" })
-    invocation.queued
-    invocation.start
-    invocation.current_state.should == :error
-    invocation.should be_error
-    invocation.error.should be_instance_of(ArgumentError)
-  end
-
-  it "should trigger an exception event if an exception was raised" do
-    invocation = Theatre::Invocation.new("/namespace/whatever", lambda { raise ArgumentError, "this error is intentional" })
-    flexmock(Adhearsion::Events).should_receive(:trigger).once.with('/exception', FlexMock.any)
-    invocation.queued
-    invocation.start
-  end
-
-  it "should NOT trigger an exception if the exception occurs in an exception namespace" do
-    invocation = Theatre::Invocation.new("/exception", lambda { raise ArgumentError, "this error is intentional" })
-    flexmock(Adhearsion::Events).should_receive(:trigger).never
-    invocation.queued
-    invocation.start
-  end
-
-  it "should do the right thing with exceptions triggered with the wrong namespace" do
-    invocation = Theatre::Invocation.new(['exception'], lambda { raise ArgumentError, "this error is intentional" })
-    flexmock(Adhearsion::Events).should_receive(:trigger).never
-    invocation.queued
-    invocation.start
-  end
-
-  it "should have a status of :success if no expection was raised" do
-    callback = lambda { "No errors raised here!" }
-    invocation = Theatre::Invocation.new("/namespace/whatever", callback)
-    invocation.queued
-    invocation.start
-    invocation.current_state.should equal(:success)
-    invocation.should be_success
-  end
-
-  it "should set the #returned_value property to the returned value callback when a payload was given" do
-    doubler = lambda { |num| num * 2 }
-    invocation = Theatre::Invocation.new('/foo/bar', doubler, 5)
-    invocation.queued
-    invocation.start
-    invocation.returned_value.should equal(10)
-  end
-
-  it "should set the #returned_value property to the returned value callback when a payload was NOT given" do
-    doubler = lambda { :ohai }
-    invocation = Theatre::Invocation.new('/foo/bar', doubler)
-    invocation.queued
-    invocation.start
-    invocation.returned_value.should equal(:ohai)
-  end
-
-  it "should set the #finished_time property when a success was encountered" do
-    block = lambda {}
-    invocation = Theatre::Invocation.new('/foo/bar', block)
-    invocation.queued
-
-    now = Time.now
-    flexmock(Time).should_receive(:now).twice.and_return now
-
-    invocation.start
-    invocation.should be_success
-  end
-
-  it "should set the #finished_time property when a failure was encountered" do
-    invocation = Theatre::Invocation.new('/foo/bar', lambda { raise LocalJumpError })
-    invocation.queued
-
-    invocation.start
-    invocation.should be_error
-    invocation.finished_time.should be_kind_of(Time)
-  end
-
-  it "should set the #started_time property after starting" do
-    invocation = Theatre::Invocation.new('/foo/bar', lambda { sleep 0.01 } )
-    invocation.queued
-    invocation.started_time.should be_nil
-    invocation.start
-    invocation.started_time.should be_kind_of(Time)
-  end
-
-  it "should properly calculate #execution_duration" do
-    time_ago_difference = 60 * 5 # Five minutes
-    time_now = Time.now
-    time_ago = time_now - time_ago_difference
-
-    invocation = Theatre::Invocation.new('/foo/bar', lambda {} )
-    invocation.queued
-    invocation.start
-
-    invocation.send(:instance_variable_set, :@started_time, time_ago)
-    invocation.send(:instance_variable_set, :@finished_time, time_now)
-
-    invocation.execution_duration.should be_within(0.01).of(time_ago_difference.to_f)
-  end
-
-  it "should return the set value of returned_value when one has been set to a non-nil value" do
-    return_nil = lambda { 123 }
-    invocation = Theatre::Invocation.new("/namespace/whatever", return_nil)
-    invocation.queued
-    invocation.start
-    invocation.returned_value.should eql(123)
-  end
-
-  it "should return nil for returned_value when it has been set to nil" do
-    return_nil = lambda { nil }
-    invocation = Theatre::Invocation.new("/namespace/whatever", return_nil)
-    invocation.queued
-    invocation.start
-    invocation.returned_value.should eql(nil)
-  end
-
-  it "waiting on an Invocation should execute properly" do
-    wait_on_invocation = lambda { 123 }
-    invocation = Theatre::Invocation.new("/namespace/whatever", wait_on_invocation)
-    invocation.queued
-    invocation.start
-    invocation.wait.should eql(123)
-    invocation.success?.should eql(true)
-  end
-
-end