adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/component_manager_spec.rb

@@ -1,292 +0,0 @@
-require 'spec_helper'
-require 'adhearsion/component_manager/component_tester'
-
-module ComponentManagerTestHelper
-
-  def mock_component_config(component_name, yaml)
-    yaml = YAML.load(yaml) if yaml.kind_of?(String)
-    flexmock(@component_manager.lazy_config_loader).should_receive(component_name).and_return yaml
-  end
-
-  def run_component_code(code)
-    @component_manager.load_code(code)
-  end
-
-  def new_object_with_scope(scope)
-    @component_manager.extend_object_with(Object.new, scope)
-  end
-end
-
-describe "Adhearsion's component system" do
-
-  include ComponentManagerTestHelper
-
-  before :each do
-    @component_manager = Adhearsion::Components::ComponentManager.new "/filesystem/access/should/be/mocked/out"
-    Object.send :remove_const, :COMPONENTS if Object.const_defined?(:COMPONENTS)
-    Object.send :const_set, :COMPONENTS, @component_manager.lazy_config_loader
-  end
-
-  it "constants should be available in the main namespace" do
-    constant_name = "FOO_#{rand(10000000000)}"
-    begin
-      run_component_code <<-RUBY
-        #{constant_name} = 123
-      RUBY
-      Module.const_get(constant_name).should be 123
-    ensure
-      Object.send(:remove_const, constant_name) rescue nil
-    end
-  end
-
-  it "defined constants should be available within the methods_for block" do
-    constant_name = "I_HAVE_#{rand(100000000000000)}_GUMMY_BEARS"
-    code = <<-RUBY
-      #{constant_name} = :its_true!
-      methods_for :dialplan do
-        throw #{constant_name}
-      end
-    RUBY
-    the_following_code {
-      run_component_code code
-    }.should throw_symbol :its_true!
-  end
-
-  it "initialization block should be called after the methods_for() blocks"
-
-  it "defined methods should be recognized once defined" do
-    run_component_code <<-RUBY
-      methods_for :events do
-        def foo
-          :inside_foo!
-        end
-      end
-    RUBY
-    container_object = new_object_with_scope :events
-    container_object.foo.should be :inside_foo!
-  end
-
-  it "a method defined in one scope should not be available in another" do
-    code = <<-RUBY
-      methods_for :events do
-        def in_events
-          in_dialplan
-        end
-      end
-      methods_for :dialplan do
-        def in_dialplan
-          in_events
-        end
-      end
-    RUBY
-
-  end
-
-  it "methods defined in separate blocks should be available if they share a scope" do
-    run_component_code <<-RUBY
-      methods_for :dialplan do
-        def get_symbol
-          :i_am_the_best_symbol_in_the_world
-        end
-      end
-      methods_for :dialplan do
-        def throw_best_symbol_in_the_world
-          throw get_symbol
-        end
-      end
-    RUBY
-    obj = new_object_with_scope :dialplan
-    the_following_code {
-      obj.throw_best_symbol_in_the_world
-    }.should throw_symbol :i_am_the_best_symbol_in_the_world
-  end
-
-  it "privately defined methods should remain private" do
-    return_value = "hear! hear! i'm private, indeed!"
-    run_component_code <<-RUBY
-      methods_for :generators do
-        def i_am_public
-          i_am_private.reverse
-        end
-
-        private
-
-        def i_am_private
-          "#{return_value}"
-        end
-      end
-    RUBY
-    object = new_object_with_scope(:generators)
-    object.i_am_public.should == return_value.reverse
-    the_following_code {
-      object.i_am_private
-    }.should raise_error NoMethodError
-  end
-
-  it "load_components should load code with the proper filenames" do
-    components_dir_path = "/path/to/somewhere/components"
-    component_names = %w[fooo barr qazz]
-    component_paths = component_names.map { |name| "#{components_dir_path}/#{name}" }
-
-    flexmock(Dir).should_receive(:glob).once.with(components_dir_path + "/*").
-        and_return(component_paths + ["disabled"])
-    flexstub(File).should_receive(:exists?).and_return true
-    flexstub(File).should_receive(:directory?).and_return true
-
-    manager = Adhearsion::Components::ComponentManager.new(components_dir_path)
-    component_paths.each do |path|
-      flexmock(manager).should_receive(:load_file).once.with "#{path}/lib/#{File.basename(path)}.rb"
-    end
-
-    manager.load_components
-  end
-
-  it "the :global scope" do
-    run_component_code <<-RUBY
-      methods_for :global do
-        def i_should_be_globally_available
-          :found!
-        end
-      end
-    RUBY
-    @component_manager.globalize_global_scope!
-    i_should_be_globally_available.should be :found!
-  end
-
-  it "methods defined in outside of any scope should not be globally available" do
-    run_component_code <<-RUBY
-      def i_should_not_be_globally_available
-        :found!
-      end
-    RUBY
-    the_following_code {
-      i_should_not_be_globally_available
-    }.should raise_error NameError
-  end
-
-  it "should have access to the COMPONENTS constant" do
-    component_name = "am_not_for_kokoa"
-    mock_component_config(component_name, <<-YAML)
-host: localhost
-port: 7007
-array:
-  - 1
-  - 2
-  - 3
-    YAML
-    run_component_code <<-RUBY
-    methods_for(:dialplan) do
-      def host
-        COMPONENTS.#{component_name}["host"]
-      end
-      def port
-        COMPONENTS.#{component_name}["port"]
-      end
-      def array
-        COMPONENTS.#{component_name}["array"]
-      end
-    end
-    RUBY
-    obj = new_object_with_scope :dialplan
-    obj.host.should =="localhost"
-    obj.port.should ==7007
-    obj.array.should ==[1,2,3]
-  end
-
-  it "the delegate method should properly delegate arguments and a block to a specified object" do
-    component_name = "writing_this_at_peets_coffee"
-    mock_component_config(component_name, "{jay: phillips}")
-    run_component_code <<-RUBY
-
-    initialization do
-      obj = Object.new
-      def obj.foo
-        :foo
-      end
-      def obj.bar
-        :bar
-      end
-      COMPONENTS.#{component_name}[:foobar] = obj
-    end
-
-    methods_for :dialplan do
-      delegate :#{component_name}, :to => :COMPONENTS
-    end
-    RUBY
-    obj = new_object_with_scope :dialplan
-    obj.send(component_name)[:foobar].foo.should be :foo
-  end
-
-  it "an initialized component should not have an 'initialize' private method since it's confusing"
-
-  it "should find components in a project properly"
-  it "should run the initialization block" do
-    code = <<-RUBY
-      initialization do
-        throw :got_here!
-      end
-    RUBY
-    the_following_code {
-      run_component_code code
-    }.should throw_symbol :got_here!
-
-  end
-
-  it "should alias the initialization method to initialisation" do
-    code = <<-RUBY
-      initialisation do
-        throw :BRITISH!
-      end
-    RUBY
-    the_following_code {
-      run_component_code code
-    }.should throw_symbol :BRITISH!
-  end
-
-  it "should properly expose any defined constants" do
-    container = run_component_code <<-RUBY
-      TEST_ONE   = 1
-      TEST_TWO   = 2
-      TEST_THREE = 3
-    RUBY
-    container.constants.sort.map{|s| s.to_sym}.should == [:TEST_ONE, :TEST_THREE, :TEST_TWO]
-    container.constants.map do |constant|
-      container.const_get(constant)
-    end.sort.should ==[1,2,3]
-  end
-
-end
-
-describe "ComponentTester" do
-  it "should allow the scope-resolution operator to access a component's constants" do
-    component_name = "my_awesomeness"
-    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return "AWESOME = :YES!"
-    tester = ComponentTester.new(component_name, "/path/shouldnt/matter")
-    tester::AWESOME.should be :YES!
-  end
-
-  it "should return an executable helper method properly" do
-    component_name = "one_two_three"
-    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return "def hair() :long end"
-    tester = ComponentTester.new(component_name, "/path/shouldnt/matter")
-    tester.helper_method(:hair).call.should be :long
-  end
-
-  it "should load the configuration for the given helper properly" do
-    component_name = "i_like_configurations"
-    config = {:german => {1 => :eins, 2 => :zwei, 3 => :drei}}
-    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return ""
-    component_manager = flexmock "ComponentManager"
-    component_manager.should_receive(:configuration_for_component_named).once.with(component_name).and_return config
-    flexmock(Adhearsion::Components::ComponentManager).should_receive(:new).once.and_return component_manager
-    ComponentTester.new(component_name, "/path/shouldnt/matter").config[:german][1].should be :eins
-  end
-
-  it "should execute the initialize block when calling ComponentTester#initialize!()" do
-    component_name = "morrissey"
-    flexmock(File).should_receive(:read).once.with(/#{component_name}\.rb$/).and_return "initialization { $YES_I_WAS_CALLED = TRUE }"
-    ComponentTester.new(component_name, "/path/shouldnt/matter").initialize!
-    $YES_I_WAS_CALLED.should == true
-  end
-
-end

data/spec/adhearsion/constants_spec.rb

@@ -1,8 +0,0 @@
-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/adhearsion/drb_spec.rb

@@ -1,65 +0,0 @@
-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/adhearsion/fixtures/dialplan.rb

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

data/spec/adhearsion/foundation/event_socket_spec.rb

@@ -1,168 +0,0 @@
-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