oleganza-emrpc 0.3

data/spec/evented_api/remote_pid_spec.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RemotePid do
+  
+  before(:each) do
+    @uuid = "my-uuid"
+    @local_pid = mock('pid', :uuid => "local-uuid", :_uid => "short")
+    @connection = mock('Protocol', :send_raw_message => nil, 
+                                   :address => ::URI.parse(em_addr),
+                                   :local_pid => @local_pid)
+                
+    @options = {:uuid => @uuid}
+    @cls = RemotePid
+    @rpid = @cls.new(@connection, @options)
+  end
+
+  describe "inspectable", :shared => true do
+    it "should be inspectable" do
+      lambda{ @rpid.inspect }.should_not raise_error
+    end
+  end
+  
+  describe "#initialize" do
+    it "should set connection" do
+      @rpid._connection.should == @connection
+    end
+
+    it "should set uuid" do
+      @rpid.uuid.should == @uuid
+    end
+        
+    it "should not be killed" do
+      @rpid.should_not be_killed
+    end
+    
+    it_should_behave_like "inspectable"
+    
+    it "should have connection description in inspect" do
+      @rpid.inspect.should =~ /on \S+ connected with local pid \S+/
+    end
+    
+  end
+    
+  
+  describe "#kill" do
+    before(:each) do
+      @connection.should_receive(:send_raw_message).once.with([:kill])
+      @connection.should_receive(:close_connection_after_writing).once
+      @rpid.kill
+    end
+    
+    it "should be killed" do
+      @rpid.should be_killed
+    end
+    
+    it "should ignore more kill calls" do
+      @rpid.kill
+      @rpid.kill
+    end
+    
+    it_should_behave_like "inspectable"
+    
+    it "should have 'KILLED' in inspect" do
+      @rpid.inspect.should =~ /KILLED/
+    end
+    
+  end
+  
+  
+  describe "method call proxying" do
+    before(:each) do
+      @connection.should_receive(:send_raw_message).once.with([:meth, :arg1, :arg2])
+    end
+    
+    it "should allow direct call" do
+      @rpid.meth(:arg1, :arg2)
+    end
+    
+    it "should allow indirect call with send()" do
+      @rpid.send(:meth, :arg1, :arg2)
+    end
+  end
+    
+end

data/spec/evented_api/scenario_spec.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Chat" do
+  
+  before(:all) do
+    
+    class Chatterer < Fixtures::Person
+      include Pid
+      attr_accessor :chat, :notices, :log
+      def initialize(*args)
+        super(*args)
+        @notices = []
+        @log = []
+      end
+      def connected(pid)
+        @chat = pid
+      end
+      def notice(msg)
+        @notices << msg
+      end
+      def receive(from, msg)
+        @log << [from, msg]
+      end
+      def write(msg)
+        @log << [@name, msg]
+        @chat.write(self, @name, msg)
+      end
+      def pid_class_name
+        self.class.name
+      end
+    end
+        
+    class Chat
+      include Pid
+      def initialize
+        super
+        @chatterers = []
+      end
+      def connected(pid)
+        @chatterers << pid
+      end
+      def disconnected(pid)
+        @chatterers.delete(pid)
+        broadcast(:notice, self, "Chatterer #{pid.uuid} disconnected!")
+      end
+      def write(from, name, text)
+        broadcast(:receive, name, text) {|c| c != from }
+      end
+      def broadcast(msg, *args, &blk)
+        cs = @chatterers
+        cs = cs.select(&blk) if blk
+        cs.each do |c|
+          c.send(msg, *args)
+        end
+      end
+      def pid_class_name
+        self.class.name
+      end
+    end
+    
+    class Oleg < Chatterer
+      def initialize
+        super(:name => "oleg")
+      end
+      def receive(from, text)
+        super
+        case text
+        when /hello!/i
+          write "How are you?"
+        when /fine/i
+          write "Ok then! Cya!"
+        when /ciao/i
+        else 
+          raise "I don't understand you"
+        end
+      end
+      def connected(pid)
+        super
+        write("Hi!")
+      end
+    end
+    
+    class Olga < Chatterer
+      def initialize
+        super(:name => "olga")
+      end
+      def receive(from, text)
+        super
+        case text
+        when /hi!/i
+          write "Hello!"
+        when /how are you/i
+          write "Fine, thanks!"
+        when /cya!/i
+          write "Ciao!"
+        else 
+          raise "I don't understand you"
+        end
+      end
+    end
+    
+    @oleg  = Oleg.new
+    @olga  = Olga.new
+    
+    @oleg.method(:marshal_dump)
+    
+    @chat_addr = em_addr
+    @chat = Chat.new
+
+    @chat.bind(@chat_addr)
+        
+    lambda { Marshal.dump(@oleg) }.should_not raise_error
+    lambda { Marshal.dump(@olga) }.should_not raise_error
+    
+    Thread.new do
+      @oleg.connect(@chat_addr)
+      @olga.connect(@chat_addr)
+    end
+  end
+  
+  it "should produce a conversation" do
+    sleep 0.5
+    
+    @oleg.log.should == [
+      ["oleg", "Hi!"],
+      ["olga", "Hello!"],
+      ["oleg", "How are you?"],
+      ["olga", "Fine, thanks!"],
+      ["oleg", "Ok then! Cya!"],
+      ["olga", "Ciao!"]
+    ]
+    
+    @oleg.log.should == @olga.log
+  end
+  
+  
+    
+end

