adhearsion 1.0.1 → 1.0.2

data/spec/constants_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe "The Adhearsion module" do
+  # This it is of questionable benefit
+  it "should have a VERSION constant" do
+    Adhearsion.const_defined?(:VERSION).should be true
+  end
+end

data/spec/drb_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module DRbTestHelper
+
+  def new_drb_rpc_object
+    Object.new.tap do |obj|
+      @component_manager.extend_object_with(obj, :rpc)
+    end
+  end
+
+  def add_rpc_methods(code)
+    @component_manager.load_code "methods_for(:rpc) do; #{code}; end"
+  end
+
+end
+
+describe "Invoking an interface method via DRb" do
+  include DRbTestHelper
+
+  it "should raise an exception if the method is not found" do
+    the_following_code do
+      new_drb_rpc_object.this_method_doesnt_exist
+    end.should raise_error NoMethodError
+  end
+
+  before(:all) { require 'drb' }
+
+  before :each do
+    @component_manager = Adhearsion::Components::ComponentManager.new("/path/doesnt/matter")
+    @door = DRb.start_service "druby://127.0.0.1:#{37832 + rand(1500)}", new_drb_rpc_object
+  end
+
+  after :each do
+    @door.stop_service
+    @door.thread.kill
+  end
+
+  it "should return normal Ruby data structures properly over DRb" do
+    add_rpc_methods <<-RUBY
+      def bar
+        [3,2,1]
+      end
+    RUBY
+    client = DRbObject.new nil, DRb.uri
+    client.bar.should == [3, 2, 1]
+  end
+
+  it "should raise an exception for a non-existent interface" do
+    client = DRbObject.new nil, DRb.uri
+    the_following_code do
+      client.interface.bad_interface.should be [3, 2, 1]
+    end.should raise_error NoMethodError
+  end
+
+  it "should raise an exception for a non-existent method" do
+    client = DRbObject.new nil, DRb.uri
+    the_following_code do
+      client.interface.interface.foobar.equal [3, 2, 1]
+    end.should raise_error NoMethodError
+  end
+
+  after do
+    DRb.stop_service
+  end
+end

data/spec/fixtures/dialplan.rb

@@ -0,0 +1,3 @@
+sample_context {
+  raise 'the body of this context should not have been evaluated'
+}

