adhearsion 1.0.1 → 1.0.2

data/spec/voip/freeswitch/basic_connection_manager_spec.rb

@@ -0,0 +1,39 @@
+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/voip/freeswitch/inbound_connection_manager_spec.rb

@@ -0,0 +1,39 @@
+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/voip/freeswitch/oes_server_spec.rb

@@ -0,0 +1,9 @@
+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/voip/numerical_string_spec.rb

@@ -0,0 +1,61 @@
+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/voip/phone_number_spec.rb

@@ -0,0 +1,45 @@
+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/theatre-spec/dsl_examples/dynamic_stomp.rb

@@ -0,0 +1,7 @@
+events.stomp.this_is_a_dynamic_name.each do
+
+end
+
+events.stomp.new_call.each do
+
+end

data/theatre-spec/dsl_examples/simple_before_call.rb

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

data/theatre-spec/dsl_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+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/theatre-spec/invocation_spec.rb

@@ -0,0 +1,167 @@
+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
+    errorful_callback = lambda { raise ArgumentError, "this error is intentional" } # Simulate logic error
+    invocation = Theatre::Invocation.new("/namespace/whatever", errorful_callback)
+    invocation.queued
+    invocation.start
+    invocation.current_state.should equal(:error)
+    invocation.should be_error
+    invocation.error.should be_instance_of(ArgumentError)
+  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
+    block = lambda { raise LocalJumpError }
+    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_error
+  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_close(time_ago_difference.to_f, 0.01)
+  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)
+    Thread.new do
+      invocation.queued
+      invocation.start
+    end
+    invocation.wait.should eql(123)
+    invocation.success?.should eql(true)
+  end
+
+end

data/theatre-spec/namespace_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module NamespaceHelper
+  class BeValidNamespace
+
+    def matches?(target)
+      @target = target
+      Theatre::ActorNamespaceManager.valid_namespace_path? target
+    end
+
+    def failure_message
+      "expected #{@target.inspect} to be a valid namespace"
+    end
+
+    def negative_failure_message
+      "expected #{@target.inspect} not to be a valid namespace"
+    end
+
+  end
+
+  def be_valid_actor_event_namespace
+    BeValidNamespace.new
+  end
+
+end
+
+describe "ActorNamespaceManager" do
+
+  it "should make a registered namespace findable once registered" do
+    nm = Theatre::ActorNamespaceManager.new
+    nm.register_namespace_name "/foo/bar/qaz"
+    nm.search_for_namespace("/foo/bar/qaz").should be_kind_of(Theatre::ActorNamespaceManager::NamespaceNode)
+  end
+
+  it "should return the new namespace when registering it" do
+
+  end
+
+  it "#search_for_namespace should raise a NamespaceNotFound exception if a namespace one level deep was not found" do
+    nm = Theatre::ActorNamespaceManager.new
+    lambda do
+      nm.search_for_namespace "/foo"
+    end.should raise_error(Theatre::NamespaceNotFound)
+  end
+
+  it "#search_for_namespace should raise a NamespaceNotFound exception if a namespace two levels deep was not found" do
+    nm = Theatre::ActorNamespaceManager.new
+    lambda do
+      nm.search_for_namespace "/foo/bar"
+    end.should raise_error(Theatre::NamespaceNotFound)
+  end
+
+  describe '::normalize_path_to_array' do
+    it "should split a standard path properly" do
+      Theatre::ActorNamespaceManager.normalize_path_to_array("/foo/bar/qaz").should == [:foo, :bar, :qaz]
+    end
+
+    it "should split out Array()'d form of a String path properly" do
+      Theatre::ActorNamespaceManager.normalize_path_to_array(["/jay/thomas/phillips"]).should == [:jay,:thomas,:phillips]
+    end
+  end
+
+end
+
+describe "NamespaceNode" do
+
+  it "when registering a new namespace, the new NamespaceNode should be returned" do
+    node = Theatre::ActorNamespaceManager::NamespaceNode.new "foobar"
+    node.register_namespace_name("foobar").should be_instance_of(Theatre::ActorNamespaceManager::NamespaceNode)
+  end
+
+  it "should not blow away an existing callback when registering a new one with the same name" do
+    name = "blah"
+    node = Theatre::ActorNamespaceManager::NamespaceNode.new name
+    node.register_namespace_name name
+    before = node.child_named(name)
+    before.should be_instance_of(Theatre::ActorNamespaceManager::NamespaceNode)
+    node.register_namespace_name name
+    before.should eql(node.child_named(name))
+  end
+
+  describe '#register_namespace_name' do
+    it "should return the NamespaceNode" do
+      Theatre::ActorNamespaceManager::NamespaceNode.new("foo").register_namespace_name("bar").should \
+          be_instance_of(Theatre::ActorNamespaceManager::NamespaceNode)
+    end
+  end
+
+end
+
+describe "Valid namespace segments" do
+
+  include NamespaceHelper
+
+  describe "a valid namespace path" do
+
+    it "should require a namespace path start with a /" do
+      "/foo".   should     be_valid_actor_event_namespace
+      "foo".    should_not be_valid_actor_event_namespace
+      "foo/bar".should_not be_valid_actor_event_namespace
+    end
+
+    it "should allow multiple namespace segments" do
+      "/foo_foo/bar".should be_valid_actor_event_namespace
+    end
+
+    it "should not allow a trailing forward slash" do
+      "/foo/bar/".should_not be_valid_actor_event_namespace
+    end
+
+    it "should not allow backslashes" do
+      '\foo'.should_not be_valid_actor_event_namespace
+      '\foo\bar'.should_not be_valid_actor_event_namespace
+      'foo\bar'.should_not be_valid_actor_event_namespace
+      '\bar\\'.should_not be_valid_actor_event_namespace
+    end
+
+    it "should not allow weird characters" do
+      %w[ ! @ # $ % ^ & * ( ) { } | ' : ? > < - = ].each do |bad_character|
+        "/foo#{bad_character}foo/bar".should_not be_valid_actor_event_namespace
+      end
+    end
+
+  end
+end