adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/theatre/namespace_spec.rb

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

data/spec/theatre/spec_helper_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe "Example" do
-
-  it "should properly load the YAML in a file" do
-    example_name = :kewlz0rz
-    data_structure = {:foo => :bar, :qaz => [1,2,3,4,5]}
-    yaml = data_structure.to_yaml
-    file_contents = <<-FILE
-# Some comment here
-=begin YAML
-#{yaml}
-=end
-events.blah.each { |event| }
-events.blah2.each { |event| }
-
-# More comments
-=begin
-another block
-=end
-    FILE
-
-    flexmock(File).should_receive(:read).once.with(/kewlz0rz\.rb$/).and_return file_contents
-    example = Example.new(example_name)
-    example.metadata.should == data_structure
-  end
-
-end

data/spec/theatre/theatre_class_spec.rb

@@ -1,148 +0,0 @@
-require 'spec_helper'
-
-describe "Theatre::Theatre" do
-
-  it "should start the quantity of threads given to its constructor" do
-    number_of_threads = 13
-    theatre = Theatre::Theatre.new(number_of_threads)
-
-    flexmock(Thread).should_receive(:new).times(number_of_threads).and_return
-    flexstub(theatre.send(:instance_variable_get, :@thread_group)).should_receive(:add).and_return
-
-    theatre.start!
-  end
-
-  it "should not spawn new threads when calling start twice" do
-    number_of_threads = 5
-
-    theatre = Theatre::Theatre.new(number_of_threads)
-
-    threads = Array.new(number_of_threads) { Thread.new(&theatre.method(:thread_loop)) }
-    flexmock(Thread).should_receive(:new).times(number_of_threads).and_return *threads
-
-    theatre.start!
-    theatre.start!
-    theatre.start!
-    theatre.start!
-    theatre.graceful_stop!
-  end
-
-  describe '#trigger' do
-
-    it "should properly execute the block given" do
-
-      has_ran = false
-
-      theatre = Theatre::Theatre.new
-      theatre.register_namespace_name "cheezburger"
-      theatre.register_callback_at_namespace "cheezburger", lambda { |payload| has_ran = payload }
-
-      theatre.start!
-
-      theatre.trigger "cheezburger", :yes
-      theatre.graceful_stop!
-      theatre.join
-
-      has_ran.should equal(:yes)
-    end
-
-    it "should return an Array of Invocation objects" do
-      theatre = Theatre::Theatre.new
-      theatre.register_namespace_name "qaz"
-      theatre.register_callback_at_namespace "qaz", lambda {}
-      return_value = theatre.trigger("qaz")
-      return_value.should be_instance_of(Array)
-      return_value.should have(1).item
-      return_value.first.should be_instance_of(Theatre::Invocation)
-    end
-
-  end
-
-  describe '#trigger_immediately' do
-    it "should continue executing callbacks when a link in the chain raises an Exception" do
-      callbacks = [lambda { 1 }, lambda { raise LocalJumpError }, lambda { 3 }]
-
-      theatre = Theatre::Theatre.new
-      theatre.register_namespace_name "breakage"
-
-      callbacks.each do |callback|
-        theatre.register_callback_at_namespace "breakage", callback
-      end
-
-      flexmock(Adhearsion::Events).should_receive(:trigger).once.with('/exception', FlexMock.on {|e| e.is_a?(StandardError)})
-      return_value = theatre.trigger_immediately("breakage")
-      return_value.first.should equal(1)
-      return_value[1].should be_instance_of(LocalJumpError)
-      return_value.last.should equal(3)
-    end
-  end
-
-  describe '#callbacks_for_namespaces' do
-    it "should properly return Procs which have been registered against a namespace" do
-      callback = lambda { :callback }
-      theatre = Theatre::Theatre.new
-      theatre.register_namespace_name "pumpkin"
-      theatre.register_callback_at_namespace "pumpkin", callback
-      theatre.namespace_manager.callbacks_for_namespaces("pumpkin").should eql([callback])
-    end
-  end
-
-  describe '#join' do
-    it "should execute join() on every ThreadGroup thread" do
-      thread_mocks = Array(3) do
-        bogus_thread = flexmock "bogus thread"
-        bogus_thread.should_receive(:join).once.and_return
-        bogus_thread
-      end
-      bogus_thread_group = flexmock "A ThreadGroup which returns an Array of mock Threads", :list => thread_mocks
-      theatre = Theatre::Theatre.new
-      theatre.send(:instance_variable_set, :@thread_group, bogus_thread_group)
-      theatre.join
-    end
-  end
-
-  describe '#thread_loop' do
-
-    it "should continue looping even after an exception been raised" do
-      mock_invocation = flexmock "mock Invocation which raises when started"
-      mock_invocation.should_receive(:start).once.and_raise ArgumentError # Simulate logic error
-
-      theatre = Theatre::Theatre.new
-      master_queue = theatre.send(:instance_variable_get, :@master_queue)
-      flexmock(theatre).should_receive(:loop).once.and_yield
-      flexmock(master_queue).should_receive(:pop).once.and_return mock_invocation
-
-      lambda do
-        theatre.send(:thread_loop).should equal(:stopped)
-      end.should_not raise_error(ArgumentError)
-    end
-
-    it "should run the callback of the Invocation it receives from the master_queue" do
-      has_executed = false
-
-      invocation = Theatre::Invocation.new("/foo/bar", lambda { has_executed = true })
-      invocation.queued
-
-      theatre = Theatre::Theatre.new
-
-      master_queue = theatre.send(:instance_variable_get, :@master_queue)
-
-      flexmock(theatre).should_receive(:loop).and_yield
-      flexmock(master_queue).should_receive(:pop).once.and_return invocation
-
-      theatre.send :thread_loop
-
-      has_executed.should be_true
-    end
-
-    it "should stop when receiving the shutdown command and return :stopped" do
-      theatre = Theatre::Theatre.new
-      master_queue = theatre.send(:instance_variable_get, :@master_queue)
-      flexmock(theatre).should_receive(:loop).once.and_yield
-      flexmock(master_queue).should_receive(:pop).once.and_return :THEATRE_SHUTDOWN!
-      theatre.send(:thread_loop).should equal(:stopped)
-    end
-
-  end
-
-end