dripdrop 0.10.0-java

data/spec/message_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+class SpecMessageClass < DripDrop::Message
+  include DripDrop::SubclassedMessage
+end
+
+describe DripDrop::Message do
+  describe "basic message" do
+    def create_basic
+      attrs = {
+        :name => 'test',
+        :head => {'foo' => 'bar'},
+        :body => ['foo', 'bar', 'baz']
+      }
+      message = DripDrop::Message.new(attrs[:name],:head => attrs[:head],
+                                                   :body => attrs[:body])
+      [message, attrs]
+    end
+    it "should create a basic message without raising an exception" do
+      lambda {
+        message, attrs = create_basic
+      }.should_not raise_exception
+    end
+    describe "with minimal attributes" do
+      it "should create a message with only a name" do
+        lambda {
+          DripDrop::Message.new('nameonly')
+        }.should_not raise_exception
+      end
+      it "should set the head to a single key hash containing message class if nil provided" do
+        DripDrop::Message.new('nilhead', :head => nil).head.should == {'message_class' => 'DripDrop::Message'}
+      end
+      it "should raise an exception if a non-hash, non-nil head is provided" do
+        lambda {
+          DripDrop::Message.new('arrhead', :head => [])
+        }.should raise_exception(ArgumentError)
+      end
+    end
+    describe "encoding" do
+      before(:all) do
+        @message, @attrs = create_basic
+      end
+      it "should encode to valid JSON hash without error" do
+        enc = @message.encoded
+        enc.should be_a(String)
+        JSON.parse(enc).should be_a(Hash)
+      end
+      it "should decode encoded messages without errors" do
+        DripDrop::Message.decode(@message.encoded).should be_a(DripDrop::Message)
+      end
+      it "should decode JSON encoded messages without errors" do
+        DripDrop::Message.decode_json(@message.json_encoded).should be_a(DripDrop::Message)
+      end
+      it "should convert messages to Hash representations" do
+        @message.to_hash.should be_a(Hash)
+      end
+      it "should be able to turn hash representations back into Message objs" do
+        DripDrop::Message.from_hash(@message.to_hash).should be_a(DripDrop::Message)
+      end
+    end
+    describe "subclassing" do
+      def create_auto_message
+        attrs = {
+          :name => 'test',
+          :head => {'foo' => 'bar', 'message_class' => 'SpecMessageClass'},
+          :body => ['foo', 'bar', 'baz']
+        }
+
+        message = DripDrop::AutoMessageClass.create_message(attrs)
+
+        [message, attrs]
+      end
+      before(:all) do
+        @message, @attrs = create_auto_message
+      end
+      it "should be added to the subclass message class hash if SubclassedMessage included" do
+        DripDrop::AutoMessageClass.message_subclasses.should include('SpecMessageClass' => SpecMessageClass)
+      end
+      it "should throw an exception if we try to recreate a message of the wrong class" do
+        msg = DripDrop::Message.new('test')
+        lambda{SpecMessageClass.recreate_message(msg.to_hash)}.should raise_exception
+      end
+
+      describe "DripDrop::AutoMessageClass" do
+        it "should create a properly classed message based on head['message_class']" do
+          @message.should be_a(SpecMessageClass)
+        end
+        it "should recreate a message based on head['message_class']" do
+          DripDrop::AutoMessageClass.recreate_message(@message.to_hash).should be_a(SpecMessageClass)
+        end
+      end
+    end
+  end
+end

