arachni-reactor 0.1.0.beta1

data/spec/arachni/reactor/connection_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+require 'spec_helper'
+
+class Handler < Arachni::Reactor::Connection
+    attr_reader :received_data
+    attr_reader :error
+
+    def initialize( options = {} )
+        @options = options
+    end
+
+    def on_close( error )
+        @error = error
+
+        if @options[:on_error]
+            @options[:on_error].call error
+        end
+
+        @reactor.stop
+    end
+
+    def on_read( data )
+        (@received_data ||= '' ) << data
+
+        return if !@options[:on_read]
+        @options[:on_read].call data
+    end
+
+end
+
+describe Arachni::Reactor::Connection do
+    before :all do
+        @host, @port = Servers.start( :echo )
+
+        if Arachni::Reactor.supports_unix_sockets?
+            _, port = Servers.start( :echo_unix )
+            @unix_socket = port_to_socket( port )
+        end
+    end
+
+    let(:unix_socket) { unix_connect( @unix_socket ) }
+    let(:unix_server_socket) { unix_server( port_to_socket( Servers.available_port ) ) }
+
+    let(:echo_client) { tcp_connect( @host, @port ) }
+    let(:echo_client_handler) { EchoClient.new }
+
+    let(:peer_client_socket) { tcp_connect( host, port ) }
+    let(:peer_server_socket) { tcp_server( host, port ) }
+
+    let(:client_socket) { tcp_connect( host, port ) }
+    let(:server_socket) { tcp_server( host, port ) }
+
+    let(:connection) { Handler.new }
+    let(:server_handler) { proc { Handler.new } }
+
+    it_should_behave_like 'Arachni::Reactor::Connection'
+end

data/spec/arachni/reactor/iterator_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe Arachni::Reactor::Iterator do
+
+    def get_iterator
+        described_class.new reactor, list, concurrency
+    end
+
+    def get_reactor
+        Arachni::Reactor.new
+    end
+
+    let(:reactor) { get_reactor }
+    let(:list) { %w(one two three four) }
+    let(:concurrency) { list.size }
+    subject { get_iterator }
+
+    describe '#initialize' do
+        context 'when the list does not respond to #to_a' do
+            let(:list) { 'stuff' }
+
+            it "raises #{ArgumentError}" do
+                expect { subject }.to raise_error ArgumentError
+            end
+        end
+
+        context 'when the concurrency is' do
+            context 0 do
+                let(:concurrency) { 0 }
+
+                it "raises #{ArgumentError}" do
+                    expect { subject }.to raise_error ArgumentError
+                end
+            end
+
+            context 'less than 0' do
+                let(:concurrency) { -1 }
+
+                it "raises #{ArgumentError}" do
+                    expect { subject }.to raise_error ArgumentError
+                end
+            end
+        end
+    end
+
+    describe '#reactor' do
+        it 'returns the associated Reactor' do
+            subject.reactor.should == reactor
+        end
+    end
+
+    describe '#concurrency' do
+        let(:concurrency){ 3 }
+        it 'returns the configured Reactor' do
+            subject.concurrency.should == concurrency
+        end
+    end
+
+    describe '#concurrency=' do
+        it 'sets the iterator concurrency' do
+            runner = proc do |concurrency|
+                start  = nil
+                finish = nil
+
+                iter = described_class.new( get_reactor, list, concurrency )
+                iter.concurrency = concurrency
+
+                iter.reactor.run do
+                    iter.each do |item, iterator|
+                        start ||= Time.now
+
+                        iter.reactor.delay 1 do
+                            if item == list.last
+                                finish = Time.now
+                                iter.reactor.stop
+                            end
+
+                            iterator.next
+                        end
+                    end
+                end
+
+                finish - start
+            end
+
+            high_concurrency = list.size
+            low_concurrency  = 1
+
+            high_concurrency_time, low_concurrency_time =
+                runner.call( high_concurrency ), runner.call( low_concurrency )
+
+            low_concurrency_time.should > high_concurrency_time
+
+            (low_concurrency_time - high_concurrency_time).to_i.should ==
+                high_concurrency - low_concurrency
+        end
+
+        context 'when it is larger than the list size' do
+            let(:concurrency){ 30 }
+
+            it 'does stuff' do
+                iterated = []
+
+                reactor.run do
+                    subject.each do |item, iterator|
+                        iterated << item
+
+                        reactor.delay 1 do
+                            reactor.stop if item == list.last
+                            iterator.next
+                        end
+                    end
+                end
+
+                list.should == iterated
+            end
+        end
+    end
+
+    describe '#each' do
+        it 'iterates over the list' do
+            iterated = []
+
+            reactor.run do
+                subject.each do |item, iterator|
+                    iterated << item
+
+                    reactor.stop if item == list.last
+                    reactor.delay 1 do
+                        iterator.next
+                    end
+                end
+            end
+
+            list.should == iterated
+        end
+
+        context 'when an \'after\' proc has been provided' do
+            it 'is called when the iteration is complete' do
+                iterated = []
+
+                reactor.run do
+                    subject.each(
+                        proc do |item, iterator|
+                            iterated << item
+                            reactor.delay 1 do
+                                iterator.next
+                            end
+                        end,
+                        proc do
+                            reactor.stop
+                        end
+                    )
+                end
+
+                list.should == iterated
+            end
+        end
+    end
+
+    describe '#map' do
+        it 'collects the results of each iteration' do
+            results = nil
+
+            reactor.run do
+                subject.map(
+                    proc do |string, iterator|
+                        reactor.delay 1 do
+                            iterator.return( string.size )
+                        end
+                    end,
+                    proc do |res|
+                        results = res
+                        reactor.stop
+                    end
+                )
+            end
+
+            results.should == list.map(&:size)
+        end
+    end
+
+    describe '#inject' do
+        it 'injects the results of the iteration into the given object' do
+            results = nil
+
+            reactor.run do
+                subject.inject( {},
+                    proc do |hash, string, iterator|
+                        hash.merge!( string => string.size )
+                        iterator.return( hash )
+                    end,
+                    proc do |res|
+                        results = res
+                        reactor.stop
+                    end
+                )
+            end
+
+            results.should == list.inject({}) { |h, string| h.merge( string => string.size ) }
+        end
+    end
+end

