cuboid 0.0.0 → 0.0.3

data/spec/cuboid/rpc/server/scheduler_spec.rb

@@ -0,0 +1,400 @@
+require 'spec_helper'
+
+require "#{Cuboid::Options.paths.lib}/rpc/server/scheduler"
+
+describe Cuboid::RPC::Server::Scheduler do
+    before( :each ) do
+        Cuboid::Options.system.max_slots        = 10
+        Cuboid::Options.scheduler.ping_interval = 0.5
+    end
+
+    subject { scheduler_spawn( application: "#{fixtures_path}/mock_app.rb" ) }
+    let(:options) { {} }
+
+    context 'when there are queued scans' do
+        it 'performs them' do
+            expect(subject.completed).to be_empty
+
+            ids = []
+            3.times do
+                ids << subject.push( options )
+            end
+
+            sleep 1 while subject.completed.size != 3
+
+            expect(subject.completed.keys.sort).to eq ids.sort
+
+            subject.completed.values.each do |report|
+                expect do
+                    Cuboid::Report.load( report )
+                end.to_not raise_error
+            end
+        end
+
+        it 'stores the reports' do
+            subject.push( options )
+            sleep 0.1 while subject.completed.empty?
+
+            expect(subject.completed.values.first).to start_with Cuboid::Options.paths.reports
+        end
+
+        it 'shuts down the Instance' do
+            subject.push( options )
+            sleep 0.1 while subject.running.empty?
+
+            pid = subject.running.values.first['pid']
+            expect(Cuboid::Processes::Manager.alive?( pid )).to be true
+
+            sleep 0.1 while subject.completed.empty?
+            sleep 2
+
+            expect(Cuboid::Processes::Manager.alive?( pid )).to be false
+        end
+    end
+
+    context 'when a Dispatcher has been set' do
+        subject { Cuboid::Processes::Schedulers.spawn dispatcher: dispatcher.url }
+        let(:dispatcher) do
+            Cuboid::Processes::Dispatchers.spawn( application: "#{fixtures_path}/mock_app.rb" )
+        end
+
+        it 'gets Instances from it' do
+            expect(dispatcher.finished_instances).to be_empty
+
+            subject.push( options )
+            sleep 0.1 while subject.completed.empty?
+            sleep 2
+
+            expect(dispatcher.finished_instances).to be_any
+        end
+
+        it 'sets OptionGroups::Scheduler#url' do
+            id = subject.push( options )
+            sleep 0.1 while subject.running.empty?
+
+            info = subject.running[id]
+            expect(instance_connect( info['url'], info['token'] ).scheduler_url).to eq subject.url
+        end
+
+        context 'but becomes unavailable' do
+            it 'does not consume the queue' do
+                subject
+
+                Cuboid::Processes::Dispatchers.killall
+                sleep 3
+
+                expect(subject.size).to be 0
+
+                subject.push( options )
+                sleep 5
+
+                expect(subject.size).to be 1
+                expect(subject.errors.join("\n")).to include "Failed to contact Dispatcher at: #{dispatcher.url}"
+            end
+        end
+    end
+
+    describe '#alive?' do
+        it 'returns true' do
+            expect(subject.alive?).to be_truthy
+        end
+    end
+
+    describe '#empty?' do
+        context 'when the queue is empty' do
+            it 'returns true' do
+                expect(subject.empty?).to be_truthy
+            end
+        end
+
+        context 'when the queue is not empty' do
+            it 'returns true' do
+                subject.push( options )
+                expect(subject.empty?).to be_falsey
+            end
+        end
+    end
+
+    describe '#any?' do
+        context 'when the queue is empty' do
+            it 'returns false' do
+                expect(subject.any?).to_not be_truthy
+            end
+        end
+
+        context 'when the queue is not empty' do
+            it 'returns true' do
+                subject.push( options )
+                expect(subject.any?).to be_truthy
+            end
+        end
+    end
+
+    describe '#size' do
+        it 'returns the queue size' do
+            expect(subject.size).to be 0
+            subject.push( options )
+            expect(subject.size).to be 1
+        end
+    end
+
+    describe '#list' do
+        it 'returns the queue entries grouped and sorted by priority' do
+            medium = subject.push( options, priority: 0 )
+            low    = subject.push( options, priority: -1 )
+            high   = subject.push( options, priority: 1 )
+
+            expect(subject.list).to eq(
+                1  => [high],
+                0  => [medium],
+                -1 => [low],
+            )
+        end
+    end
+
+    describe '#running' do
+        it 'returns running scans' do
+            expect(subject.running).to be_empty
+
+            ids = []
+            3.times do
+                ids << subject.push( options )
+            end
+            sleep 0.1 while subject.running.empty?
+
+            expect(subject.running.keys & ids).to be_any
+            expect(subject.running.values.first).to include 'url'
+            expect(subject.running.values.first).to include 'token'
+            expect(subject.running.values.first).to include 'pid'
+        end
+    end
+
+    describe '#detach' do
+        it 'detaches a running scan' do
+            id = subject.push( options )
+            sleep 0.1 while subject.running.empty?
+
+            info = subject.detach( id )
+
+            expect(info.keys.sort).to eq %w(url token pid).sort
+
+            client = instance_connect( info['url'], info['token'] )
+
+            expect(subject.running).to be_empty
+
+            sleep 0.1 while client.busy?
+            client.shutdown
+            sleep 2
+
+            expect(subject.completed).to be_empty
+            expect(subject.failed).to be_empty
+        end
+
+        it 'removes OptionGroups::Scheduler#url' do
+            id = subject.push( options )
+            sleep 0.1 while subject.running.empty?
+
+            info   = subject.detach( id )
+            client = instance_connect( info['url'], info['token'] )
+
+            expect(client.scheduler_url).to be_nil
+        end
+
+        context 'when no scan with that ID is found' do
+            it 'returns nil' do
+                subject.push( options )
+                sleep 0.1 while subject.running.empty?
+
+                expect(subject.detach( 'id' )).to be_nil
+            end
+        end
+    end
+
+    describe '#attach' do
+        let(:client) { instance_spawn( application: "#{fixtures_path}/mock_app.rb" ) }
+
+        it 'attaches a running Instance to the queue' do
+            expect(subject.attach( client.url, client.token )).to eq client.token
+
+            id = client.token
+            expect(subject.running).to eq(
+                id => {
+                    'url'   => client.url,
+                    'token' => client.token,
+                    'pid'   => nil
+                }
+            )
+
+            client.run( options )
+            sleep 0.1 while subject.completed.empty?
+
+            expect(subject.completed.keys).to eq [id]
+        end
+
+        it 'sets OptionGroups::Scheduler#url' do
+            expect(client.scheduler_url).to be_nil
+
+            subject.attach( client.url, client.token )
+
+            client.run( options )
+            sleep 0.1 while subject.running.empty?
+
+            expect(client.scheduler_url).to eq subject.url
+        end
+
+        context 'when the Instance is already attached to a Scheduler' do
+            it 'returns false' do
+                expect(client.scheduler_url).to be_nil
+
+                subject.attach( client.url, client.token )
+                expect(client.scheduler_url).to eq subject.url
+
+                q = scheduler_spawn
+
+                expect(q.attach( client.url, client.token )).to be_falsey
+                expect(client.scheduler_url).to eq subject.url
+            end
+        end
+
+        context 'when the Instance could not be accessed' do
+            it 'returns nil' do
+                expect(subject.attach( '127.0.0.1:3333', 'fdfdfd' )).to be_nil
+            end
+        end
+    end
+
+    describe '#completed' do
+        it 'returns completed scans' do
+            expect(subject.completed).to be_empty
+
+            ids = []
+            3.times do
+                ids << subject.push( options )
+            end
+            sleep 0.1 while subject.completed.size != 3
+
+            expect(subject.completed.keys.sort).to eq ids.sort
+
+            subject.completed.values.each do |report|
+                expect do
+                    Cuboid::Report.load( report )
+                end.to_not raise_error
+            end
+        end
+    end
+
+    describe '#failed' do
+        it 'returns failed scans' do
+            expect(subject.completed).to be_empty
+
+            id = subject.push( options )
+            sleep 0.1 while subject.running.empty?
+
+            process_kill( subject.running.values.first['pid'] )
+            sleep 0.1 while subject.failed.empty?
+
+            expect(subject.failed[id]['error']).to eq 'Arachni::RPC::Exceptions::ConnectionError'
+            expect(subject.failed[id]['description']).to include 'Connection closed'
+        end
+    end
+
+    describe '#get' do
+        it "returns a queued scan's info" do
+            info = subject.get( subject.push( options ) )
+            expect(info).to eq(
+                'options' => options,
+                'priority' => 0
+            )
+        end
+
+        context 'when no scan matching the ID is queued' do
+            it 'returns nil' do
+                expect(subject.get( '1' )).to be_nil
+            end
+        end
+    end
+
+    describe '#push' do
+        it 'queues a scan' do
+            subject.push( options )
+            expect(subject.any?).to be_truthy
+        end
+
+        it 'returns an ID' do
+            id = subject.push( options )
+            expect(subject.get( id )).to be_truthy
+        end
+
+        it 'sets OptionGroups::Scheduler#url' do
+            id  = subject.push( options )
+            sleep 0.1 while subject.running.empty?
+
+            info   = subject.running[id]
+            client = instance_connect( info['url'], info['token'] )
+
+            expect(client.scheduler_url).to eq subject.url
+        end
+
+        context 'on invalid options' do
+            it 'raises ArgumentError' do
+                expect do
+                    subject.push invalid: :test
+                end.to raise_error Arachni::RPC::Exceptions::RemoteException
+            end
+        end
+
+        context 'when no priority is specified' do
+            it 'uses 0' do
+                id = subject.push( options )
+                expect(subject.get( id )['priority']).to be 0
+            end
+        end
+
+        context 'when priority is specified' do
+            it 'uses it' do
+                id = subject.push( options, priority: 1 )
+                expect(subject.get( id )['priority']).to be 1
+            end
+        end
+    end
+
+    describe '#remove' do
+        it 'removes a scan from the queue' do
+            id = subject.push( options )
+            expect(subject.remove( id )).to be true
+        end
+
+        context 'when the scan does not exist' do
+            it 'returns false' do
+                expect(subject.remove( 'id' )).to be false
+            end
+        end
+    end
+
+    describe '#clear' do
+        it 'clears the queue' do
+            expect(subject.empty?).to be_truthy
+
+            10.times do
+                subject.push( options )
+            end
+
+            expect(subject.any?).to be_truthy
+
+            subject.clear
+
+            expect(subject.empty?).to be_truthy
+        end
+    end
+
+    describe '#shutdown' do
+        it 'shuts down the server' do
+            subject.shutdown
+            sleep 2
+
+            expect do
+                subject.alive?
+            end.to raise_error Arachni::RPC::Exceptions::ConnectionError
+        end
+    end
+end

