toq 0.0.1

data/spec/servers/server.rb

@@ -0,0 +1,83 @@
+require 'ap'
+require_relative '../../lib/toq'
+
+def pems_path
+    File.expand_path( File.dirname( __FILE__ ) + '/../' )
+end
+
+def rpc_opts
+    {
+        host:       '127.0.0.1',
+        port:       7331,
+        token:      'superdupersecret',
+        serializer: Marshal,
+    }
+end
+
+def rpc_opts_with_socket
+    opts = rpc_opts
+    opts.delete( :host )
+    opts.delete( :port )
+
+    opts.merge( socket: '/tmp/arachni-rpc-test' )
+end
+
+def rpc_opts_with_ssl_primitives
+    rpc_opts.merge(
+        port:     7332,
+        ssl_ca:   pems_path + '/pems/cacert.pem',
+        ssl_pkey: pems_path + '/pems/client/key.pem',
+        ssl_cert: pems_path + '/pems/client/cert.pem'
+    )
+end
+
+def rpc_opts_with_invalid_ssl_primitives
+    rpc_opts_with_ssl_primitives.merge(
+        ssl_pkey: pems_path + '/pems/client/foo-key.pem',
+        ssl_cert: pems_path + '/pems/client/foo-cert.pem'
+    )
+end
+
+def rpc_opts_with_mixed_ssl_primitives
+    rpc_opts_with_ssl_primitives.merge(
+        ssl_pkey: pems_path + '/pems/client/key.pem',
+        ssl_cert: pems_path + '/pems/client/foo-cert.pem'
+    )
+end
+
+class Parent
+    def foo( arg )
+        arg
+    end
+end
+
+class Test < Parent
+
+    # In order to make inherited methods accessible you've got to explicitly
+    # make them public.
+    private :foo
+    public  :foo
+
+    def delay( arg, &block )
+        Raktr.global.delay( 1 ) { block.call( arg ) }
+    end
+
+    def exception
+        fail
+    end
+
+    def defer( arg, &block )
+        Thread.new do
+            block.call( arg )
+        end
+    end
+
+end
+
+def start_server( opts, do_not_start = false )
+    server = Toq::Server.new( opts )
+    server.add_async_check { |method| method.parameters.flatten.include? :block }
+    server.add_handler( 'test', Test.new )
+    server.run if !do_not_start
+    server
+end

data/spec/servers/unix_socket.rb

@@ -0,0 +1,8 @@
+require_relative 'server'
+
+opts = rpc_opts.merge(
+    socket:     '/tmp/arachni-rpc-test',
+    serializer: Marshal
+)
+
+start_server( opts )

data/spec/servers/with_ssl_primitives.rb

@@ -0,0 +1,11 @@
+require_relative 'server'
+
+cwd = File.expand_path( File.dirname( __FILE__ ) )
+opts = rpc_opts.merge(
+    port:     7332,
+    ssl_ca:   cwd + '/../pems/cacert.pem',
+    ssl_pkey: cwd + '/../pems/server/key.pem',
+    ssl_cert: cwd + '/../pems/server/cert.pem'
+)
+
+start_server( opts )

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'ap'
+require 'timeout'
+require_relative '../lib/toq'
+require_relative 'servers/server'
+
+def cwd
+    File.expand_path( File.dirname( __FILE__ ) )
+end
+
+def start_client( opts )
+    Toq::Client.new( opts )
+end
+
+def quiet_spawn( file )
+    path = File.join( File.expand_path( File.dirname( __FILE__ ) ), 'servers', "#{file}.rb" )
+    Process.spawn RbConfig.ruby, path#, out: '/dev/null'
+end
+
+server_pids = []
+RSpec.configure do |config|
+    config.color = true
+    config.add_formatter :documentation
+
+    config.before( :suite ) do
+        File.delete( '/tmp/arachni-rpc-test' ) rescue nil
+
+        files = %w(basic with_ssl_primitives)
+        files << 'unix_socket' if Raktr.supports_unix_sockets?
+
+        files.each do |name|
+            server_pids << quiet_spawn( name ).tap { |pid| Process.detach( pid ) }
+        end
+        sleep 5
+    end
+
+    config.after( :suite ) do
+        server_pids.each { |pid| Process.kill( 'KILL', pid ) }
+    end
+end