data/spec/foundation/event_socket_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+module EventSocketTestHelper
+  def mock_handler_object
+    flexmock.tap do |handler|
+      flexstub(handler).should_receive(:connected)
+      flexstub(handler).should_receive(:receive_data)
+      flexstub(handler).should_receive(:disconnected)
+    end
+  end
+end
+
+describe "a new EventSocket" do
+
+  include EventSocketTestHelper
+
+  it "instantiating a new EventSocket should not instantiate a TCPSocket yet" do
+    flexmock(TCPSocket).should_receive(:new).never
+    EventSocket.new("localhost", 1234, mock_handler_object)
+  end
+
+  it "instantiating a new EventSocket with both a block and a handler object" do
+    the_following_code {
+      EventSocket.new("localhost", 1234, mock_handler_object) {}
+    }.should raise_error ArgumentError
+  end
+
+  it "instantiating a new EventSocket with neither a block nor handler object" do
+    the_following_code {
+      EventSocket.new("localhost", 1234)
+    }.should raise_error ArgumentError
+  end
+
+  it "should have an initial state of :new" do
+    EventSocket.new("localhost", 1234, mock_handler_object).state.should be :new
+  end
+
+  it "the handler created when instantiating the EventSocket with a block" do
+    event_socket = EventSocket.new("foo", 123) do |handler|
+      handler.receive_data { throw :inside_receive_data }
+      handler.disconnected { throw :inside_disconnected}
+      handler.connected { throw :inside_connected }
+    end
+    handler = event_socket.send(:instance_variable_get, :@handler)
+    the_following_code {
+      handler.send :receive_data, ''
+    }.should throw_symbol :inside_receive_data
+
+    %w[disconnected connected].each do |callback|
+      the_following_code {
+        handler.send callback
+      }.should throw_symbol "inside_#{callback}".to_sym
+    end
+  end
+
+  it 'the handler created when instantiating the EventSocket with a block in which "def" is used to define callbacks' do
+    event_socket = EventSocket.new("foo", 123) do |handler|
+      def handler.receive_data
+        throw :inside_receive_data
+      end
+      def handler.disconnected
+        throw :inside_disconnected
+      end
+      def handler.connected
+        throw :inside_connected
+      end
+    end
+    handler = event_socket.send(:instance_variable_get, :@handler)
+    %w[receive_data disconnected connected].each do |callback|
+      the_following_code {
+        handler.send callback
+      }.should throw_symbol "inside_#{callback}".to_sym
+    end
+  end
+
+end
+
+describe "connecting an EventSocket" do
+
+  include EventSocketTestHelper
+
+  before :each do
+    flexmock(Mutex).new_instances.should_receive(:synchronize).zero_or_more_times.and_yield
+  end
+
+  it "should instantiate a new TCPSocket with the correct host and port" do
+    host, port = "google.com", 80
+    mock_socket = flexmock "TCPSocket"
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port)
+    EventSocket.new(host, port, mock_handler_object).connect!
+  end
+
+  it "should have a state of :connected if TCPSocket instantiates without error" do
+    host, port = "google.com", 80
+    mock_socket = flexmock "TCPSocket"
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port)
+    event_socket = EventSocket.new(host, port, mock_handler_object)
+    event_socket.connect!
+    # Avoid race condition in JRuby where state may return nil
+    sleep(0.1)
+    event_socket.state.should be :connected
+  end
+
+  it "should have a state of :failed after ECONNREFUSED is raised" do
+    host, port = "google.com", 80
+    flexmock(TCPSocket).should_receive(:new).once.with(host, port).and_raise(Errno::ECONNREFUSED)
+    event_socket = EventSocket.new(host, port, mock_handler_object)
+
+    the_following_code {
+      event_socket.connect!
+    }.should raise_error Errno::ECONNREFUSED
+
+    event_socket.state.should be :failed
+  end
+
+  it "should instantiate a new Thread which calls EventSocket#reader_loop" do
+    flexmock(TCPSocket).should_receive(:new).once
+    flexmock(Thread).should_receive(:new).and_yield
+    the_following_code {
+      event_socket = EventSocket.new("foo", 123, mock_handler_object)
+      flexmock(event_socket).should_receive(:reader_loop).once.and_throw :in_thread_loop
+      event_socket.connect!
+    }.should throw_symbol :in_thread_loop
+  end
+
+end
+
+describe "the reader_loop method" do
+
+  include EventSocketTestHelper
+
+  it "should call readpartial() on the TCPSocket and pass that to the receive_data method of handler" do
+    mock_handler = flexmock "mock handler object"
+    mock_socket  = flexmock "TCPSocket"
+    data         = "Jay Phillips " * 25
+
+    mock_handler.should_receive(:connected).and_return
+    mock_handler.should_receive(:disconnected).and_return
+    mock_handler.should_receive(:receive_data).once.with(data).and_throw :done_testing
+
+    mock_socket.should_receive(:readpartial).once.with(EventSocket::MAX_CHUNK_SIZE).and_return data
+
+    flexmock(TCPSocket).should_receive(:new).once.and_return mock_socket
+    flexmock(Thread).should_receive(:new).and_yield
+
+    the_following_code {
+      EventSocket.new("foo", 123, mock_handler).connect!
+    }.should throw_symbol :done_testing
+  end
+
+  it "should set the state to :connection_dropped when an EOFError is raised by readpartial" do
+    mock_socket  = flexmock "TCPSocket"
+    mock_socket.should_receive(:readpartial).once.and_raise EOFError
+    flexmock(TCPSocket).should_receive(:new).once.and_return mock_socket
+
+    flexmock(Thread).should_receive(:new).and_yield
+
+    event_socket = EventSocket.new("foo", 123, mock_handler_object)
+
+    event_socket.connect!
+    event_socket.state.should be :connection_dropped
+  end
+
+end
+
+describe "the writer_loop method" do
+
+end