data/spec/node/http_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+require 'set'
+
+if defined?(EM::HttpServer)
+describe "http" do
+  
+  def http_send_messages(to_send,addr=rand_addr('http'),&block)
+    responses = []
+    client = nil
+    server = nil
+    
+    @node = run_reactor(2) do
+      zmq_subscribe(rand_addr, :bind) do |message|
+      end
+      
+      client = http_client(addr)
+      
+      server = http_server(addr).on_recv do |message,response|
+        $stdout.flush
+        responses << message
+        response.send_message(message)
+      end
+      
+      to_send.each do |message|
+        EM::next_tick do
+          http_client(addr).send_message(message) do |resp_message|
+            block.call(message,resp_message)
+          end
+        end
+      end
+    end
+    
+   {:responses => responses, :handlers => {:server => [server] }}
+  end
+  
+  shared_examples_for "all http nodes" do
+    describe "basic sending and receiving" do
+      before(:all) do
+        @sent = []
+        10.times {|i| @sent << DripDrop::Message.new("test-#{i}")}
+        @client_responses = []
+        @http_info = http_send_messages(@sent,@http_test_addr) do |sent_message,resp_message|
+          @client_responses << {:sent_message  => sent_message,
+                                :resp_message  => resp_message}
+        end
+        @responses     = @http_info[:responses]
+      end
+
+      it "should receive all sent messages" do
+        resp_names = @responses.map(&:name).inject(Set.new) {|memo,rn| memo << rn}
+        @sent.map(&:name).each {|sn| resp_names.should include(sn)}
+      end
+      
+      it "should return to the client as many responses as sent messages" do
+        @client_responses.length.should == @sent.length
+      end
+      
+      it "should return to the client an identical message to that which was sent" do
+        @client_responses.each do |resp|
+          resp[:sent_message].name.should == resp[:resp_message].name
+        end
+      end
+    end
+  end
+  
+  describe "http apps using the URL root (/)" do
+    before(:all) { @http_test_addr = rand_addr('http') }
+    it_should_behave_like "all http nodes"
+  end
+  
+  describe "http apps using a subdirectory of the URL (/subdir)" do
+    before(:all) { @http_test_addr = rand_addr('http') + '/subdir' }
+    it_should_behave_like "all http nodes"
+  end
+end
+end

data/spec/node/nodelet_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe "nodelets" do
+  class SpecialNodelet < DripDrop::Node::Nodelet
+    def action
+      route :worker1,     :zmq_pull, distributor_output.address, :connect
+      route :worker2,     :zmq_pull, distributor_output.address, :connect
+    end
+  end
+  
+  before(:all) do
+    nodelets = {}
+    
+    
+    @node = run_reactor do
+      nodelet :distributor do |nlet|
+        nlet.route :output, :zmq_push, rand_addr, :bind
+      end
+      
+      nodelet :worker_cluster, SpecialNodelet
+    end
+    
+    @nodelets = @node.nodelets
+  end
+  
+  it "should create the nodelets" do
+    @nodelets.length.should == 2
+  end
+  
+  it "should pass a DripDrop::Node::Nodelet to the block" do
+    @nodelets.values.each do |nlet|
+      nlet.should be_kind_of(DripDrop::Node::Nodelet)
+    end
+  end
+    
+  it "should give access to the full routing table to nodelets" do
+    @node.routing.each do |route_name,handler|
+      @nodelets.values.each do |nlet|
+        nlet.send(route_name).should == handler
+      end
+    end
+  end
+  
+  it "should use the class SpecialNodelet for the nodelet assigned that" do
+    @nodelets[:worker_cluster].should be_a(SpecialNodelet)
+  end
+
+  it "should return a DripDrop::Handler for short routes" do
+    @nodelets[:distributor].send(:output).should be_a(DripDrop::BaseHandler)
+  end
+
+  it "should return a DripDrop::Handler for long routes" do
+    @nodelets[:distributor].send(:distributor_output).should be_a(DripDrop::BaseHandler)
+  end
+  
+  it "should define prefix-less versions of nodelet specific routes" do
+    {
+      @nodelets[:worker_cluster] => {:worker1 => :worker_cluster_worker1, 
+                                     :worker2 => :worker_cluster_worker2},
+      @nodelets[:distributor]    => {:output  => :distributor_output}
+    }.each do |nlet, mapping|
+      mapping.each do |short,long|
+        nlet.send(short).should == nlet.send(long)
+      end
+    end
+  end
+end