data/spec/toq/client_spec.rb

@@ -0,0 +1,397 @@
+require 'spec_helper'
+
+describe Toq::Client do
+
+    def wait
+        Raktr.global.wait rescue Raktr::Error::NotRunning
+    end
+
+    before(:each) do
+        if Raktr.global.running?
+            Raktr.stop
+        end
+    end
+
+    let(:arguments) do
+        [
+            'one',
+            2,
+            { three: 3 },
+            [ 4 ]
+        ]
+    end
+    let(:reactor) { Raktr.global }
+    let(:handler) { 'test' }
+    let(:remote_method) { 'foo' }
+    let(:options) { rpc_opts }
+    subject do
+        start_client( options )
+    end
+
+    def call( &block )
+        subject.call( "#{handler}.#{remote_method}", arguments, &block )
+    end
+
+    describe '#initialize' do
+        let(:options) { rpc_opts.merge( role: :client ) }
+
+        it 'assigns instance options (including :role)' do
+            subject.opts.should == options
+        end
+
+        context 'when passed no connection information' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new({})
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
+        end
+
+        describe 'option' do
+            describe :socket, if: Raktr.supports_unix_sockets? do
+                let(:options) { rpc_opts_with_socket }
+
+                it 'connects to it' do
+                    call.should == arguments
+                end
+
+                context 'when under heavy load' do
+                    it 'retains stability and consistency' do
+                        n    = 10_000
+                        cnt  = 0
+
+                        mismatches = []
+
+                        n.times do |i|
+                            arg = 'a' * i
+                            subject.call( "#{handler}.#{remote_method}", arg ) do |res|
+                                cnt += 1
+                                mismatches << [i, arg, res] if arg != res
+                                Raktr.stop if cnt == n || mismatches.any?
+                            end
+                        end
+                        wait
+
+                        cnt.should > 0
+                        mismatches.should be_empty
+                    end
+                end
+
+                context 'and connecting to a non-existent server' do
+                    let(:options) { rpc_opts_with_socket.merge( socket: '/' ) }
+
+                    it "returns #{Toq::Exceptions::ConnectionError}" do
+                        response = nil
+                        call do |res|
+                            response = res
+                            Raktr.stop
+                        end
+                        wait
+
+                        response.should be_rpc_connection_error
+                        response.should be_kind_of Toq::Exceptions::ConnectionError
+                    end
+                end
+
+                context 'when passed an invalid socket path' do
+                    it 'raises ArgumentError' do
+                        begin
+                            described_class.new( socket: 'blah' )
+                        rescue => e
+                            e.should be_kind_of ArgumentError
+                        end
+                    end
+                end
+            end
+        end
+
+        context 'when passed a host but not a port' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new( host: 'test' )
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
+        end
+
+        context 'when passed a port but not a host' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new( port: 9999 )
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
+        end
+
+        context 'when passed an invalid port' do
+            it 'raises ArgumentError' do
+                begin
+                    described_class.new( host: 'tt', port: 'blah' )
+                rescue => e
+                    e.should be_kind_of ArgumentError
+                end
+            end
+        end
+    end
+
+    describe '#call' do
+        context 'when calling a remote method that delays its results' do
+            let(:remote_method) { 'delay' }
+
+            it 'it supports it' do
+                call.should == arguments
+            end
+        end
+
+        context 'when calling a remote method that defers its results' do
+            let(:remote_method) { 'defer' }
+
+            it 'it supports it' do
+                call.should == arguments
+            end
+        end
+
+        context 'when under heavy load' do
+            it 'retains stability and consistency' do
+                n   = 10_000
+                cnt = 0
+
+                mismatches = []
+
+                n.times do |i|
+                    arg = 'a' * i
+                    subject.call( "#{handler}.#{remote_method}", arg ) do |res|
+                        cnt += 1
+                        mismatches << [i, arg, res] if arg != res
+                        Raktr.stop if cnt == n || mismatches.any?
+                    end
+                end
+
+                wait
+
+                cnt.should > 0
+                mismatches.should be_empty
+            end
+        end
+
+        context 'when using Threads' do
+            it 'should be able to perform synchronous calls' do
+                arguments.should == call
+            end
+
+            it 'should be able to perform asynchronous calls' do
+                response = nil
+                call do |res|
+                    response = res
+                    Raktr.stop
+                end
+                wait
+
+                response.should == arguments
+            end
+        end
+
+        context 'when run inside the Reactor loop' do
+            it 'should be able to perform asynchronous calls' do
+                response = nil
+
+                Raktr.stop
+                reactor.run do
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                end
+
+                response.should == arguments
+            end
+
+            it 'should not be able to perform synchronous calls' do
+                exception = nil
+
+                Raktr.stop
+                reactor.run do
+                    begin
+                        call
+                    rescue => e
+                        exception = e
+                        Raktr.stop
+                    end
+                end
+
+                exception.should be_kind_of RuntimeError
+            end
+        end
+
+        context 'when performing an asynchronous call' do
+            context 'and connecting to a non-existent server' do
+                let(:options) { rpc_opts.merge( host: 'dddd', port: 999339 ) }
+
+                it "returns #{Toq::Exceptions::ConnectionError}" do
+                    response = nil
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                    wait
+
+                    response.should be_rpc_connection_error
+                    response.should be_kind_of Toq::Exceptions::ConnectionError
+                end
+            end
+
+            context 'and requesting a non-existent object' do
+                let(:handler) { 'bar' }
+
+                it "returns #{Toq::Exceptions::InvalidObject}" do
+                    response = nil
+
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                    wait
+
+                    response.should be_rpc_invalid_object_error
+                    response.should be_kind_of Toq::Exceptions::InvalidObject
+                end
+            end
+
+            context 'and requesting a non-public method' do
+                let(:remote_method) { 'bar' }
+
+                it "returns #{Toq::Exceptions::InvalidMethod}" do
+                    response = nil
+
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                    wait
+
+                    response.should be_rpc_invalid_method_error
+                    response.should be_kind_of Toq::Exceptions::InvalidMethod
+                end
+            end
+
+            context 'and there is a remote exception' do
+                let(:remote_method) { :exception }
+
+                it "returns #{Toq::Exceptions::RemoteException}" do
+                    response = nil
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                    wait
+
+                    response.should be_rpc_remote_exception
+                    response.should be_kind_of Toq::Exceptions::RemoteException
+                end
+            end
+        end
+
+        context 'when performing a synchronous call' do
+            context 'and connecting to a non-existent server' do
+                let(:options) { rpc_opts.merge( host: 'dddd', port: 999339 ) }
+
+               it "raises #{Toq::Exceptions::ConnectionError}" do
+                   begin
+                       call
+                   rescue => e
+                       e.rpc_connection_error?.should be_true
+                       e.should be_kind_of Toq::Exceptions::ConnectionError
+                   end
+               end
+            end
+
+            context 'and requesting a non-existent object' do
+                let(:handler) { 'bar' }
+
+                it "raises #{Toq::Exceptions::InvalidObject}" do
+                    begin
+                        call
+                    rescue => e
+                        e.rpc_invalid_object_error?.should be_true
+                        e.should be_kind_of Toq::Exceptions::InvalidObject
+                    end
+                end
+            end
+
+            context 'and requesting a non-public method' do
+                let(:remote_method) { 'bar' }
+
+                it "raises #{Toq::Exceptions::InvalidMethod}" do
+                    begin
+                        call
+                    rescue => e
+                        e.rpc_invalid_method_error?.should be_true
+                        e.should be_kind_of Toq::Exceptions::InvalidMethod
+                    end
+                end
+            end
+
+            context 'and there is a remote exception' do
+                let(:remote_method) { :exception }
+
+                it "raises #{Toq::Exceptions::RemoteException}" do
+                    begin
+                        call
+                    rescue => e
+                        e.rpc_remote_exception?.should be_true
+                        e.should be_kind_of Toq::Exceptions::RemoteException
+                    end
+                end
+            end
+        end
+
+        context 'when using valid SSL configuration' do
+            let(:options) { rpc_opts_with_ssl_primitives }
+
+            it 'should be able to establish a connection' do
+                call.should == arguments
+            end
+        end
+
+        context 'when using invalid SSL configuration' do
+            let(:options) { rpc_opts_with_invalid_ssl_primitives }
+
+            it 'should not be able to establish a connection' do
+                response = nil
+
+                Raktr.stop
+                reactor.run do
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                end
+
+                response.should be_rpc_connection_error
+            end
+        end
+
+        context 'when using mixed SSL configuration' do
+            let(:options) { rpc_opts_with_mixed_ssl_primitives }
+
+            it 'should not be able to establish a connection' do
+                response = nil
+
+                Raktr.stop
+                reactor.run do
+                    call do |res|
+                        response = res
+                        Raktr.stop
+                    end
+                end
+
+                response.should be_rpc_connection_error
+            end
+        end
+    end
+
+end

