rjr 0.12.2 → 0.15.1

data/specs/message_spec.rb

@@ -1,203 +1,229 @@
 require 'rjr/dispatcher'
 require 'rjr/message'
 
-describe RJR::RequestMessage do
-  it "should accept request parameters" do
-    msg = RJR::RequestMessage.new :method => 'test',
-                                  :args   => ['a', 1],
-                                  :headers => {:h => 2}
-    msg.jr_method.should == "test"
-    msg.jr_args.should =~ ['a', 1]
-    msg.headers.should have_key(:h)
-    msg.headers[:h].should == 2
-    msg.msg_id.should =~ /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+module RJR
+  describe RequestMessage do
+    it "should accept request parameters" do
+      msg = RequestMessage.new :method => 'test',
+                               :args   => ['a', 1],
+                               :headers => {:h => 2}
+      msg.jr_method.should == "test"
+      msg.jr_args.should =~ ['a', 1]
+      msg.headers.should have_key(:h)
+      msg.headers[:h].should == 2
+      msg.msg_id.should =~ /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/
+    end
+
+    it "should return bool indicating if string is a request msg"
+
+    it "should produce valid json" do
+      msg = RequestMessage.new :method => 'test',
+                               :args   => ['a', 1],
+                               :headers => {:h => 2}
+
+      msg_string = msg.to_s
+      msg_string.should include('"h":2')
+      msg_string.should include('"method":"test"')
+      msg_string.should include('"params":["a",1]')
+      msg_string.should include('"jsonrpc":"2.0"')
+      msg_string.should include('"id":"'+msg.msg_id+'"')
+    end
+
+    it "should parse request message string" do
+      msg_uuid = gen_uuid 
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"id": "' + msg_uuid + '", ' +
+                   '"method": "test", "params": ["a", 1]}'
+      msg = RequestMessage.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.jr_method.should == 'test'
+      msg.jr_args.should =~ ['a', 1]
+      msg.msg_id.should == msg_uuid
+    end
+
+    it "should extract optional headers from message string" do
+      msg_uuid = gen_uuid 
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"id": "' + msg_uuid + '", ' +
+                   '"method": "test", "params": ["a", 1], ' +
+                   '"h": 2}'
+      msg = RequestMessage.new :message => msg_string, :headers => {'f' => 'g'}
+      msg.json_message.should == msg_string
+      msg.headers.should have_key 'h'
+      msg.headers.should have_key 'f'
+      msg.headers['h'].should == 2
+      msg.headers['f'].should == 'g'
+    end
+
+    it "should fail if parsing invalid message string" do
+      lambda {
+        msg = RequestMessage.new :message => 'foobar'
+      }.should raise_error JSON::ParserError
+    end
+
+  end
+
+  describe ResponseMessage do
+    it "should accept response parameters" do
+      msg_id = gen_uuid
+      msg = ResponseMessage.new :id      => msg_id,
+                                     :result  => Result.new(:result => 'success'),
+                                     :headers => {:h => 2}
+      msg.msg_id.should == msg_id
+      msg.result.result == 'success'
+      msg.headers.should have_key(:h)
+      msg.headers[:h].should == 2
+    end
+
+    it "should return bool indicating if string is a response msg"
+
+    it "should produce valid result response json" do
+      msg_id = gen_uuid
+      msg = ResponseMessage.new :id      => msg_id,
+                                :result  => RJR::Result.new(:result => 'success'),
+                                :headers => {:h => 2}
+      msg_string = msg.to_s
+      msg_string.should include('"id":"'+msg_id+'"')
+      msg_string.should include('"result":"success"')
+      msg_string.should include('"h":2')
+      msg_string.should include('"jsonrpc":"2.0"')
+    end
+
+    it "should produce valid error response json" do
+      msg_id = gen_uuid
+      msg = ResponseMessage.new :id      => msg_id,
+                                :result  =>
+                                  RJR::Result.new(:error_code => 404,
+                                                  :error_msg => 'not found',
+                                                  :error_class => ArgumentError),
+                                :headers => {:h => 2}
+      msg_string = msg.to_s
+      msg_string.should include('"id":"'+msg_id+'"')
+      msg_string.should include('"h":2')
+      msg_string.should include('"jsonrpc":"2.0"')
+      msg_string.should include('"error":{')
+      msg_string.should include('"code":404')
+      msg_string.should include('"message":"not found"')
+    end
+
+
+    it "should parse result response message string" do
+      msg_id = gen_uuid
+      msg_string = '{"id":"' + msg_id + '", ' +
+                    '"result":"success","jsonrpc":"2.0"}'
+      msg = ResponseMessage.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.msg_id.should == msg_id
+      msg.result.success.should == true
+      msg.result.failed.should == false
+      msg.result.result.should == "success"
+    end
+
+    it "should parse error response message string" do
+      msg_id = gen_uuid
+      msg_string = '{"id":"' + msg_id + '", ' +
+                    '"error":{"code":404,"message":"not found","class":"ArgumentError"}, "jsonrpc":"2.0"}'
+      msg = ResponseMessage.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.msg_id.should == msg_id
+      msg.result.success.should == false
+      msg.result.failed.should == true
+      msg.result.error_code.should == 404
+      msg.result.error_msg.should == "not found"
+      msg.result.error_class.should == 'ArgumentError'
+    end
+
+    it "should extract optional headers from message string" do
+      msg_id = gen_uuid
+      msg_string = '{"id":"' + msg_id + '", ' +
+                    '"result":"success","h":2,"jsonrpc":"2.0"}'
+      msg = ResponseMessage.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.headers.should have_key 'h'
+      msg.headers['h'].should == 2
+    end
+
+    it "should fail if parsing invalid message string" do
+      lambda {
+        msg = ResponseMessage.new :message => 'foobar'
+      }.should raise_error JSON::ParserError
+    end
+  end
+
+  describe NotificationMessage do
+    it "should accept notification parameters" do
+      msg = NotificationMessage.new :method => 'test',
+                                    :args   => ['a', 1],
+                                    :headers => {:h => 2}
+      msg.jr_method.should == "test"
+      msg.jr_args.should =~ ['a', 1]
+      msg.headers.should have_key(:h)
+      msg.headers[:h].should == 2
+    end
+
+    it "should return bool indicating if string is a notification msg"
+  
+    it "should produce valid json" do
+      msg = NotificationMessage.new :method => 'test',
+                                    :args   => ['a', 1],
+                                    :headers => {:h => 2}
+  
+      msg_string = msg.to_s
+      msg_string.should include('"h":2')
+      msg_string.should include('"method":"test"')
+      msg_string.should include('"params":["a",1]')
+      msg_string.should include('"jsonrpc":"2.0"')
+      msg_string.should_not include('"id":"')
+    end
+  
+    it "should parse notification message string" do
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"method": "test", "params": ["a", 1]}'
+      msg = NotificationMessage.new :message => msg_string
+      msg.json_message.should == msg_string
+      msg.jr_method.should == 'test'
+      msg.jr_args.should =~ ['a', 1]
+    end
+  
+    it "should extract optional headers from message string" do
+      msg_string = '{"jsonrpc": "2.0", ' +
+                   '"method": "test", "params": ["a", 1], ' +
+                   '"h": 2}'
+      msg = NotificationMessage.new :message => msg_string, :headers => {'f' => 'g'}
+      msg.json_message.should == msg_string
+      msg.headers.should have_key 'h'
+      msg.headers.should have_key 'f'
+      msg.headers['h'].should == 2
+      msg.headers['f'].should == 'g'
+    end
+  
+    it "should fail if parsing invalid message string" do
+      lambda {
+        msg = NotificationMessage.new :message => 'foobar'
+      }.should raise_error JSON::ParserError
+    end
+  end
+
+  describe MessageUtil do
+    after(:each) do
+      MessageUtil.clear
+    end
+
+    it "should extract json messages out of a message stream"
+
+    it "should store preformatted messages" do
+      MessageUtil.message 'foobar', 'raboof'
+      MessageUtil.message('foobar').should == 'raboof'
+    end
+
+    it "should clear preformatted messages" do
+      MessageUtil.message 'foobar', 'raboof'
+      MessageUtil.clear
+      MessageUtil.message('foobar').should be_nil
+    end
+
+    it "should return rand preformatted message"
+    it "should return rand preformatted message matching transport"
   end
 
