cuboid 0.0.0 → 0.0.3

data/spec/cuboid/system/slots_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe Cuboid::System::Slots do
+    subject { system.slots }
+    let(:system) { Cuboid::System.instance }
+
+    before :each do
+        subject.reset
+    end
+
+    describe '#available' do
+        context 'when OptionGroups::system#max_slots is set' do
+            before do
+                Cuboid::Options.system.max_slots = 5
+            end
+
+            it 'uses it to calculate available slots' do
+                expect(subject.available).to eq 5
+            end
+
+            context 'when some slots have been used' do
+                it 'subtracts them' do
+                    allow(subject).to receive(:used).and_return( 2 )
+                    expect(subject.available).to eq 3
+                end
+            end
+        end
+
+        context 'when OptionGroups::system#max_slots is not set' do
+            before do
+                Cuboid::Options.system.max_slots = nil
+            end
+
+            it 'uses #available_auto' do
+                expect(subject).to receive(:available_auto).and_return( 25 )
+                expect(subject.available).to eq 25
+            end
+        end
+    end
+
+    describe '#available_auto' do
+        before do
+            Cuboid::Options.system.max_slots = nil
+        end
+
+        it 'calculates slots based on available resources' do
+            expect(subject).to receive(:available_in_memory).and_return( 25 )
+            expect(subject).to receive(:available_in_cpu).and_return( 25 )
+            expect(subject).to receive(:available_in_disk).and_return( 25 )
+
+            expect(subject.available).to eq 25
+        end
+
+        context 'when restricted by memory' do
+            it 'bases the calculation on memory slots' do
+                expect(subject).to receive(:available_in_memory).and_return( 10 )
+                expect(subject).to receive(:available_in_cpu).and_return( 25 )
+                expect(subject).to receive(:available_in_disk).and_return( 20 )
+
+                expect(subject.available).to eq 10
+            end
+        end
+
+        context 'when restricted by CPUs' do
+            it 'bases the calculation on CPU slots' do
+                expect(subject).to receive(:available_in_memory).and_return( 10 )
+                expect(subject).to receive(:available_in_cpu).and_return( 5 )
+                expect(subject).to receive(:available_in_disk).and_return( 20 )
+
+                expect(subject.available).to eq 5
+            end
+        end
+
+        context 'when restricted by disk space' do
+            it 'bases the calculation on disk space' do
+                expect(subject).to receive(:available_in_memory).and_return( 10 )
+                expect(subject).to receive(:available_in_cpu).and_return( 5 )
+                expect(subject).to receive(:available_in_disk).and_return( 4 )
+
+                expect(subject.available).to eq 4
+            end
+        end
+    end
+
+    describe '#used' do
+        it 'returns the amount of active instances' do
+            expect(subject.used).to eq 0
+
+            subject.use Process.pid
+            expect(subject.used).to eq 1
+        end
+
+        context 'when a process dies' do
+            it 'gets removed from the count'
+        end
+    end
+
+    describe '#total' do
+        it 'sums up free and used slots' do
+            expect(subject).to receive(:available).and_return( 3 )
+            expect(subject).to receive(:used).and_return( 5 )
+
+            expect(subject.total).to eq 8
+        end
+    end
+
+    describe '#available_in_memory' do
+        it 'returns amount of free memory slots' do
+            expect(subject).to receive(:unallocated_memory).and_return( subject.memory_size * 2 )
+
+            expect(subject.available_in_memory).to eq 2
+        end
+    end
+
+    describe '#available_in_cpu' do
+        it 'returns amount of free CPUs splots' do
+            expect(system).to receive(:cpu_count).and_return( 12 )
+            expect(subject).to receive(:used).and_return( 5 )
+
+            expect(subject.available_in_cpu).to eq 7
+        end
+    end
+
+    describe '#unallocated_memory' do
+        context 'when there are no scans running' do
+            it 'returns the amount of free memory' do
+                free = subject.memory_size * 2
+
+                expect(system).to receive(:memory_free).and_return( free )
+
+                expect(subject.unallocated_memory).to eq free
+            end
+        end
+
+        context 'when there are scans running' do
+            context 'using part of their allocation' do
+                it 'removes their allocated slots' do
+                    used_allocation = subject.memory_size / 3
+
+                    expect(system).to receive(:memory_free).and_return( subject.memory_size * 2 - used_allocation )
+
+                    subject.use 123
+                    expect(subject).to receive(:remaining_memory_for).with(123).and_return( subject.memory_size - used_allocation )
+
+                    expect(subject.unallocated_memory).to eq subject.memory_size
+                end
+            end
+        end
+    end
+
+    describe '#remaining_memory_for' do
+        it 'returns the amount of allocated memory available to the scan' do
+            expect(system).to receive(:memory_for_process_group).with(123).and_return( subject.memory_size / 3 )
+            expect(subject.remaining_memory_for(123)).to eq( subject.memory_size - subject.memory_size / 3 )
+        end
+    end
+
+    describe '#unallocated_disk_space' do
+        context 'when there are no scans running' do
+            it 'returns the amount of free disk space' do
+                free = subject.disk_space * 2
+
+                expect(system).to receive(:disk_space_free).and_return( free )
+
+                expect(subject.unallocated_disk_space).to eq free
+            end
+        end
+
+        context 'when there are scans running' do
+            context 'using part of their allocation' do
+                it 'removes their allocated slots' do
+                    used_allocation = subject.disk_space / 3
+
+                    expect(system).to receive(:disk_space_free).and_return( subject.disk_space * 2 - used_allocation )
+
+                    subject.use 123
+                    expect(subject).to receive(:remaining_disk_space_for).with(123).and_return( subject.disk_space - used_allocation )
+
+                    expect(subject.unallocated_disk_space.to_i).to eq subject.disk_space.to_i
+                end
+            end
+        end
+    end
+
+    describe '#remaining_disk_space_for' do
+        it 'returns the amount of allocated disk space available to the scan' do
+            expect(system).to receive(:disk_space_for_process).with(123).and_return( subject.disk_space / 3 )
+            expect(subject.remaining_disk_space_for(123)).to eq( subject.disk_space - subject.disk_space / 3 )
+        end
+    end
+
+    describe '#memory_size' do
+        before do
+            Cuboid::Options.reset
+        end
+        let(:memory_size) { subject.memory_size }
+
+        it 'is approx 0.2GB with default options' do
+            expect(memory_size).to eq MockApp.max_memory
+        end
+    end
+end

