dramatis 0.0.1

data/spec/dramatis/actor/become_spec.rb

@@ -0,0 +1,17 @@
+describe "become" do
+
+  after do
+    begin
+      Dramatis::Runtime.current.quiesce
+      Dramatis::Runtime.current.exceptions.length.should equal( 0 )
+      Thread.list.length.should equal( 1 )
+    ensure
+      Dramatis::Runtime.reset
+    end
+  end
+
+  it "should forward messages on become"
+
+  it "should do something with the patterns on become"
+
+end

data/spec/dramatis/actor/future_spec.rb

@@ -0,0 +1,189 @@
+require File.join( File.dirname(__FILE__), "..", "..", '/spec_helper.rb' )
+
+require 'dramatis/actor'
+require 'dramatis/future'
+
+# NB: don't use the module name here: rspec wants to include described
+# modules ... and making the result into an actor, well, needless to say,
+# it's not a good idea
+
+describe "Dramatis::Actor" do
+
+  include Dramatis
+
+  include DramatisSpecHelper
+
+  after(:each) { runtime_check }
+
+  it "should allow future names to be created" do
+
+    object = Object.new
+    actor = Dramatis::Actor.new object
+
+    future_name = future( actor )
+
+  end
+
+  it "should return a future when used" do
+
+    object = mock Object.new
+    object.should_receive(:foo).with(:bar).and_return(:foobar)
+    actor = Dramatis::Actor.new object
+
+    future_name = future( actor )
+
+    x = future_name.foo :bar
+
+    x.should be_kind_of( Dramatis::Future )
+
+  end
+
+  it "should evalute to the right value when used" do
+
+    object = mock Object.new
+    object.should_receive(:foo).with(:bar).and_return(:foobar)
+    actor = Dramatis::Actor.new object
+
+    future_name = future( actor )
+
+    x = future_name.foo :bar
+
+    x.should be_kind_of( Dramatis::Future )
+    x.to_sym.should equal( :foobar )
+
+  end
+
+  it "should raise as appropriate" do
+
+    object = Object.new
+    actor = Dramatis::Actor.new object
+
+    future_name = future( actor )
+
+    x = future_name.bar :bar
+
+    x.should be_kind_of( Dramatis::Future )
+
+    lambda { x.to_sym }.should raise_error( NoMethodError )
+
+  end
+
+  it "should act like an object ... to the extent possible" do
+
+    object = mock Object.new
+    object.should_receive(:foo).with(:bar).and_return(12345)
+    actor = Dramatis::Actor.new object
+
+    future_name = future( actor )
+
+    x = future_name.foo :bar
+    
+    x.should be_kind_of( Dramatis::Future )
+    ( x + 0 ).should == 12345
+    ( 0 + x ).should == 12345
+
+  end
+
+  it "should have a value interface" do
+    object = mock Object.new
+    object.should_receive(:foo).with(:bar).and_return(12345)
+    actor = Dramatis::Actor.new object
+
+    future_name = future( actor )
+
+    x = future_name.foo :bar
+    
+    x.should be_kind_of( Dramatis::Future )
+
+    x = interface( x ).value
+
+    x.should be_kind_of( Fixnum )
+
+    x.should == 12345
+
+  end
+
+  it "should have a ready? interface" do
+    aClass = Class.new do
+      include Dramatis::Actor
+      def initialize
+        actor.always :ready?, true
+        @state = nil
+        @future = nil
+      end
+      def caller callee
+        @future = future( callee ).callee
+      end
+      def ready?
+        interface( @future ).ready?
+      end
+      def value
+        interface( @future ).value
+      end
+    end
+
+    bClass = Class.new do
+      include Dramatis::Actor
+      attr_reader :state
+      def initialize
+        actor.refuse :callee
+      end
+      def allow
+        actor.default :callee
+      end
+      def callee
+        :foobar
+      end
+    end
+
+    a = aClass.new
+    b = bClass.new
+
+    a.caller b
+
+    a.ready?.should be_false
+    
+    b.allow
+
+    Dramatis::Runtime.current.quiesce
+    
+    a.ready?.should be_true
+
+    a.value.should equal( :foobar )
+
+  end
+
+  it "should evalute to the right value when used with a delay" do
+
+    aClass = Class.new do
+      include Dramatis::Actor
+      def inititialize
+        actor.always :state
+        @state = nil
+        @future = nil
+      end
+      def caller callee
+        @future = future( callee ).callee
+      end
+    end
+
+    bClass = Class.new do
+      include Dramatis::Actor
+      attr_reader :state
+      def initialize
+        actor.refuse :callee
+      end
+      def allow
+        actor.default :callee
+      end
+      def callee
+        :foobar
+      end
+    end
+
+    a = aClass.new
+    b = bClass.new
+
+  end
+
+end

data/spec/dramatis/actor/name_spec.rb