data/spec/evented_api/spec_helper.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module MockDescribe
+  def mock_describe(title, scope = :each, &blk)
+    describe(title) do
+      before(scope, &blk)
+      it("should verify mocks expectations") { }
+    end
+  end
+end

data/spec/evented_api/subscribable_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Subscribable do
+  extend MockDescribe
+  
+  before(:all) do
+    @cls = Class.new { include Subscribable }
+    @cafe = @cls.new
+  end
+
+  def client_mock(name)
+    m = mock(name)
+    m.stub!(:send)
+    m
+  end
+  
+  mock_describe "subscribed client" do
+    oleg = client_mock("Oleg in cafe")
+    oleg.should_receive(:send).once.with(:on_open, :arg).ordered
+    oleg.should_receive(:send).once.with(:on_close).ordered
+    andrey = client_mock("Andrey in cafe")
+    andrey.should_receive(:send).once.with(:on_close).ordered
+    
+    @cafe.subscribe(:open,  oleg, :on_open)
+    @cafe.subscribe(:close, oleg, :on_close)
+    @cafe.subscribe(:close, andrey, :on_close)
+    
+    @cafe.notify_subscribers(:open, :arg)
+    @cafe.notify_subscribers(:close)
+  end
+
+  mock_describe "unsubscribed client from event" do
+    oleg = client_mock("Oleg in cafe")
+    oleg.should_not_receive(:send).with(:on_open, :arg)
+    oleg.should_receive(:send).with(:on_close).ordered
+    andrey = client_mock("Andrey in cafe")
+    andrey.should_receive(:send).with(:on_close).ordered
+    
+    @cafe.subscribe(:open,  oleg, :on_open)
+    @cafe.subscribe(:close, oleg, :on_close)
+    @cafe.subscribe(:close, andrey, :on_close)
+    
+    @cafe.unsubscribe(:open, oleg)
+    
+    @cafe.notify_subscribers(:open, :arg)
+    @cafe.notify_subscribers(:close)
+  end
+  
+  
+  %{
+    TODO: more scenarios with special DSL
+  }
+end