-  it "should produce valid json" do
-    msg = RJR::RequestMessage.new :method => 'test',
-                                  :args   => ['a', 1],
-                                  :headers => {:h => 2}
-
-    msg_string = msg.to_s
-    msg_string.should include('"h":2')
-    msg_string.should include('"method":"test"')
-    msg_string.should include('"params":["a",1]')
-    msg_string.should include('"jsonrpc":"2.0"')
-    msg_string.should include('"id":"'+msg.msg_id+'"')
-  end
-
-  it "should parse request message string" do
-    msg_uuid = RJR::RequestMessage.gen_uuid 
-    msg_string = '{"jsonrpc": "2.0", ' +
-                 '"id": "' + msg_uuid + '", ' +
-                 '"method": "test", "params": ["a", 1]}'
-    msg = RJR::RequestMessage.new :message => msg_string
-    msg.json_message.should == msg_string
-    msg.jr_method.should == 'test'
-    msg.jr_args.should =~ ['a', 1]
-    msg.msg_id.should == msg_uuid
-  end
-
-  it "should extract optional headers from message string" do
-    msg_uuid = RJR::RequestMessage.gen_uuid 
-    msg_string = '{"jsonrpc": "2.0", ' +
-                 '"id": "' + msg_uuid + '", ' +
-                 '"method": "test", "params": ["a", 1], ' +
-                 '"h": 2}'
-    msg = RJR::RequestMessage.new :message => msg_string, :headers => {'f' => 'g'}
-    msg.json_message.should == msg_string
-    msg.headers.should have_key 'h'
-    msg.headers.should have_key 'f'
-    msg.headers['h'].should == 2
-    msg.headers['f'].should == 'g'
-  end
-
-  it "should fail if parsing invalid message string" do
-    lambda {
-      msg = RJR::RequestMessage.new :message => 'foobar'
-    }.should raise_error JSON::ParserError
-  end
-end
-
-describe RJR::ResponseMessage do
-  it "should accept response parameters" do
-    msg_id = RJR::RequestMessage.gen_uuid
-    msg = RJR::ResponseMessage.new :id      => msg_id,
-                                   :result  => RJR::Result.new(:result => 'success'),
-                                   :headers => {:h => 2}
-    msg.msg_id.should == msg_id
-    msg.result.result == 'success'
-    msg.headers.should have_key(:h)
-    msg.headers[:h].should == 2
-  end
-
-  it "should produce valid result response json" do
-    msg_id = RJR::RequestMessage.gen_uuid
-    msg = RJR::ResponseMessage.new :id      => msg_id,
-                                   :result  => RJR::Result.new(:result => 'success'),
-                                   :headers => {:h => 2}
-    msg_string = msg.to_s
-    msg_string.should include('"id":"'+msg_id+'"')
-    msg_string.should include('"result":"success"')
-    msg_string.should include('"h":2')
-    msg_string.should include('"jsonrpc":"2.0"')
-  end
-
-  it "should produce valid error response json" do
-    msg_id = RJR::RequestMessage.gen_uuid
-    msg = RJR::ResponseMessage.new :id      => msg_id,
-                                   :result  => RJR::Result.new(:error_code => 404,
-                                                               :error_msg => 'not found',
-                                                               :error_class => ArgumentError),
-                                   :headers => {:h => 2}
-    msg_string = msg.to_s
-    msg_string.should include('"id":"'+msg_id+'"')
-    msg_string.should include('"h":2')
-    msg_string.should include('"jsonrpc":"2.0"')
-    msg_string.should include('"error":{')
-    msg_string.should include('"code":404')
-    msg_string.should include('"message":"not found"')
-  end
-
-
-  it "should parse result response message string" do
-    msg_id = RJR::RequestMessage.gen_uuid
-    msg_string = '{"id":"' + msg_id + '", ' +
-                  '"result":"success","jsonrpc":"2.0"}'
-    msg = RJR::ResponseMessage.new :message => msg_string
-    msg.json_message.should == msg_string
-    msg.msg_id.should == msg_id
-    msg.result.success.should == true
-    msg.result.failed.should == false
-    msg.result.result.should == "success"
-  end
-
-  it "should parse error response message string" do
-
-    msg_id = RJR::RequestMessage.gen_uuid
-    msg_string = '{"id":"' + msg_id + '", ' +
-                  '"error":{"code":404,"message":"not found","class":"ArgumentError"}, "jsonrpc":"2.0"}'
-    msg = RJR::ResponseMessage.new :message => msg_string
-    msg.json_message.should == msg_string
-    msg.msg_id.should == msg_id
-    msg.result.success.should == false
-    msg.result.failed.should == true
-    msg.result.error_code.should == 404
-    msg.result.error_msg.should == "not found"
-    msg.result.error_class.should == 'ArgumentError'
-  end
-
-  it "should extract optional headers from message string" do
-    msg_id = RJR::RequestMessage.gen_uuid
-    msg_string = '{"id":"' + msg_id + '", ' +
-                  '"result":"success","h":2,"jsonrpc":"2.0"}'
-    msg = RJR::ResponseMessage.new :message => msg_string
-    msg.json_message.should == msg_string
-    msg.headers.should have_key 'h'
-    msg.headers['h'].should == 2
-  end
-
-  it "should fail if parsing invalid message string" do
-    lambda {
-      msg = RJR::ResponseMessage.new :message => 'foobar'
-    }.should raise_error JSON::ParserError
-  end
-end
-
-describe RJR::NotificationMessage do
-  it "should accept notification parameters" do
-    msg = RJR::NotificationMessage.new :method => 'test',
-                                       :args   => ['a', 1],
-                                       :headers => {:h => 2}
-    msg.jr_method.should == "test"
-    msg.jr_args.should =~ ['a', 1]
-    msg.headers.should have_key(:h)
-    msg.headers[:h].should == 2
-  end
-
-  it "should produce valid json" do
-    msg = RJR::NotificationMessage.new :method => 'test',
-                                       :args   => ['a', 1],
-                                       :headers => {:h => 2}
-
-    msg_string = msg.to_s
-    msg_string.should include('"h":2')
-    msg_string.should include('"method":"test"')
-    msg_string.should include('"params":["a",1]')
-    msg_string.should include('"jsonrpc":"2.0"')
-    msg_string.should_not include('"id":"')
-  end
-
-  it "should parse notification message string" do
-    msg_string = '{"jsonrpc": "2.0", ' +
-                 '"method": "test", "params": ["a", 1]}'
-    msg = RJR::NotificationMessage.new :message => msg_string
-    msg.json_message.should == msg_string
-    msg.jr_method.should == 'test'
-    msg.jr_args.should =~ ['a', 1]
-  end
-
-  it "should extract optional headers from message string" do
-    msg_string = '{"jsonrpc": "2.0", ' +
-                 '"method": "test", "params": ["a", 1], ' +
-                 '"h": 2}'
-    msg = RJR::NotificationMessage.new :message => msg_string, :headers => {'f' => 'g'}
-    msg.json_message.should == msg_string
-    msg.headers.should have_key 'h'
-    msg.headers.should have_key 'f'
-    msg.headers['h'].should == 2
-    msg.headers['f'].should == 'g'
-  end
-
-  it "should fail if parsing invalid message string" do
-    lambda {
-      msg = RJR::NotificationMessage.new :message => 'foobar'
-    }.should raise_error JSON::ParserError
-  end
-end
-
-describe RJR::MessageUtil do
-  it "should extract json messages out of a message stream" do
-    # TODO!
-  end
 end