data/spec/toq/exceptions_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Toq::Exceptions do
+
+    describe '#rpc_exception?' do
+        context 'for RPC exceptions' do
+            subject { described_class::InvalidMethod.new.rpc_exception? }
+            it { should be_true }
+        end
+
+        context 'for other exceptions' do
+            subject { ::Exception.new.rpc_connection_error? }
+            it { should be_false }
+        end
+    end
+
+    describe '#rpc_connection_error?' do
+        context 'for ConnectionError' do
+            subject { described_class::ConnectionError.new.rpc_connection_error? }
+            it { should be_true }
+        end
+
+        context 'for other exceptions' do
+            subject { described_class::InvalidMethod.new.rpc_connection_error? }
+            it { should be_false }
+        end
+    end
+
+    describe '#rpc_remote_exception?' do
+        context 'for RemoteException' do
+            subject { described_class::RemoteException.new.rpc_remote_exception? }
+            it { should be_true }
+        end
+
+        context 'for other exceptions' do
+            subject { described_class::InvalidMethod.new.rpc_remote_exception? }
+            it { should be_false }
+        end
+    end
+
+    describe '#rpc_invalid_object_error?' do
+        context 'for invalid object RPC exceptions' do
+            subject { described_class::InvalidObject.new.rpc_invalid_object_error? }
+            it { should be_true }
+        end
+
+        context 'for other exceptions' do
+            subject { ::Exception.new.rpc_invalid_object_error? }
+            it { should be_false }
+        end
+    end
+
+    describe '#rpc_invalid_method_error?' do
+        context 'for invalid method RPC exceptions' do
+            subject { described_class::InvalidMethod.new.rpc_invalid_method_error? }
+            it { should be_true }
+        end
+
+        context 'for other exceptions' do
+            subject { ::Exception.new.rpc_invalid_method_error? }
+            it { should be_false }
+        end
+    end
+
+    describe '#rpc_invalid_token_error?' do
+        context 'for RPC exceptions' do
+            subject { described_class::InvalidToken.new.rpc_invalid_token_error? }
+            it { should be_true }
+        end
+
+        context 'for other exceptions' do
+            subject { ::Exception.new.rpc_invalid_token_error? }
+            it { should be_false }
+        end
+    end
+
+end

data/spec/toq/message_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class MyMessage < Toq::Message
+    attr_accessor :foo
+    attr_accessor :boo
+
+    def transmit?( attr )
+        attr == :@boo
+    end
+end
+
+describe Toq::Message do
+    let(:options) { { foo: 'foo val', boo: 'boo val' }}
+    subject { MyMessage.new( options ) }
+
+    describe '#initialize' do
+        it 'sets attributes' do
+            subject.foo == options[:foo]
+            subject.boo == options[:boo]
+        end
+    end
+
+    describe '#merge!' do
+        it 'assigns the attribute values of the provided object to self' do
+            opts = { foo: 'my foo' }
+            my_msg = MyMessage.new( opts )
+
+            subject.merge!( my_msg )
+
+            subject.foo == opts[:foo]
+            subject.boo == options[:boo]
+        end
+    end
+
+    describe '#prepare_for_tx' do
+        it 'converts self into a hash' do
+            subject.prepare_for_tx.class.should == Hash
+        end
+
+        it 'skips attributes based on #transmit?' do
+            subject.prepare_for_tx.should include 'boo'
+            subject.prepare_for_tx.should_not include 'callback_id'
+            subject.prepare_for_tx.should_not include 'foo'
+        end
+    end
+
+end