data/spec/cuboid/system_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Cuboid::System do
+    subject { described_class.instance }
+
+    describe '#utilization' do
+        it 'returns the utilization ratio of the system'
+    end
+
+    describe '#max_utilization?' do
+        context 'when #utilization is 1' do
+            it 'returns true' do
+                expect(subject).to receive(:utilization).and_return( 1 )
+                expect(subject).to be_max_utilization
+            end
+        end
+
+        context 'when #utilization is < 1' do
+            it 'returns false' do
+                expect(subject).to receive(:utilization).and_return( 0.2 )
+                expect(subject).to_not be_max_utilization
+            end
+        end
+    end
+
+    describe '#memory_free' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:memory_free).and_return(10)
+            expect(subject.memory_free).to eq 10
+        end
+    end
+
+    describe '#memory_for_process_group' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:memory_for_process_group).with(123).and_return(10)
+            expect(subject.memory_for_process_group(123)).to eq 10
+        end
+    end
+
+    describe '#disk_space_free' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:disk_space_free).and_return(10)
+            expect(subject.disk_space_free).to eq 10
+        end
+    end
+
+    describe '#disk_space_for_process' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:disk_space_for_process).with(123).and_return(10)
+            expect(subject.disk_space_for_process(123)).to eq 10
+        end
+    end
+
+    describe '#disk_directory' do
+        it "delegates to #platform" do
+            expect(subject.platform).to receive(:disk_directory).and_return('10')
+            expect(subject.disk_directory).to eq '10'
+        end
+    end
+
+    describe '#cpu_count' do
+        it 'delegates to #platform' do
+            expect(subject.platform).to receive(:cpu_count).and_return(10)
+            expect(subject.cpu_count).to eq 10
+        end
+    end
+
+    describe '#platform' do
+        it 'returns the current platform' do
+            platform_stub = Class.new do
+                def self.current?
+                    true
+                end
+            end
+
+            subject.platforms.unshift platform_stub
+
+            expect(subject.platform).to be_instance_of platform_stub
+
+            subject.platforms.delete platform_stub
+        end
+
+        context 'when the platform could not be identified' do
+            it 'raises error' do
+                subject.platforms.each do |platform|
+                    expect(platform).to receive(:current?).and_return(false)
+                end
+
+                expect do
+                    subject.platform
+                end.to raise_error "Unsupported platform: #{RUBY_PLATFORM}"
+            end
+        end
+    end
+
+    describe '#platforms' do
+        it 'returns all supported platforms' do
+            expect(subject.platforms.map(&:to_s).sort).to eq [
+                described_class::Platforms::Linux,
+                described_class::Platforms::OSX,
+                described_class::Platforms::Windows
+            ].map(&:to_s).sort
+        end
+    end
+end