data/specs/node_spec.rb

@@ -1,169 +1,73 @@
+require 'rjr/dispatcher'
 require 'rjr/node'
 
-describe RJR::Node do
-  it "should initialize properly from params" do
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.node_id.should == 'foobar'
-    node.message_headers[:h].should == 123
+module RJR
+  describe Node do
+
+    it "should initialize properly from params" do
+      d = Dispatcher.new
+      node = Node.new :node_id => 'foobar',
+                      :headers => {:h => 123},
+                      :dispatcher => d
+      node.node_id.should == 'foobar'
+      node.message_headers[:h].should == 123
+      node.dispatcher.should == d
+    end
+
+    it "should create a new dispatcher" do
+      node = Node.new
+      node.dispatcher.should_not be_nil
+      node.dispatcher.class.should == Dispatcher
+    end
+
+    it "should start the thread pool" do
+      ThreadPool.instance.stop.join
+      node = Node.new
+      ThreadPool.instance.should be_running
+    end
+
+    it "should start event machine" do
+      EMAdapter.instance.halt.join
+      node = Node.new
+      EMAdapter.instance.reactor_running?.should be_true
+    end
+
+    it "should halt the thread pool" do
+      node = Node.new
+      node.halt.join
+      ThreadPool.instance.should_not be_running
+    end
+
+    it "should halt event machine" do
+      node = Node.new
+      node.halt.join
+      EMAdapter.instance.reactor_running?.should be_false
+    end
+
+    it "should handle connection events" do
+      node = Node.new
+      closed = false
+      error = false
+      node.on :closed do
+        closed = true
+      end
+      node.on :error do
+        error = true
+      end
+      node.send(:connection_event, :error)
+      error.should be_true
+
+      node.send(:connection_event, :closed)
+      closed.should be_true
+    end
+
+    it "should handle request messages"
+    it "should handle notification messages"
+    it "should handle response messages"
+    it "should block until reponse is received"
   end
 
