ruby_skynet 0.1.0

data/test/doozer_client_test.rb

@@ -0,0 +1,73 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'ruby_skynet/doozer/client'
+
+SemanticLogger::Logger.default_level = :trace
+SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
+
+# NOTE:
+# This test assumes that doozerd is running locally on the default port of 8046
+
+# Unit Test for RubySkynet::Doozer::Client
+class DoozerClientTest < Test::Unit::TestCase
+  context RubySkynet::Doozer::Client do
+
+    context "without server" do
+      should "raise exception when cannot reach doozer server after 5 retries" do
+        exception = assert_raise ResilientSocket::ConnectionFailure do
+          RubySkynet::Doozer::Client.new(
+            # Bad server address to test exception is raised
+            :server                 => 'localhost:9999',
+            :connect_retry_interval => 0.1,
+            :connect_retry_count    => 5)
+        end
+        assert_match /After 5 attempts: Errno::ECONNREFUSED/, exception.message
+      end
+
+    end
+
+    context "with client connection" do
+      setup do
+        @client = RubySkynet::Doozer::Client.new(:server => 'localhost:8046')
+      end
+
+      def teardown
+        if @client
+          @client.close
+          @client.delete('/test/foo')
+        end
+      end
+
+      should "return current revision" do
+        assert @client.current_revision >= 0
+      end
+
+      should "successfully set and get data" do
+        new_revision = @client.set('/test/foo', 'value')
+        result = @client.get('/test/foo')
+        assert_equal 'value', result.value
+        assert_equal new_revision, result.rev
+      end
+
+      should "successfully set and get data using array operators" do
+        @client['/test/foo'] = 'value2'
+        result = @client['/test/foo']
+        assert_equal 'value2', result
+      end
+
+      should "fetch directories in a path" do
+        @path = '/'
+        count = 0
+        until @client.directory(@path, count).nil?
+          count += 1
+        end
+        assert count > 0
+      end
+
+    end
+  end
+end

data/test/ruby_skynet_client_test.rb

@@ -0,0 +1,77 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'ruby_skynet'
+require 'simple_server'
+
+SemanticLogger::Logger.default_level = :trace
+SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
+
+# Unit Test for ResilientSocket::TCPClient
+class RubySkynetClientTest < Test::Unit::TestCase
+  context RubySkynet::Client do
+
+    context "without server" do
+      should "raise exception when cannot reach server after 5 retries" do
+        exception = assert_raise ResilientSocket::ConnectionFailure do
+          RubySkynet::Client.new('SomeService',
+            :server                 => 'localhost:3300',
+            :connect_retry_interval => 0.1,
+            :connect_retry_count    => 5)
+        end
+        assert_match /After 5 attempts: Errno::ECONNREFUSED/, exception.message
+      end
+
+    end
+
+    context "with server" do
+      setup do
+        @read_timeout = 3.0
+        @server = SimpleServer.new(2000)
+        @server_name = 'localhost:2000'
+      end
+
+      teardown do
+        @server.stop if @server
+      end
+
+      context "using blocks" do
+        should "call server" do
+          RubySkynet::Client.connect('TutorialService', :read_timeout => @read_timeout, :server => @server_name) do |tutorial_service|
+            assert_equal 'test1', tutorial_service.call(:test1, 'some' => 'parameters')['result']
+          end
+        end
+      end
+
+      context "with client connection" do
+        setup do
+          @client = RubySkynet::Client.new('TutorialService', :read_timeout => @read_timeout, :server => @server_name)
+        end
+
+        def teardown
+          @client.close if @client
+        end
+
+        should "successfully send and receive data" do
+          reply = @client.call(:test1, 'some' => 'parameters')
+          assert_equal 'test1', reply['result']
+        end
+
+        should "timeout on receive" do
+          request = { 'duration' => @read_timeout + 0.5}
+
+          exception = assert_raise ResilientSocket::ReadTimeout do
+            # Read 4 bytes from server
+            @client.call('sleep', request)
+          end
+          assert_match /Timedout after #{@read_timeout} seconds trying to read/, exception.message
+        end
+
+      end
+    end
+  end
+end