data/spec/host_definitions_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'adhearsion/host_definitions'
+
+describe 'HostDefinition' do
+
+  after :each do
+    Adhearsion::HostDefinition.clear_definitions!
+  end
+
+  it 'when loading from a YAML array, it should pass each nested Hash to the constructor' do
+    hosts = [
+      {:host => "hostname1", :username => "user", :password => "password"},
+      {:host => "hostname2", :username => "user", :password => "password"},
+      {:host => "hostname3", :username => "user", :password => "password"}
+    ]
+    flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(hosts[0])
+    flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(hosts[1])
+    flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(hosts[2])
+    Adhearsion::HostDefinition.import_from_yaml hosts.to_yaml
+  end
+
+  it 'should set the @name property to a new UUID when no name is given' do
+    definition = {:host => "hostname", :username => "user", :password => "pass"}
+    Adhearsion::HostDefinition.new(definition).name.should =~ /^[a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}$/i
+  end
+
+  it 'when loading from YAML keys, it should pass each nested Hash to the constructor with the key as :name' do
+    definitions = { :pbx1 => {},
+                    :pbx2 => {},
+                    :pbx3 => {} }
+    definitions.each_pair do |key,value|
+      flexmock(Adhearsion::HostDefinition).should_receive(:new).once.with(value.merge(:name => key))
+    end
+    Adhearsion::HostDefinition.import_from_data_structure(definitions)
+  end
+
+  it 'should have an Array class variable named definitions' do
+    Adhearsion::HostDefinition.definitions.should be_a_kind_of Array
+  end
+
+  it 'should add each HostDefinition to a class variable named @@definitions when instantiated' do
+    Adhearsion::HostDefinition.definitions.size.should be 0
+    Adhearsion::HostDefinition.new :name => "foobar", :host => "hostname", :username => "user", :password => "password"
+    Adhearsion::HostDefinition.definitions.size.should be 1
+    Adhearsion::HostDefinition.clear_definitions!
+    Adhearsion::HostDefinition.definitions.size.should be 0
+  end
+
+  it 'should raise a HostDefinitionException when a password and a key are given' do
+    the_following_code {
+      Adhearsion::HostDefinition.new(:username => "user", :host => "foobar", :key => "doesntmatter", :password => "pass")
+    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
+  end
+
+  it 'should raise a HostDefinitionException when no password or key is given' do
+    the_following_code {
+      Adhearsion::HostDefinition.new(:username => "user", :host => "foobar")
+    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
+  end
+
+  it 'should raise a HostDefinitionException when no username is given' do
+    the_following_code {
+      Adhearsion::HostDefinition.new(:host => "host", :password => "password")
+    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
+  end
+
+  it 'should raise a HostDefinitionException when no "host" key is given' do
+    the_following_code {
+      Adhearsion::HostDefinition.new(:username => "foobar", :password => "password")
+    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
+  end
+
+  it 'should raise a HostDefinitionException when an unrecognized key is given' do
+    the_following_code {
+      Adhearsion::HostDefinition.new(:username => "foobar", :password => "password", :host => "blah", :thiskeyisnotrecognized => nil)
+    }.should raise_error Adhearsion::HostDefinition::HostDefinitionException
+  end
+
+end

data/spec/initialization_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe "Adhearsion::Initializer" do
+
+  include InitializerStubs
+  # TODO: create a specification for aliases
+
+  before :each do
+    Adhearsion.send(:remove_const, 'AHN_CONFIG') if Adhearsion.const_defined? 'AHN_CONFIG'
+    Adhearsion::AHN_CONFIG = Adhearsion::Configuration.new
+  end
+
+  after :each do
+    Adhearsion::Events.reinitialize_theatre!
+  end
+
+  it "initialization will start with only a path given" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      Adhearsion::Initializer.start path
+    end
+  end
+
+  it "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+       flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+       ahn = Adhearsion::Initializer.start path, :pid_file => true
+       ahn.pid_file[0, path.length].should == path
+    end
+  end
+
+  it "should NOT create a pid file in the app's path when given 'false' as the pid_file hash key argument" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      ahn = Adhearsion::Initializer.start path, :pid_file => false
+      ahn.pid_file.should be nil
+    end
+  end
+
+  it "should create a pid file in the app's path by default when daemonizing" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      flexmock(File).should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w', Proc)
+      ahn = Adhearsion::Initializer.start path, :daemon => true
+      ahn.pid_file[0, path.size].should == path
+    end
+  end
+
+  it "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      ahn = Adhearsion::Initializer.start path, :daemon => true, :pid_file => false
+      ahn.pid_file.should be nil
+    end
+  end
+
+  it "should execute gem when .ahnrc contains gem names" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      ahn_rc = {
+        "gems" => {
+          "activerecord" => { "version" => ">= 1.2.0" },
+          "twitter" => nil
+        },
+        # Paths are unnecessary except to make the other part of bootstrap_rc happy.
+        "paths"=>{"dialplan"=>"dialplan.rb", "init"=>"config/startup.rb", "events"=>"events.rb",
+            "models"=> "models/*.rb"}
+      }
+      ahn = Adhearsion::Initializer.new path
+      flexmock(Adhearsion::Initializer).should_receive(:get_rules_from).once.and_return ahn_rc
+      flexmock(ahn).should_receive(:gem).once.with("activerecord", ">= 1.2.0")
+      flexmock(ahn).should_receive(:gem).once.with("twitter")
+      ahn.start
+    end
+  end
+
+  it "should require() the lib when .ahnrc contains a require section with one name" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      ahn_rc = {
+        "gems" => {
+          "twitter" => {
+            "require" => "sometwitterstuffs"
+          }
+        },
+        # Paths are unnecessary except to make the other part of bootstrap_rc happy.
+        "paths"=>{"dialplan"=>"dialplan.rb", "init"=>"config/startup.rb", "events"=>"events.rb",
+            "models"=>"models/*.rb"}
+      }
+      ahn = Adhearsion::Initializer.new path
+      flexmock(Adhearsion::Initializer).should_receive(:get_rules_from).once.and_return ahn_rc
+      flexstub(ahn).should_receive(:gem).once.with("twitter")
+      flexmock(ahn).should_receive(:require).once.with("sometwitterstuffs")
+      flexmock(ahn).should_receive(:require).at_least.once.with(String)
+      ahn.start
+    end
+  end
+
+  it "should create a designated pid file when supplied a String path as :pid_file" do
+    random_file = "/tmp/AHN_TEST_#{rand 100000}.pid"
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      ahn = Adhearsion::Initializer.start path, :pid_file => random_file
+      ahn.pid_file.should be(random_file)
+      File.exists?(random_file).should be true
+      File.delete random_file
+    end
+  end
+
+  it "should initialze events properly" do
+    require 'theatre'
+    events_rb = Tempfile.new "events.rb"
+    initializer = Adhearsion::Initializer.new("/does/not/matter")
+    flexmock(Adhearsion::AHN_CONFIG).should_receive(:files_from_setting).at_least.once.with("paths", "events").
+        and_return([events_rb.path])
+    flexmock(Adhearsion::Events.framework_theatre).should_receive(:load_events_file).once.with events_rb.path
+    flexmock(Adhearsion::Events.framework_theatre).should_receive(:start!).once
+
+    initializer.send :init_events_subsystem
+    initializer.send :init_events_file
+  end
+
+  private
+    def path
+      '/any/ole/path'
+    end
+end
+
+describe "AHN_ROOT" do
+  include InitializerStubs
+  before(:each) do
+    Object.send(:remove_const, :AHN_ROOT) if defined? AHN_ROOT
+  end
+
+  it "initializing will create the AHN_ROOT" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      ahn = Adhearsion::Initializer.start path
+      Object.constants.map(&:to_s).include?("AHN_ROOT").should be true
+    end
+  end
+
+  it "swapping out the base_path for the duration of the block" do
+    original_base_path = '.'
+    temporary_base     = '/foo'
+
+    path = Adhearsion::PathString.new(original_base_path)
+    path.should == original_base_path
+
+    path.using_base_path temporary_base do
+      path.should == temporary_base
+    end
+    path.should == original_base_path
+  end
+
+  it "creating the AHN_ROOT will set defaults" do
+    stub_behavior_for_initializer_with_no_path_changing_behavior do
+      flexstub(Adhearsion::Initializer).new_instances.should_receive(:load).and_return
+      ahn = Adhearsion::Initializer.start path
+      full_path = File.expand_path(path)
+      AHN_ROOT.to_s.should == full_path
+      AHN_ROOT.component_path.should == File.join(full_path, "components")
+      AHN_ROOT.log_path.should == File.join(full_path, "logs")
+      AHN_ROOT.dialplan_path.should == full_path
+    end
+  end
+  private
+    def path
+      '/any/ole/path'
+    end
+end