data/spec/cuboid/utilities_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+class Subject
+    include Cuboid::UI::Output
+    include Cuboid::Utilities
+end
+
+describe Cuboid::Utilities do
+
+    subject { Subject.new }
+
+    let(:response) { Factory[:response] }
+    let(:page) { Factory[:page] }
+
+    describe '#caller_name' do
+        it 'returns the filename of the caller' do
+            expect(subject.caller_name).to eq('example')
+        end
+    end
+
+    describe '#caller_path' do
+        it 'returns the filepath of the caller' do
+            expect(subject.caller_path).to eq(Kernel.caller.first.match( /^(.+):\d/ )[1])
+        end
+    end
+
+    describe '#port_available?' do
+        context 'when a port is available' do
+            it 'returns true' do
+                expect(subject.port_available?( 7777 )).to be_truthy
+            end
+        end
+
+        context 'when a port is not available' do
+            it 'returns true' do
+                s = TCPServer.new( "127.0.0.1", 7777 )
+                expect(subject.port_available?( 7777 )).to be_falsey
+                s.close
+            end
+        end
+    end
+
+    describe '#random_seed' do
+        it 'returns a random string' do
+            expect(subject.random_seed).to be_kind_of String
+        end
+    end
+
+    describe '#seconds_to_hms' do
+        it 'converts seconds to HOURS:MINUTES:SECONDS' do
+            expect(subject.seconds_to_hms( 0 )).to eq('00:00:00')
+            expect(subject.seconds_to_hms( 1 )).to eq('00:00:01')
+            expect(subject.seconds_to_hms( 60 )).to eq('00:01:00')
+            expect(subject.seconds_to_hms( 60*60 )).to eq('01:00:00')
+            expect(subject.seconds_to_hms( 60*60 + 60 + 1 )).to eq('01:01:01')
+        end
+    end
+
+    describe '#hms_to_seconds' do
+        it 'converts seconds to HOURS:MINUTES:SECONDS' do
+            expect(subject.hms_to_seconds( '00:00:00' )).to eq(0)
+            expect(subject.hms_to_seconds( '00:00:01' )).to eq(1)
+            expect(subject.hms_to_seconds( '00:01:00' )).to eq(60)
+            expect(subject.hms_to_seconds( '01:00:00' )).to eq(60*60)
+            expect(subject.hms_to_seconds( '01:01:01')).to eq(60 * 60 + 60 + 1)
+        end
+    end
+
+    describe '#exception_jail' do
+        context 'when no error occurs' do
+            it 'returns the return value of the block' do
+                expect(subject.exception_jail { :stuff }).to eq(:stuff)
+            end
+        end
+
+        context "when a #{RuntimeError} occurs" do
+            context 'and raise_exception is' do
+                context 'default' do
+                    it 're-raises the exception' do
+                        expect do
+                            subject.exception_jail { raise }
+                        end.to raise_error RuntimeError
+                    end
+                end
+
+                context 'true' do
+                    it 're-raises the exception' do
+                        expect do
+                            subject.exception_jail( true ) { raise }
+                        end.to raise_error RuntimeError
+                    end
+                end
+
+                context 'false' do
+                    it 'returns nil' do
+                        expect(subject.exception_jail( false ) { raise }).to be_nil
+                    end
+                end
+            end
+        end
+
+        context "when an #{Exception} occurs" do
+            context 'and raise_exception is' do
+                context 'default' do
+                    it 'does not rescue it' do
+                        expect do
+                            subject.exception_jail { raise Exception }
+                        end.to raise_error Exception
+                    end
+                end
+
+                context 'true' do
+                    it 'does not rescue it' do
+                        expect do
+                            subject.exception_jail( true ) { raise Exception }
+                        end.to raise_error Exception
+                    end
+                end
+
+                context 'false' do
+                    it 'does not rescue it' do
+                        expect do
+                            subject.exception_jail( false ) { raise Exception }
+                        end.to raise_error Exception
+                    end
+                end
+            end
+        end
+    end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+require 'rack/test'
+# require 'simplecov'
+require 'faker'
+
+require 'typhoeus'
+require_relative '../lib/cuboid'
+require_relative '../lib/cuboid/processes'
+require_relative '../lib/cuboid/processes/helpers'
+
+require_relative 'support/helpers/paths'
+require_relative 'support/helpers/requires'
+
+Dir.glob( "#{support_path}/{lib,helpers,shared,factories}/**/*.rb" ).each { |f| require f }
+
+# Uncomment to show output from spawned processes.
+Cuboid::Processes::Manager.preserve_output
+
+RSpec::Core::MemoizedHelpers.module_eval do
+    alias to should
+    alias to_not should_not
+end
+
+RSpec.configure do |config|
+    config.example_status_persistence_file_path = '.rspec_status'
+    config.run_all_when_everything_filtered = true
+    config.color = true
+    config.add_formatter :documentation
+    config.alias_example_to :expect_it
+    config.filter_run_when_matching focus: true
+
+    config.mock_with :rspec do |mocks|
+        mocks.yield_receiver_to_any_instance_implementation_blocks = true
+    end
+
+    config.before( :each ) do
+        reset_all
+    end
+
+    config.after( :each ) do
+        cleanup_instances
+        processes_killall
+    end
+    config.after( :all ) do
+        killall
+    end
+end

