toq 0.0.1

data/spec/toq/proxy_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+class Translator < Toq::Proxy
+
+    translate :foo do |response|
+        response.map(&:to_s)
+    end
+
+    translate :delay do |response, arguments|
+        [arguments, response.map(&:to_s)]
+    end
+
+end
+
+describe Toq::Proxy do
+
+    def wait
+        Raktr.global.wait rescue Raktr::Error::NotRunning
+    end
+
+    before(:each) do
+        if Raktr.global.running?
+            Raktr.stop
+        end
+
+        Raktr.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) { Raktr.global }
+    let(:client) { start_client( rpc_opts ) }
+    let(:handler) { 'test' }
+    let(:translator) { Translator.new( client, handler ) }
+    subject do
+        Toq::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
+            Raktr.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
+                        Raktr.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/toq/request_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Toq::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/toq/response_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Toq::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/toq/server_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+class Toq::Server
+    public :async?, :async_check, :object_exist?, :public_method?
+    attr_accessor :proxy
+end
+
+describe Toq::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
+

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: toq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tasos Laskos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: raktr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: |2
+          Toq is a simple and lightweight Remote Procedure Call protocol
+          used to provide the basis for Arachni's distributed infrastructure.
+email: tasos.laskos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.md
+- CHANGELOG.md
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/toq.rb
+- lib/toq/client.rb
+- lib/toq/client/handler.rb
+- lib/toq/exceptions.rb
+- lib/toq/message.rb
+- lib/toq/protocol.rb
+- lib/toq/proxy.rb
+- lib/toq/request.rb
+- lib/toq/response.rb
+- lib/toq/server.rb
+- lib/toq/server/handler.rb
+- lib/toq/version.rb
+- spec/pems/cacert.pem
+- spec/pems/client/cert.pem
+- spec/pems/client/foo-cert.pem
+- spec/pems/client/foo-key.pem
+- spec/pems/client/key.pem
+- spec/pems/server/cert.pem
+- spec/pems/server/key.pem
+- spec/servers/basic.rb
+- spec/servers/server.rb
+- spec/servers/unix_socket.rb
+- spec/servers/with_ssl_primitives.rb
+- spec/spec_helper.rb
+- spec/toq/client_spec.rb
+- spec/toq/exceptions_spec.rb
+- spec/toq/message_spec.rb
+- spec/toq/proxy_spec.rb
+- spec/toq/request_spec.rb
+- spec/toq/response_spec.rb
+- spec/toq/server_spec.rb
+homepage: https://github.com/qadron/toq
+licenses:
+- BSD 3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Simple RPC protocol.
+test_files:
+- spec/pems/server/cert.pem
+- spec/pems/server/key.pem
+- spec/pems/cacert.pem
+- spec/pems/client/foo-key.pem
+- spec/pems/client/cert.pem
+- spec/pems/client/foo-cert.pem
+- spec/pems/client/key.pem
+- spec/servers/with_ssl_primitives.rb
+- spec/servers/unix_socket.rb
+- spec/servers/server.rb
+- spec/servers/basic.rb
+- spec/toq/client_spec.rb
+- spec/toq/server_spec.rb
+- spec/toq/request_spec.rb
+- spec/toq/message_spec.rb
+- spec/toq/response_spec.rb
+- spec/toq/exceptions_spec.rb
+- spec/toq/proxy_spec.rb
+- spec/spec_helper.rb