data/spec/arachni/reactor/queue_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Arachni::Reactor::Queue do
+    let(:reactor) { Arachni::Reactor.new }
+    subject { described_class.new reactor }
+
+    describe '#initialize' do
+        it 'sets the associated reactor' do
+            subject.reactor.should == reactor
+        end
+    end
+
+    describe '#pop' do
+        context 'when the queue is not empty' do
+            it 'passes the next item to the block' do
+                passed_item = nil
+
+                reactor.run do
+                    subject << :my_item
+                    subject.pop do |item|
+                        passed_item = item
+                        reactor.stop
+                    end
+                end
+
+                passed_item.should == :my_item
+            end
+        end
+
+        context 'when the queue is empty' do
+            it 'assigns a block to handle new items' do
+                passed_item = nil
+
+                reactor.run do
+                    subject.pop do |item|
+                        passed_item = item
+                        reactor.stop
+                    end
+
+                    subject << :my_item
+                end
+
+                passed_item.should == :my_item
+            end
+        end
+    end
+
+    describe '#empty?' do
+        context 'when the queue is empty' do
+            it 'returns true' do
+                subject.should be_empty
+            end
+        end
+
+        context 'when the queue is not empty' do
+            it 'returns false' do
+                reactor.run_block do
+                    subject << nil
+                    subject.should_not be_empty
+                end
+            end
+        end
+    end
+
+    describe '#size' do
+        it 'returns the queue size' do
+            reactor.run_block do
+                2.times { |i| subject << i }
+                subject.size.should == 2
+            end
+        end
+    end
+
+    describe '#num_waiting' do
+        context 'when no jobs are available to handle new items' do
+            it 'returns 0' do
+                subject.num_waiting.should == 0
+            end
+        end
+
+        context 'when there are jobs waiting to handle new items' do
+            it 'returns a count' do
+                reactor.run_block do
+                    3.times { subject.pop{} }
+                    subject.num_waiting.should == 3
+                end
+            end
+        end
+    end
+
+end

data/spec/arachni/reactor/tasks/base.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Arachni::Reactor::Tasks::Base do
+    it_should_behave_like 'Arachni::Reactor::Tasks::Base'
+
+    subject { described_class.new{} }
+end
+

data/spec/arachni/reactor/tasks/delayed_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Arachni::Reactor::Tasks::Delayed do
+    it_should_behave_like 'Arachni::Reactor::Tasks::Base'
+
+    let(:list) { Arachni::Reactor::Tasks.new }
+    let(:interval) { 0.25 }
+    subject { described_class.new( interval ){} }
+
+    describe '#initialize' do
+        context 'when the interval is <= 0' do
+            it "raises #{ArgumentError}" do
+                expect { described_class.new( 0 ){} }.to raise_error ArgumentError
+                expect { described_class.new( -1 ){} }.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#interval' do
+        it 'returns the configured interval' do
+            subject.interval.should == interval
+        end
+    end
+
+    describe '#call' do
+        context 'at the next interval' do
+            it 'calls the task' do
+                called = 0
+                task = described_class.new( interval ) do
+                    called += 1
+                end
+
+                list << task
+
+                time = Time.now
+                task.call while called < 1
+
+                (Time.now - time).round(2).should == 0.25
+            end
+
+            it 'calls #done' do
+                called = 0
+                task = described_class.new( interval ) do
+                    called += 1
+                end
+
+                list << task
+
+                task.should receive(:done)
+                task.call while called < 1
+            end
+        end
+    end
+end

data/spec/arachni/reactor/tasks/one_off_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Arachni::Reactor::Tasks::OneOff do
+    it_should_behave_like 'Arachni::Reactor::Tasks::Base'
+
+    let(:list) { Arachni::Reactor::Tasks.new }
+    subject { described_class.new{} }
+
+    describe '#initialize' do
+        context 'when no task have been given' do
+            it "raises #{ArgumentError}" do
+                expect { described_class.new }.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#call' do
+        it 'calls the given task' do
+            callable = proc {}
+            callable.should receive(:call)
+
+            task = described_class.new(&callable)
+            list << task
+
+            task.call
+        end
+
+        it 'passes the task to it' do
+            callable = proc {}
+            task = described_class.new(&callable)
+
+            callable.should receive(:call).with(task)
+
+            list << task
+
+            task.call
+        end
+
+        it 'calls #done' do
+            callable = proc {}
+            task = described_class.new(&callable)
+
+            callable.should receive(:call).with(task)
+
+            list << task
+
+            task.should receive(:done)
+            task.call
+        end
+    end
+end