data/spec/server_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Server do
+  it "should be covered with some scenario-like specs" do
+    pending
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+$LOAD_PATH.unshift( File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')) )
+
+require 'emrpc'
+include EMRPC
+
+require 'socket'
+
+module AddressHelpers
+  def em_host(host = ENV['EM_HOST'])
+    host || '127.0.0.1'
+  end
+
+  def em_port(port = ENV['EM_PORT'])
+    (port || 45_678).to_i
+  end
+  
+  def em_random_port
+    rand(10_000) + 40_000
+  end
+
+  def em_proto(proto = ENV['EM_PROTO'])
+    proto || 'emrpc'
+  end
+
+  def em_addr(proto = em_proto, host = em_host, port = em_port)
+    "#{proto}://#{host}:#{port}"
+  end
+end
+
+class Object
+  include AddressHelpers
+end
+
+module Fixtures
+  class Person
+    attr_accessor :name
+    def initialize(options = {})
+      @name = options[:name]
+    end
+  end
+
+  class Paris
+    attr_accessor :people, :options
+  
+    def initialize(ppl = 2, options = {})
+      @options = options
+      @people = Array.new(ppl){ Person.new }
+      @name = "Paris"
+    end
+  
+    def translate(english_word)
+      "le #{english_word}" # :-)
+    end
+  
+    def visit(person)
+      people << person
+      people.size
+    end
+    
+    def run_slow(time = 2)
+      sleep(time)
+    end
+    
+    def run_exception
+      raise SomeException, "paris message"
+    end
+    class SomeException < Exception; end
+  end
+end
+
+module ThreadHelpers
+  def create_threads(n, abort_on_exception = false, &blk)
+    Array.new(n) do 
+      t = Thread.new(&blk)
+      t.abort_on_exception = abort_on_exception
+      t
+    end
+  end
+end
+
+# Runs eventmachine reactor in a child thread,
+# waits 0.5 sec. in a current thread.
+# Returns child thread.
+#
+module EventMachine
+  def self.run_in_thread(delay = 0.5, &blk)
+    blk = proc{} unless blk
+    t = Thread.new do
+      EventMachine.run(&blk)
+    end
+    sleep delay
+    t
+  end
+end
+
+$em_thread ||= EventMachine.run_in_thread

data/spec/util/blank_slate_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe EMRPC::BlankSlate do  
+  it "should have only __id__ and __send__ instance methods" do
+    EMRPC::BlankSlate.instance_methods.sort.should == %w[__id__ __send__]
+  end
+end

data/spec/util/codec_spec.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Codec with" do
+  
+  before(:each) do
+    @encode_method = :encode_b381b571_1ab2_5889_8221_855dbbc76242
+    @decode_method = :decode_b381b571_1ab2_5889_8221_855dbbc76242
+    @dummy_pid = mock("dummy pid", :uuid => "dummy-uuid")
+    @host_pid = mock("host pid", :find_pid => @dummy_pid)
+  end
+  
+  describe Object do
+    before(:each) do
+      @obj = Object.new
+    end
+    
+    it "should return self" do
+      @obj.encode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid).should eql(@obj)
+      @obj.decode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid).should eql(@obj)
+    end
+  end
+  
+  describe PidVariables do
+    before(:each) do
+      ::MyClass = Class.new do 
+        include PidVariables
+        attr_accessor :name, :pid
+      end
+      @pid = Pid.new
+      @obj = ::MyClass.new
+      @obj.name = "Oleg"
+      @obj.pid = @pid
+      @encoded = @obj.encode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid)
+    end
+    
+    after(:each) do
+      Object.send(:remove_const, :MyClass) if defined?(::MyClass)
+    end
+    
+    it "should encode ivars" do
+      encoded = @encoded
+      encoded.should be_kind_of(PidVariables::Container)
+      encoded.cls.should == @obj.class
+      name_pair, pid_pair = encoded.ivars.sort_by{|a|a[0]}
+      name_pair.should == ["@name", "Oleg"]
+      pid_pair[0].should == "@pid"
+      pid_pair[1].should be_kind_of(Pid::Marshallable)
+      pid_pair[1].uuid.should == @obj.pid.uuid
+    end
+
+    describe PidVariables::Container do
+      before(:each) do
+        @host_pid.should_receive(:find_pid).once.with(@pid.uuid).and_return do |uuid|
+          @pid
+        end
+        @decoded = @encoded.decode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid)
+      end
+      
+      it "should decode ivars" do
+        @decoded.class.should == @obj.class
+        @decoded.name.should == @obj.name
+        @decoded.pid.should == @obj.pid
+      end
+    end
+  end
+  
+  describe "primitive", :shared => true do
+    it "should return itself" do
+      @obj.encode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid).should eql(@obj)
+    end
+    it "should return itself" do
+      @obj.decode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid).should eql(@obj)
+    end
+  end
+
+  [nil, true, false, "string", 123, 3.725, :symbol].each do |obj|
+    describe obj.inspect do
+      before(:each) do
+        @obj = obj
+      end
+      it_should_behave_like "primitive"
+    end
+  end
+
+  def codec_mock(method, name, n)
+    enc = name.upcase.to_sym
+    item = mock(name)
+    item.stub!(method).and_return(enc)
+    item.should_receive(method).exactly(n).times.with(@host_pid).and_return do |hpid|
+      hpid.should == @host_pid
+      enc
+    end
+    item
+  end
+  
+  describe Array do
+    describe "array codec", :shared => true do
+      it "should encode/decode each item recusively" do
+        item = codec_mock(@method, "item", 6)
+        @arr = [item, item, [item, item, [item, [[item]] ]]]
+        @coded = @arr.__send__(@method, @host_pid)
+        item = :ITEM
+        @coded.should == [item, item, [item, item, [item, [[item]] ]]]
+      end
+    end
+    describe "encoding" do
+      before(:each) do
+        @method = @encode_method
+      end
+      it_should_behave_like "array codec"
+    end
+    describe "decoding" do
+      before(:each) do
+        @method = @decode_method
+      end
+      it_should_behave_like "array codec"
+    end
+  end
+
+
+  describe Hash do
+    describe "hash codec", :shared => true do
+      it "should encode/decode each key and value recusively" do
+        key   = codec_mock(@method, "key", 3)
+        value = codec_mock(@method, "value", 3)
+        @hash = { key => value, :key => { key => { "str" => value, key => {"str" => 123, :sym => value } } } }
+        @coded = @hash.__send__(@method, @host_pid)
+        key = :KEY
+        value = :VALUE
+        @coded.should == { key => value, :key => { key => { "str" => value, key => {"str" => 123, :sym => value } } } }
+      end
+    end
+    describe "encoding" do
+      before(:each) do
+        @method = @encode_method
+      end
+      it_should_behave_like "hash codec"
+    end
+    describe "decoding" do
+      before(:each) do
+        @method = @decode_method
+      end
+      it_should_behave_like "hash codec"
+    end
+  end
+  
+  describe Pid do
+    before(:each) do
+      @pid = Pid.new
+      @pid.uuid = @dummy_pid.uuid
+      @epid = @pid.encode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid)
+    end
+    
+    it "should be encoded into Pid::Marshallable" do
+      @epid.should be_kind_of(Pid::Marshallable)
+      @epid.uuid.should_not be_nil
+      @epid.uuid.should == @pid.uuid
+    end
+    
+    describe "decoded" do
+      before(:each) do
+        @host_pid.should_receive(:find_pid).once.with(@dummy_pid.uuid).and_return do |uuid|
+          @dummy_pid
+        end
+        @depid = @epid.decode_b381b571_1ab2_5889_8221_855dbbc76242(@host_pid)
+      end
+      it "should be decoded into real pid" do
+        @depid.should == @dummy_pid
+      end
+    end
+  end
+end
+
+
+describe Pid::Marshallable do
+  before(:each) do  
+    @cls = Pid::Marshallable
+    @obj = @cls.new("myuuid")
+  end
+  it "should be marshallable" do
+    Marshal.load(Marshal.dump(@obj)).uuid.should == @obj.uuid
+  end
+end