data/spec/cuboid/ruby/array_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Array do
+    subject do
+        arr = described_class.new
+        50.times { |i| arr << i }
+        arr
+    end
+
+    describe '#includes_tag?' do
+        context 'when passed' do
+            context 'nil' do
+                it 'returns false' do
+                    expect(subject.includes_tags?( nil )).to eq(false)
+                end
+            end
+
+            context '[]' do
+                it 'returns false' do
+                    expect(subject.includes_tags?( [] )).to eq(false)
+                end
+            end
+
+            context 'String' do
+                context 'when includes the given tag (as either a String or a Symbol)' do
+                    it 'returns true' do
+                        expect([ 1 ].includes_tags?( 1 )).to eq(true)
+                        expect([ :tag ].includes_tags?( :tag )).to eq(true)
+                        expect([ :tag ].includes_tags?( 'tag' )).to eq(true)
+                        expect(%w(tag).includes_tags?( 'tag' )).to eq(true)
+                        expect(%w(tag).includes_tags?( :tag )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( :tag )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( 'tag' )).to eq(true)
+                    end
+                end
+                context 'when it does not includes the given tag (as either a String or a Symbol)' do
+                    it 'returns false' do
+                        expect([ 1 ].includes_tags?( 2 )).to eq(false)
+                        expect([ :tag ].includes_tags?( :tag1 )).to eq(false)
+                        expect([ :tag ].includes_tags?( 'tag2' )).to eq(false)
+                        expect(%w(tag).includes_tags?( 'tag3' )).to eq(false)
+                        expect(%w(tag).includes_tags?( :tag5 )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( :ta5g )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( 'ta4g' )).to eq(false)
+                        expect([ :t3ag, 'tag1' ].includes_tags?( 'tag' )).to eq(false)
+                    end
+                end
+            end
+
+            context 'Array' do
+                context 'when includes any of the given tags (as either a String or a Symbol)' do
+                    it 'returns true' do
+                        expect([ 1, 2, 3 ].includes_tags?( [1] )).to eq(true)
+                        expect([ :tag ].includes_tags?( [:tag] )).to eq(true)
+                        expect([ :tag ].includes_tags?( ['tag', 12] )).to eq(true)
+                        expect(%w(tag).includes_tags?( ['tag', nil] )).to eq(true)
+                        expect(%w(tag).includes_tags?( [:tag] )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( [:tag] )).to eq(true)
+                        expect([ :tag, 'tag' ].includes_tags?( ['tag', :blah] )).to eq(true)
+                    end
+                end
+                context 'when it does not include any of the given tags (as either a String or a Symbol)' do
+                    it 'returns true' do
+                        expect([ 1, 2, 3 ].includes_tags?( [4, 5] )).to eq(false)
+                        expect([ :tag ].includes_tags?( [:ta3g] )).to eq(false)
+                        expect([ :tag ].includes_tags?( ['ta3g', 12] )).to eq(false)
+                        expect(%w(tag).includes_tags?( ['ta3g', nil] )).to eq(false)
+                        expect(%w(tag).includes_tags?( [:t4ag] )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( [:t3ag] )).to eq(false)
+                        expect([ :tag, 'tag' ].includes_tags?( ['t2ag', :b3lah] )).to eq(false)
+                    end
+                end
+            end
+        end
+    end
+
+end