data/test/simple_server.rb

@@ -0,0 +1,134 @@
+require 'rubygems'
+require 'socket'
+require 'bson'
+require 'semantic_logger'
+
+# This a simple stand-alone server that does not use the Skynet code so that
+# the Skynet code can be tested
+
+
+# Read the bson document, returning nil if the IO is closed
+# before receiving any data or a complete BSON document
+def read_bson_document(io)
+  bytebuf = BSON::ByteBuffer.new
+  # Read 4 byte size of following BSON document
+  bytes = io.read(4)
+  return unless bytes
+  # Read BSON document
+  sz = bytes.unpack("V")[0]
+  bytebuf.append!(bytes)
+  bytes = io.read(sz-4)
+  return unless bytes
+  bytebuf.append!(bytes)
+  return BSON.deserialize(bytebuf)
+end
+
+# Simple single threaded server for testing purposes using a local socket
+# Sends and receives BSON Messages
+class SimpleServer
+  attr_reader :thread
+  def initialize(port = 2000)
+    start(port)
+  end
+
+  def start(port)
+    @server = TCPServer.open(port)
+    @logger = SemanticLogger::Logger.new(self.class)
+
+    @thread = Thread.new do
+      loop do
+        @logger.debug "Waiting for a client to connect"
+
+        # Wait for a client to connect
+        on_request(@server.accept)
+      end
+    end
+  end
+
+  def stop
+    if @thread
+      @thread.kill
+      @thread.join
+      @thread = nil
+    end
+    begin
+      @server.close if @server
+    rescue IOError
+    end
+  end
+
+  # Called for each message received from the client
+  # Returns a Hash that is sent back to the caller
+  def on_message(method, params)
+    case method
+    when 'test1'
+      { 'result' => 'test1' }
+    when 'sleep'
+      sleep params['duration'] || 1
+      { 'result' => 'sleep' }
+    when 'fail'
+      if params['attempt'].to_i >= 2
+        { 'result' => 'fail' }
+      else
+        nil
+      end
+    else
+      { 'result' => "Unknown method: #{method}" }
+    end
+  end
+
+  # Called for each client connection
+  # In a real server each request would be handled in a separate thread
+  def on_request(client)
+    @logger.debug "Client connected, waiting for data from client"
+
+    # Process handshake
+    handshake = {
+      'registered' => true,
+      'clientid' => '123'
+    }
+    client.print(BSON.serialize(handshake))
+    read_bson_document(client)
+
+    while(header = read_bson_document(client)) do
+      @logger.debug "\n******************"
+      @logger.debug "Received Request"
+      @logger.trace 'Header', header
+
+      request = read_bson_document(client)
+      @logger.trace 'Request', request
+      break unless request
+
+      if reply = on_message(request['method'], BSON.deserialize(request['in']))
+        @logger.debug "Sending Header"
+        # For this test we just send back the received header
+        client.print(BSON.serialize(header))
+
+        @logger.debug "Sending Reply"
+        @logger.trace 'Reply', reply
+        client.print(BSON.serialize({'out' => BSON.serialize(reply).to_s}))
+      else
+        @logger.debug "Closing client since no reply is being sent back"
+        @server.close
+        client.close
+        @logger.debug "Server closed"
+        #@thread.kill
+        @logger.debug "thread killed"
+        start(2000)
+        @logger.debug "Server Restarted"
+        break
+      end
+    end
+    # Disconnect from the client
+    client.close
+    @logger.debug "Disconnected from the client"
+  end
+
+end
+
+if $0 == __FILE__
+  SemanticLogger::Logger.default_level = :trace
+  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDOUT)
+  server = SimpleServer.new(2000)
+  server.thread.join
+end