data/spec/node/routing_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe "routing" do
+  shared_examples_for "all routing" do
+    it "should define all routes in the table" do
+      @expected_routing.keys.each do |route_name|
+        @node.routing.keys.should include(route_name)
+      end
+    end
+    
+    it "should define a handler in the routing table for each route" do
+      @expected_routing.keys.each do |route_name|
+        @node.routing[route_name].should be_kind_of(DripDrop::BaseHandler)
+      end
+    end    
+
+    it "should define a singleton method for each entry in the routing table" do
+      @expected_routing.keys.each do |route_name|
+        @node.send(route_name).should == @node.routing[route_name]
+      end
+    end
+
+    it "should create handlers with the correct properties" do
+      @expected_routing.each do |route_name,expected_props|
+        handler = @node.send(route_name)
+        handler.class.should == expected_props[:class]
+      end
+    end
+  end
+  
+  context "with no groups" do
+    before(:all) do
+      @expected_routing = {
+        :distributor => {:class => DripDrop::ZMQPushHandler},
+        :worker1     => {:class => DripDrop::ZMQPullHandler},
+        :worker2     => {:class => DripDrop::ZMQPullHandler}
+      }
+      @node = run_reactor do
+        route :distributor, :zmq_push, rand_addr, :bind
+        route :worker1,     :zmq_pull, distributor.address, :connect
+        route :worker2,     :zmq_pull, distributor.address, :connect
+      end
+    end
+
+    it_should_behave_like "all routing"
+  end
+  context "with groups" do
+    before(:all) do
+      @expected_routing = {
+        :distributor_output     => {:class => DripDrop::ZMQPushHandler, :socket_ctype => :bind},
+        :worker_cluster_worker1 => {:class => DripDrop::ZMQPullHandler, :socket_ctype => :connect},
+        :worker_cluster_worker2 => {:class => DripDrop::ZMQPullHandler, :socket_ctype => :connect}
+      }
+      @node = run_reactor do
+        nodelet :distributor do |nlet|
+          nlet.route :output, :zmq_push, rand_addr, :bind
+        end
+        nodelet :worker_cluster do |nlet|
+          nlet.route :worker1,     :zmq_pull, distributor_output.address, :connect
+          nlet.route :worker2,     :zmq_pull, distributor_output.address, :connect
+        end
+      end
+    end
+    
+    it_should_behave_like "all routing"
+  end
+end

data/spec/node/websocket_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe "websockets" do
+  def websockets_send_messages(to_send,&block)
+    received  = []
+    responses = []
+    seen_signatures = Set.new
+    server = nil
+    
+    open_message  = DripDrop::Message.new('open',  :body => 'test')
+    open_received = false
+    
+    close_occured = false
+    
+    error_occured = false
+    
+    @node = run_reactor(2) do
+      addr = rand_addr('ws')
+      
+      server = websocket_server(addr)
+      server.on_open do |conn|
+        conn.send_message(open_message)
+        seen_signatures << conn.signature
+      end.on_recv do |message,conn|
+        received << message
+        conn.send_message(message)
+      end.on_close do |conn|
+        close_occured = true
+      end.on_error do |reason,conn|
+        error_occured = true
+      end
+      
+      EM.defer do
+        client = WebSocket.new(addr)
+        open_received = DripDrop::Message.decode(client.receive)
+        to_send.each do |message|
+          client.send(message.json_encoded)
+        end
+        
+        recvd_count = 0
+        while recvd_count < to_send.length && (message = client.receive)
+          responses << DripDrop::Message.decode_json(message)
+          recvd_count += 1
+        end
+        client.close
+        
+        # This one only connects to test unique signatures
+        client2 = WebSocket.new(addr)
+        client2.close
+      end
+      
+      zmq_subscribe(rand_addr, :bind) {} #Keep zmqmachine happy
+    end
+    
+    {:received => received, :responses => responses, 
+     :open_message => open_message,   :open_received => open_received,
+     :close_occured => close_occured, :error_occured => error_occured,
+     :seen_signatures => seen_signatures,:handlers => {:server => server }}
+  end
+  describe "basic sending and receiving" do
+    before(:all) do
+      @sent = []
+      10.times {|i| @sent << DripDrop::Message.new("test-#{i}")}
+      @ws_info = websockets_send_messages(@sent)
+    end
+
+    it "should receive all sent messages" do
+      recvd_names = @ws_info[:received].map(&:name).inject(Set.new) {|memo,rn| memo << rn}
+      @sent.map(&:name).each {|sn| recvd_names.should include(sn)}
+    end
+    
+    it "should return to the client as many responses as sent messages" do
+      @ws_info[:responses].length.should == @sent.length
+    end
+    
+    it "should return to the client an identical message to that which was sent" do
+      @ws_info[:received].zip(@ws_info[:responses]).each do |recvd,resp|
+        recvd.name.should == resp.name
+      end
+    end
+
+    it "should generate an on open message" do
+      @ws_info[:open_received].to_hash.should == @ws_info[:open_message].to_hash
+    end
+    
+    it "should generate a close event" do
+      @ws_info[:close_occured].should be_true
+    end
+
+    it "should not generate an error event" do
+      @ws_info[:error_occured].should be_false
+    end
+    
+    it "should see unique connection signatures for each client" do
+      @ws_info[:seen_signatures].length.should == 2
+    end
+  end
+end