data/spec/cuboid/ruby/hash_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Hash do
+    let( :with_symbols ) do
+        {
+            stuff: 'blah',
+            more: {
+                stuff: {
+                    blah: 'stuff'
+                }
+            }
+        }
+    end
+
+    let( :with_strings ) do
+        {
+            'stuff' => 'blah',
+            'more'  => {
+                'stuff' => {
+                    'blah' => 'stuff'
+                }
+            }
+        }
+    end
+
+    describe '#my_stringify_keys' do
+        it 'recursively converts keys to strings' do
+            expect(with_symbols.my_stringify_keys).to eq(with_strings)
+        end
+
+        context 'when the recursive is set to false' do
+            it 'only converts the keys at depth 1' do
+                expect(with_symbols.my_stringify_keys( false )).to eq({
+                    'stuff' => 'blah',
+                    'more'  => {
+                        stuff: {
+                            blah: 'stuff'
+                        }
+                    }
+                })
+            end
+        end
+    end
+
+    describe '#my_symbolize_keys' do
+        it 'recursively converts keys to symbols' do
+            expect(with_strings.my_symbolize_keys).to eq(with_symbols)
+        end
+
+        context 'when the recursive is set to false' do
+            it 'only converts the keys at depth 1' do
+                expect(with_strings.my_symbolize_keys( false )).to eq({
+                    stuff: 'blah',
+                    more:  {
+                        'stuff' => {
+                            'blah' => 'stuff'
+                        }
+                    }
+                })
+            end
+        end
+    end
+end