-  it "should start eventmachine and allow multiple blocks to be invoked in its context" do
-    block1_called = false
-    block2_called = false
-
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_run {
-      ThreadPool2Manager.running?.should be_true
-      EMAdapter.running?.should be_true
-      block1_called = true
-      node.em_run {
-        EMAdapter.running?.should be_true
-        block2_called = true
-        node.halt
-      }
-    }
-    node.join
-
-    block1_called.should be_true
-    block2_called.should be_true
-  end
-
-  #it "should gracefully stop managed subsystems" do
-  #  # TODO test w/ keep_alive
-  #  node = RJR::Node.new :node_id => 'foobar',
-  #                       :headers => {:h => 123}
-  #  node.em_run {}
-  #  EMAdapter.running?.should be_true
-  #  ThreadPool2Manager.running?.should be_true
-  #  node.stop
-  #  node.join
-  #end
-
-  it "should halt managed subsystems" do
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_run {}
-    EMAdapter.running?.should be_true
-    ThreadPool2Manager.running?.should be_true
-    node.halt
-    node.join
-    EMAdapter.running?.should be_false
-    ThreadPool2Manager.running?.should be_false
-  end
-
-  it "should run a block directly via eventmachine" do
-    block1_called = false
-    block1_thread = nil
-
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_run {
-      block1_called = true
-      block1_thread = Thread.current
-      node.halt
-    }
-    reactor_thread = EMAdapter.instance_variable_get(:@em_manager).instance_variable_get(:@reactor_thread)
-    node.join
-    block1_called.should be_true
-    block1_thread.should == reactor_thread
-  end
-
-  it "should run a block in a thread via eventmachine" do
-    block1_called = false
-    block1_thread = nil
-
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_run_async {
-      block1_called = true
-      block1_thread = Thread.current
-      node.halt
-    }
-    reactor_thread = EMAdapter.instance_variable_get(:@em_manager).instance_variable_get(:@reactor_thread)
-    worker_threads = ThreadPool2Manager.thread_pool.instance_variable_get(:@worker_threads)
-    node.join
-    block1_called.should be_true
-    block1_thread.should_not == reactor_thread   
-    worker_threads.should include(block1_thread)
-  end
-
-  it "should schedule a job to be run in a thread via eventmachine after a specified interval" do
-    block1_called = false
-    block1_thread = nil
-
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_schedule_async(1) {
-      block1_called = true
-      block1_thread = Thread.current
-      node.halt
-    }
-    reactor_thread = EMAdapter.instance_variable_get(:@em_manager).instance_variable_get(:@reactor_thread)
-    worker_threads = ThreadPool2Manager.thread_pool.instance_variable_get(:@worker_threads)
-
-    sleep 0.5
-    block1_called.should be_false
-
-    node.join
-    block1_called.should be_true
-    block1_thread.should_not == reactor_thread   
-    worker_threads.should include(block1_thread)
+  describe NodeCallback do
+    it "should send notifications"
   end