data/spec/support/factories/scan_report.rb

@@ -0,0 +1,18 @@
+Factory.define :report_data do
+
+    {
+        application: MockApp,
+        seed:     Cuboid::Utilities.random_seed,
+        options:  Cuboid::Options.to_hash,
+        start_datetime:  Time.now - 10_000,
+        finish_datetime: Time.now
+    }
+end
+
+Factory.define :report do
+    Cuboid::Report.new Factory[:report_data]
+end
+
+Factory.define :report_empty do
+    Cuboid::Report.new
+end

data/spec/support/fixtures/executables/node.rb

@@ -0,0 +1,50 @@
+require Options.paths.lib + 'ui/output'
+require Options.paths.lib + 'rpc/server/dispatcher'
+require Options.paths.lib + 'processes/manager'
+
+class Node < Cuboid::RPC::Server::Dispatcher::Node
+
+    def initialize
+        @options = Options.instance
+
+        methods.each do |m|
+            next if method( m ).owner != Cuboid::RPC::Server::Dispatcher::Node
+            self.class.send :private, m
+            self.class.send :public, m
+        end
+
+        @server = Cuboid::RPC::Server::Base.new
+        @server.add_async_check do |method|
+            # methods that expect a block are async
+            method.parameters.flatten.include?( :block )
+        end
+        @server.add_handler( 'node', self )
+
+        super @options, @server
+
+        @server.start
+    end
+
+    def url
+        @server.url
+    end
+
+    def shutdown
+        Arachni::Reactor.global.delay 1 do
+            Process.kill( 'KILL', Process.pid )
+        end
+    end
+
+    def connect_to_peer( url )
+        self.class.connect_to_peer( url )
+    end
+
+    def self.connect_to_peer( url )
+        c = Cuboid::RPC::Client::Base.new( url )
+        Arachni::RPC::Proxy.new( c, 'node' )
+    end
+end
+
+Arachni::Reactor.global.run do
+    Node.new
+end

