arachni-rpc 0.1.3 → 0.2.0

data/spec/arachni/rpc/exceptions_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Arachni::RPC::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/arachni/rpc/message_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+class MyMessage < Arachni::RPC::Message
+    attr_accessor :foo
+    attr_accessor :boo
+
+    def transmit?( attr )
+        attr == :@boo
+    end
+end
+
+describe Arachni::RPC::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

data/spec/arachni/rpc/proxy_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class Translator < Arachni::RPC::Proxy
+
+    translate :foo do |response|
+        response.map(&:to_s)
+    end
+
+    translate :delay do |response, arguments|
+        [arguments, response.map(&:to_s)]
+    end
+
+end
+
+describe Arachni::RPC::Proxy do
+
+    def wait
+        Arachni::Reactor.global.wait rescue Arachni::Reactor::Error::NotRunning
+    end
+
+    before(:each) do
+        if Arachni::Reactor.global.running?
+            Arachni::Reactor.stop
+        end
+
+        Arachni::Reactor.global.run_in_thread
+    end
+
+    let(:translated_arguments) do
+        arguments.map(&:to_s)
+    end
+    let(:arguments) do
+        [
+            'one',
+            2,
+            { three: 3 },
+            [ 4 ]
+        ]
+    end
+    let(:reactor) { Arachni::Reactor.global }
+    let(:client) { start_client( rpc_opts ) }
+    let(:handler) { 'test' }
+    let(:translator) { Translator.new( client, handler ) }
+    subject do
+        Arachni::RPC::Proxy.new( client, handler )
+    end
+
+    it 'forwards synchronous calls' do
+        subject.foo( arguments ).should == arguments
+    end
+
+    it 'forwards synchronous calls' do
+        response = nil
+        subject.foo( arguments ) do |res|
+            response = res
+            Arachni::Reactor.stop
+        end
+        wait
+
+        response.should == arguments
+    end
+
+    describe '.translate' do
+        context 'when a synchronous call' do
+            context 'does not return an exception' do
+                it 'returns the translated result' do
+                    translator.foo( arguments ).should == translated_arguments
+                end
+            end
+
+            context 'returns an exception' do
+                it 'returns the exception'
+            end
+        end
+
+        context 'when an asynchronous call' do
+            context 'does not result in an exception' do
+                it 'calls the block with the translated result' do
+                    response = nil
+                    translator.foo( arguments ) do |res|
+                        response = res
+                        Arachni::Reactor.stop
+                    end
+                    wait
+
+                    response.should == translated_arguments
+                end
+            end
+
+            context 'results in an exception' do
+                it 'calls the block with the exception'
+            end
+        end
+
+        it 'passes the method arguments to the translator' do
+            translator.delay( arguments ).should == [arguments, translated_arguments]
+        end
+    end
+end

data/spec/arachni/rpc/request_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Arachni::RPC::Request do
+    subject { described_class.new }
+
+    describe '#message' do
+        it 'should be an accessor' do
+            subject.message = 'test'
+            subject.message.should == 'test'
+        end
+    end
+
+    describe '#args' do
+        it 'should be an accessor' do
+            subject.args = %w(test)
+            subject.args.should == %w(test)
+        end
+    end
+
+    describe '#token' do
+        it 'should be an accessor' do
+            subject.token = 'blah'
+            subject.token.should == 'blah'
+        end
+    end
+
+    describe '#callback' do
+        it 'should be an accessor' do
+            called = false
+            subject.callback = proc { called = true }
+            subject.callback.call
+            called.should be_true
+        end
+    end
+
+    describe '#prepare_for_tx' do
+        it 'should convert the request to a hash ready for transmission' do
+            subject.prepare_for_tx.should be_empty
+
+            described_class.new(
+                message:  'obj.method',
+                args:     %w(test),
+                token:    'mytoken',
+                callback: proc{}
+            ).prepare_for_tx.should =={
+                'args'    => %w(test),
+                'message' => 'obj.method',
+                'token'   => 'mytoken'
+            }
+        end
+    end
+
+end

data/spec/arachni/rpc/response_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Arachni::RPC::Response do
+    subject { described_class.new }
+
+    describe '#obj' do
+        it 'should be an accessor' do
+            subject.obj = 'test'
+            subject.obj.should == 'test'
+        end
+    end
+
+    describe '#exception' do
+        it 'should be an accessor' do
+            subject.exception = 'test'
+            subject.exception.should == 'test'
+        end
+    end
+
+    describe '#exception?' do
+        context 'when #exception is not set' do
+            it 'returns false' do
+                subject.exception?.should be_false
+            end
+        end
+
+        context 'when #exception is set' do
+            it 'returns true' do
+                subject.exception = 'stuff'
+                subject.exception?.should be_true
+            end
+        end
+    end
+
+    describe '#async?' do
+        context 'by default' do
+            it 'should return false' do
+                subject.async?.should be_false
+            end
+        end
+
+        context 'after #async!' do
+            it 'should return false' do
+                subject.async!
+                subject.async?.should be_true
+            end
+        end
+    end
+end

data/spec/arachni/rpc/server_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+class Arachni::RPC::Server
+    public :async?, :async_check, :object_exist?, :public_method?
+    attr_accessor :proxy
+end
+
+describe Arachni::RPC::Server do
+    let(:options) { rpc_opts.merge( port: 7333 ) }
+    subject { start_server( options, true ) }
+
+    describe '#initialize' do
+        it 'should be able to properly setup class options' 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
+
+        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
+
+    it 'retains the supplied token' do
+        subject.token.should == options[:token]
+    end
+
+    it 'has a Logger' do
+        subject.logger.class.should == ::Logger
+    end
+
+    describe '#alive?' do
+        it 'returns true' do
+            subject.should be_alive
+        end
+    end
+
+    describe '#async?' do
+        context 'when a method is async' do
+            it 'returns true' do
+                subject.async?( 'test', 'delay' ).should be_true
+            end
+        end
+
+        context 'when a method is sync' do
+            it 'returns false' do
+                subject.async?( 'test', 'foo' ).should be_false
+            end
+        end
+    end
+
+    describe '#async_check' do
+        context 'when a method is async' do
+            it 'returns true' do
+                subject.async_check( Test.new.method( :delay ) ).should be_true
+            end
+        end
+
+        context 'when a method is sync' do
+            it 'returns false' do
+                subject.async_check( Test.new.method( :foo ) ).should be_false
+            end
+        end
+    end
+
+    describe '#object_exist?' do
+        context 'when an object exists' do
+            it 'returns true' do
+                subject.object_exist?( 'test' ).should be_true
+            end
+        end
+
+        context 'when an object does not exist' do
+            it 'returns false' do
+                subject.object_exist?( 'foo' ).should be_false
+            end
+        end
+    end
+
+    describe '#public_method?' do
+        context 'when a method is public' do
+            it 'returns true' do
+                subject.public_method?( 'test', 'foo' ).should be_true
+            end
+        end
+
+        context 'when a method is non-existent or not public' do
+            it 'returns false' do
+                subject.public_method?( 'test', 'bar' ).should be_false
+            end
+        end
+    end
+
+end
+