-
-  it "should schedule a job to be run directly via eventmachine repeatidly with specified interval" do
-    block1_threads = []
-
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_repeat(1) {
-      block1_threads << Thread.current
-    }
-    reactor_thread = EMAdapter.instance_variable_get(:@em_manager).instance_variable_get(:@reactor_thread)
-
-    sleep 0.5
-    block1_threads.size.should == 0
-
-    sleep 0.6
-    block1_threads.size.should == 1
-
-    sleep 1.1
-    block1_threads.size.should == 2
-    node.halt
-    node.join
-
-    block1_threads.each { |bt|
-      bt.should == reactor_thread   
-    }
-  end
-
-  it "should schedule a job to be run in a thread via eventmachine repeatidly with specified interval" do
-    block1_threads = []
-
-    node = RJR::Node.new :node_id => 'foobar',
-                         :headers => {:h => 123}
-    node.em_repeat_async(1) {
-      block1_threads << Thread.current
-    }
-    reactor_thread = EMAdapter.instance_variable_get(:@em_manager).instance_variable_get(:@reactor_thread)
-    worker_threads = ThreadPool2Manager.thread_pool.instance_variable_get(:@worker_threads)
-
-    sleep 0.5
-    block1_threads.size.should == 0
-
-    sleep 0.6
-    block1_threads.size.should == 1
-
-    sleep 1.1
-    block1_threads.size.should == 2
-    node.halt
-    node.join
-
-    block1_threads.each { |bt|
-      bt.should_not == reactor_thread   
-      worker_threads.should include(bt)
-    }
-  end
-
 end