@@ -0,0 +1,141 @@
+require File.join( File.dirname(__FILE__), "..", "..", '/spec_helper.rb' )
+
+require 'dramatis/runtime'
+require 'dramatis'
+require 'dramatis/actor/name'
+
+describe Dramatis do
+
+  include Dramatis
+
+  include DramatisSpecHelper
+
+  after(:each) { runtime_check }
+
+  it "should return NoMethodError as appropriate" do
+    actor = Dramatis::Actor.new Object.new
+    lambda { actor.foo }.should raise_error( NoMethodError )
+  end
+
+  it "should recreate errors rather just forward them(?)"
+
+  it "should block other methods during a continuation"
+
+  it "should be creatable unbound" do
+    Dramatis::Actor.new
+  end
+
+  it "should allow messages to unbound" do
+    lambda { Dramatis::Actor.new.foo }.
+      should raise_error( Dramatis::Deadlock )
+  end
+
+  it "should be creatable bound" do
+    name = Dramatis::Actor.new Object.new
+    name.should be_kind_of( Dramatis::Actor::Name )
+  end
+
+  it "should allow and execute messages to bound names" do
+    object = mock Object.new
+    object.should_receive(:foo).with(:bar).and_return(:foobar)
+    name = Dramatis::Actor.new object
+    result = name.foo :bar
+    result.should equal( :foobar )
+  end
+
+  it "should deliver messages with nil continuations" do
+    object = mock(Object.new)
+    object.should_receive(:foo).with(:bar)
+    name = Dramatis::Actor.new object
+    interface( name ).continue(nil).foo( :bar )
+  end
+
+  it "should have a nice short method for casts" do
+    object = mock(Object.new)
+    object.should_receive(:foo).with(:bar)
+    name = Dramatis::Actor.new object
+    release( name ).foo( :bar )
+  end
+
+  it "should suport cast from the object interface"
+
+  it "shouldn't be possible to bind twice" do
+    name = Dramatis::Actor.new
+    interface( name ).bind Object.new
+    lambda { interface( name ).bind Object.new }.should raise_error( Dramatis::Error::Bind )
+  end
+
+  it "should allow and execute block continuations" do
+
+    actor = Object.new
+    name = Dramatis::Actor.new actor
+    actor.should_receive(:foo).with(:bar).and_return(:foobar)
+
+    result = nil
+    retval = ( interface( name ).continue { |value| result = value } ).foo :bar
+    retval.should be_nil
+    result.should be_nil
+    result.should be_nil # to perhaps highlight a threading problem
+
+    Dramatis::Runtime.current.quiesce
+    
+    result.should equal( :foobar )
+
+  end
+
+  it "should execute messages to unbound names once bound" do
+
+    name = Dramatis::Actor.new
+
+    object = mock(Object.new)
+    object.should_receive(:foo).with(:bar).and_return(:foobar)
+
+    result = nil
+
+    retval = ( interface( name ).continue { |value| result = value } ).foo :bar
+
+    retval.should be_nil
+    result.should be_nil
+
+    Dramatis::Runtime.current.quiesce
+
+    result.should be_nil
+
+    interface( name ).bind object
+
+    Dramatis::Runtime.current.quiesce
+
+    result.should equal( :foobar )
+
+  end
+
+  it "rpc binds should return an actor name" do
+    name = Dramatis::Actor.new
+    retval = Dramatis.interface( name ).bind Hash.new
+    retval.should be_kind_of( Dramatis::Actor::Name )
+  end
+
+  it "should be possible to bind with a non-rpc continuation" do
+    name = Dramatis::Actor.new
+    result = nil
+    name = interface( name ).continue { |v| result = v }
+    retval = interface( name ).bind Object.new
+    retval.should equal( nil )
+    result.should equal( nil )
+    Dramatis::Runtime.current.quiesce
+    result.should_not be_nil
+  end
+
+  it "should provide a url, if asked" do
+    actor = Dramatis::Actor.new Object.new
+    url = interface( actor ).url
+    url.should match( %r[http://] )
+  end
+
+  it "unbound names should queue messages and deliver them in order"
+
+  it "messages should be delivered out of order sometimes"
+
+  it "flushing should guarantee message order"
+
+end

data/spec/dramatis/actor/task_spec.rb

@@ -0,0 +1,75 @@
+require File.join( File.dirname(__FILE__), "..", "..", '/spec_helper.rb' )
+
+require 'dramatis/runtime/task'
+require 'dramatis/actor'
+
+describe Dramatis::Runtime::Task do
+
+  include Dramatis
+
+  include DramatisSpecHelper
+
+  after(:each) { runtime_check }
+
+  it "should return errors to calling actor even when non-rpc (non-main)" do
+    callerClass = Class.new do
+      include Dramatis::Actor
+      def initalize
+        @exception = nil
+      end
+      def caller callee
+        release( callee ).callee
+      end
+      def dramatis_exception e
+        @exception = e
+      end
+      def exception
+        raise @exception if @exception
+      end
+    end
+
+    caller = callerClass.new
+    callee = Dramatis::Actor.new Object.new
+
+    caller.caller callee
+
+    Dramatis::Runtime.current.quiesce
+
+    lambda { caller.exception }.should raise_error( NoMethodError )
+  end
+
+  it "should do something reasonable when the caller is main" do
+    callee = Dramatis::Actor.new Object.new
+    lambda { callee.callee }.should raise_error( NoMethodError )
+    release( callee ).callee
+    Dramatis::Runtime.current.warnings = false
+    lambda { Dramatis::Runtime.current.quiesce }.should raise_error( Dramatis::Error::Uncaught )
+    Dramatis::Runtime.current.warnings = true
+    Dramatis::Runtime.current.exceptions.length.should equal( 1 )
+    Dramatis::Runtime.current.clear_exceptions
+  end
+
+  it "should default to global when no dramatis_exception defined" do
+    callerClass = Class.new do
+      include Dramatis::Actor
+      def caller callee
+        release( callee ).callee
+      end
+    end
+
+    caller = callerClass.new
+    callee = Dramatis::Actor.new Object.new
+
+    Dramatis::Runtime.current.warnings = false
+    caller.caller callee
+    lambda { Dramatis::Runtime.current.quiesce }.should raise_error( Dramatis::Error::Uncaught )
+    Dramatis::Runtime.current.warnings = true
+
+    lambda { raise Dramatis::Runtime.current.exceptions[0] }.should raise_error( NoMethodError )
+    Dramatis::Runtime.current.clear_exceptions
+      
+  end
+
+  it "should call dramatis_exception on main if that works(?)"
+
+end