data/spec/cuboid/ruby/object_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+class Empty
+end
+
+class MyClass
+    attr_accessor :stuff
+end
+
+describe Object do
+
+    describe '#deep_clone' do
+        it 'returns a deep copy of the object' do
+            a = [ [1,2] ]
+            b = a.deep_clone
+            a[0] << 3
+
+            expect(b).to eq([ [1,2] ])
+        end
+    end
+
+end

data/spec/cuboid/snapshot_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Cuboid::Snapshot do
+
+    subject { described_class }
+    let(:dump_archive) do
+        "#{Cuboid::Options.paths.tmpdir}/snapshot-#{Cuboid::Utilities.generate_token}.#{described_class::EXTENSION}"
+    end
+
+    describe '.summary' do
+        let(:summary) { subject.summary }
+
+        it 'includes :data' do
+            expect(summary[:data]).to eq(Cuboid::Data.statistics)
+        end
+
+        it 'includes :state' do
+            expect(summary[:state]).to eq(Cuboid::State.statistics)
+        end
+    end
+
+    describe '.metadata' do
+        context 'when dealing with a restored snapshot' do
+            it 'returns the stored metadata from the snapshot archive' do
+                subject.dump( dump_archive )
+                subject.load( dump_archive )
+
+                expect(subject.metadata).to eq(subject.read_metadata( dump_archive ))
+            end
+        end
+
+        context 'when not dealing with a restored snapshot' do
+            it 'returns nil' do
+                expect(subject.metadata).to be_nil
+            end
+        end
+    end
+
+    describe '.restored?' do
+        context 'when dealing with a restored snapshot' do
+            it 'returns true' do
+                subject.dump( dump_archive )
+                subject.load( dump_archive )
+
+                expect(subject).to be_restored
+            end
+        end
+
+        context 'when not dealing with a restored snapshot' do
+            it 'returns false' do
+                expect(subject).not_to be_restored
+            end
+        end
+    end
+
+    describe '.location' do
+        context 'when dealing with a restored snapshot' do
+            it 'returns the location of the loaded snapshot' do
+                subject.dump( dump_archive )
+                subject.load( dump_archive )
+
+                expect(subject.location).to eq(dump_archive)
+            end
+        end
+
+        context 'when not dealing with a restored snapshot' do
+            it 'returns nil' do
+                expect(subject.location).to be_nil
+            end
+        end
+    end
+
+    describe '.read_metadata' do
+        let(:metadata) do
+            subject.dump( dump_archive )
+            subject.read_metadata( dump_archive )
+        end
+
+        it 'includes a :timestamp' do
+            expect(metadata[:timestamp]).to be_kind_of Time
+        end
+
+        it 'includes a :version' do
+            expect(metadata[:version]).to eq(Cuboid::VERSION)
+        end
+
+        it 'includes a #summary' do
+            expect(metadata[:summary]).to eq(subject.summary)
+        end
+
+        context 'when trying to read an invalid file' do
+            it "raises #{described_class::Error::InvalidFile}" do
+                expect { subject.read_metadata( __FILE__ ) }.to raise_error described_class::Error::InvalidFile
+            end
+        end
+    end
+
+    describe '.dump' do
+        it "stores #{Cuboid::State} to disk" do
+            expect(Cuboid::State).to receive(:dump)
+            expect(Cuboid::Data).to receive(:dump)
+
+            subject.dump( dump_archive )
+        end
+    end
+
+    describe '.load' do
+        it "stores #{Cuboid::State} to disk" do
+            subject.dump( dump_archive )
+
+            expect(Cuboid::State).to receive(:load)
+            expect(Cuboid::Data).to receive(:load)
+
+            subject.load( dump_archive )
+        end
+
+        context 'when trying to load an invalid file' do
+            it "raises #{described_class::Error::InvalidFile}" do
+                expect { subject.load( __FILE__ ) }.to raise_error described_class::Error::InvalidFile
+            end
+        end
+    end
+end