data/spec/node/zmq_m2_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+m2_req    = '34f9cfef-dc52-4b7f-b197-098765432112 16 /handlertest 537:{"PATH":"/handlertest","accept-language":"en-us,en;q=0.5","user-agent":"Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.13) Gecko/20110207 Gentoo Firefox/3.6.13","host":"it.wishdev.org:6767","accept-charset":"ISO-8859-1,utf-8;q=0.7,*;q=0.7","accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8","keep-alive":"115","x-forwarded-for":"127.0.0.1","cache-control":"max-age=0","connection":"keep-alive","accept-encoding":"gzip,deflate","METHOD":"GET","VERSION":"HTTP/1.1","URI":"/handlertest","PATTERN":"/handlertest"},0:,'
+dd_resp   = "34f9cfef-dc52-4b7f-b197-098765432112 2:16, HTTP/1.1 200 OK\r\nContent-Length: 19\r\n\r\nHello from DripDrop"
+
+body      = ""
+conn_id   = "16"
+headers   = {"PATH"=>"/handlertest",
+              "accept-language"=>"en-us,en;q=0.5",
+              "user-agent"=>
+                "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.13) Gecko/20110207 Gentoo Firefox/3.6.13",
+              "host"=>"it.wishdev.org:6767",
+              "accept-charset"=>"ISO-8859-1,utf-8;q=0.7,*;q=0.7",
+              "accept"=>"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+              "keep-alive"=>"115",
+              "x-forwarded-for"=>"127.0.0.1",
+              "cache-control"=>"max-age=0",
+              "connection"=>"keep-alive",
+              "accept-encoding"=>"gzip,deflate",
+              "METHOD"=>"GET",
+              "VERSION"=>"HTTP/1.1",
+              "URI"=>"/handlertest",
+              "PATTERN"=>"/handlertest"}
+path      = "/handlertest"
+sender    = "34f9cfef-dc52-4b7f-b197-098765432112"
+
+describe "zmq m2" do
+  def pp_send_messages(to_send)
+    responses = []
+    requests = []
+    
+    @node = run_reactor(2) do
+      addr = rand_addr
+      addr2 = rand_addr
+      
+      m2_send = zmq_push(addr, :bind, {:msg_format => :raw})
+      m2_recv = zmq_subscribe(addr2, :bind, {:msg_format => :raw})
+      
+      dd = zmq_m2([addr, addr2])
+
+      dd.on_recv do |req|
+        requests << req
+        dd.reply_http req, "Hello from DripDrop"
+      end
+
+      m2_recv.on_recv do |msg|
+        responses << msg
+      end
+
+      sleep 1
+      
+      to_send.each {|message| m2_send.send_message(message)}
+    end
+     
+    {:responses => responses, :requests => requests}
+  end
+  describe "basic sending and receiving" do
+    before(:all) do
+      @sent = [m2_req]
+      pp_info = pp_send_messages(@sent)
+      @responses     = pp_info[:responses]
+      @requests      = pp_info[:requests]
+    end
+
+    it "should parse a request" do
+      @requests[0].body.should == body
+      @requests[0].conn_id.should == conn_id
+      @requests[0].headers.should == headers
+      @requests[0].path.should == path
+      @requests[0].sender.should == sender
+    end
+
+    it "should respond to an http request" do
+      @responses[0][0].copy_out_string.should == dd_resp
+    end
+  end
+end