data/spec/support/fixtures/mock_app/test_service.rb

@@ -0,0 +1,64 @@
+require 'cuboid/rpc/server/dispatcher'
+
+class TestService < Cuboid::RPC::Server::Dispatcher::Service
+
+    private :instances
+    public  :instances
+
+    def test_dispatcher
+        dispatcher.class == Cuboid::RPC::Server::Dispatcher
+    end
+
+    def test_opts
+        dispatcher.instance_eval{ @options } == options
+    end
+
+    def test_node
+        node.class == Cuboid::RPC::Server::Dispatcher::Node
+    end
+
+    def test_map_instances( &block )
+        each = proc do |instance, iterator|
+            iterator.return [instance.url, instance.token]
+        end
+        after = proc { |i| block.call Hash[i] }
+
+        map_instances( each, after )
+    end
+
+    def test_each_instance
+        i = 0
+        each_instance do |instance, iterator|
+            i += 1
+            instance.options.set( authorized_by: "test_#{i}@test.com") { |p| iterator.next }
+        end
+        true
+    end
+
+    def test_iterator_for
+        iterator_for( instances ).class == Arachni::Reactor::Iterator
+    end
+
+    def test_connect_to_dispatcher( url, &block )
+        connect_to_dispatcher( url ).alive? { |b| block.call b }
+    end
+
+    def test_connect_to_instance( *args, &block )
+        connect_to_instance( *args ).busy?{ |b| block.call !!b }
+    end
+
+    def test_defer( *args, &block )
+        defer do
+            block.call args
+        end
+    end
+
+    def test_run_asap( *args, &block )
+        run_asap { block.call args }
+    end
+
+    def echo( *args )
+        args
+    end
+
+end

data/spec/support/fixtures/mock_app.rb

@@ -0,0 +1,61 @@
+require_relative 'mock_app/test_service'
+
+class MockApp < Cuboid::Application
+
+    # This app is going to be using a max of 2 threads.
+    provision_cores  2
+    # This app is going to be using a max of 200MB of RAM.
+    provision_memory 200 * 1024 * 1024
+    # This app is going to be using a max of 2GB of disk space.
+    provision_disk   2   * 1024 * 1024 * 1024
+
+    validate_options_with :do_validate_options
+
+    # Register event handlers.
+    handler_for :pause,   :do_pause
+    handler_for :resume,  :do_resume
+    handler_for :suspend, :do_suspend
+    handler_for :restore, :do_restore
+    handler_for :abort,   :do_abort
+
+    # RPC, report and snapshot file.
+    serialize_with Marshal
+
+    dispatcher_service_for :test_service, TestService
+
+    # Execution entry point.
+    def run
+        ap __method__
+        report 'My results.'
+
+        sleep 5
+    end
+
+    def do_validate_options( options )
+        return true if !options.is_a?( Hash )
+        !options.include?( 'invalid' )
+    end
+
+    def do_pause
+        ap __method__
+    end
+
+    def do_resume
+        ap __method__
+    end
+
+    def do_suspend
+        # Write pending state and data to Cuboid::Data::Application.
+        ap __method__
+    end
+
+    def do_restore
+        # Restore special state and data from Cuboid::Data::Application.
+        ap __method__
+    end
+
+    def do_abort
+        ap __method__
+    end
+
+end