cuboid 0.0.0 → 0.0.1alpha

data/spec/cuboid/support/filter/set_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Filter::Set do
+    it_behaves_like 'filter'
+
+    describe '#merge' do
+        it 'merges 2 sets' do
+            new = described_class.new
+
+            subject << 'test'
+            new     << 'test2'
+
+            subject.merge new
+            expect(subject).to include 'test'
+            expect(subject).to include 'test2'
+        end
+    end
+
+end

data/spec/cuboid/support/glob_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Glob do
+
+    let(:conversions) do
+        {
+            '*'      => /^.*?$/i,
+            'test*'  => /^test.*?$/i,
+            '*test*' => /^.*?test.*?$/i,
+            '*/*'    => /^.*?\/.*?$/i
+        }
+    end
+
+    let(:matches) do
+        [
+            ['*',       '',                 true],
+            ['*',       'stuff',            true],
+
+            ['test*',   'stuff',            false],
+            ['test*',   'teststuff',        true],
+            ['test*',   'tEsTstuff',        true],
+            ['test*',   'stuffteststuff',   false],
+
+            ['*test*',  'stuffteststuff',   true],
+            ['*test*',  'stufftEsTstuff',   true],
+            ['*test*',  'stuff',            false],
+            ['*test*',  'teststuff',        true],
+            ['*test*',  'stufftest',        true],
+
+            ['*/*',     'test',             false],
+            ['*/*',     'test/',            true],
+            ['*/*',     'test/stuff',       true]
+        ]
+    end
+
+    describe '.to_regexp' do
+        it 'converts a glog to a regexp' do
+            conversions.each do |glob, regexp|
+                expect(described_class.to_regexp( glob )).to eq regexp
+            end
+        end
+    end
+
+    describe '#regexp' do
+        it 'returns the glob as a regexp' do
+            conversions.each do |glob, regexp|
+                expect(described_class.new( glob ).regexp).to eq regexp
+            end
+        end
+    end
+
+    describe '#match?' do
+        it 'checks whether or not the glob matches the string' do
+            matches.each do |glob, string, result|
+                expect(described_class.new( glob ).match?( string )).to eq result
+            end
+        end
+    end
+
+    describe '#matches?' do
+        it 'checks whether or not the glob matches the string' do
+            matches.each do |glob, string, result|
+                expect(described_class.new( glob ).matches?( string )).to eq result
+            end
+        end
+    end
+
+    describe '=~' do
+        it 'checks whether or not the glob matches the string' do
+            matches.each do |glob, string, result|
+                expect(described_class.new( glob ) =~ string ).to eq result
+            end
+        end
+    end
+end

data/spec/cuboid/support/mixins/observable_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+class ObservableTest
+    include Cuboid::Support::Mixins::Observable
+
+    public :clear_observers
+
+    advertise :my_event, :my_other_event
+
+    def notify( event, *args )
+        send "notify_#{event}", *args
+    end
+
+end
+
+describe Cuboid::Support::Mixins::Observable do
+
+    subject{ ObservableTest.new }
+
+    describe '#<event>' do
+        it 'adds an observer' do
+            called = false
+            subject.my_event { called = true }
+            subject.notify :my_event
+
+            expect(called).to be_truthy
+        end
+
+        it 'returns self' do
+            expect(subject.my_event { }).to eq(subject)
+        end
+
+        context 'when no block is given' do
+            it 'raises ArgumentError' do
+                expect { subject.my_event }.to raise_error ArgumentError
+            end
+        end
+
+        context 'when the observer expects arguments' do
+            it 'forwards them' do
+                received_args = nil
+                sent_args     = [ 1, 2, 3]
+
+                subject.my_other_event do |one, two, three|
+                    received_args = [one, two, three]
+                end
+                subject.notify :my_other_event, sent_args
+
+                expect(received_args).to eq(sent_args)
+            end
+        end
+
+        describe 'when the event does not exist' do
+            it "raises #{NoMethodError}" do
+                expect { subject.blah_event }.to raise_error NoMethodError
+            end
+        end
+    end
+
+    describe '#notify' do
+        it 'returns nil' do
+            subject.my_event { }
+            expect(subject.notify( :my_event )).to be_nil
+        end
+
+        context 'when a callback raises an exception' do
+            it 'does not affect other callbacks' do
+                called = []
+
+                subject.my_event { called << 1 }
+                subject.my_event { called << 2; raise }
+                subject.my_event { called << 3 }
+
+                subject.notify( :my_event )
+
+                expect(called).to eq([1, 2, 3])
+            end
+        end
+    end
+
+    describe '#clear_observers' do
+        it 'removes all observers' do
+            called = false
+
+            subject.my_event { called = true }
+            subject.clear_observers
+
+            subject.notify :my_event
+
+            expect(called).to be_falsey
+
+        end
+    end
+
+end

data/spec/cuboid/system/platforms/linux_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Cuboid::System::Platforms::Linux do
+    it_should_behave_like 'Cuboid::System::Platforms::Mixins::Unix'
+
+    describe '#memory_free' do
+        it 'returns the amount of free memory' do
+            o = Object.new
+            expect(o).to receive(:available_bytes).and_return(1000)
+            expect(subject).to receive(:memory).at_least(:once).and_return(o)
+
+            expect(subject.memory_free).to eq 1000
+        end
+    end
+
+    describe '.current?' do
+        context 'when running on Linux' do
+            it 'returns true' do
+                expect(Cuboid).to receive(:linux?).and_return( true )
+                expect(described_class).to be_current
+            end
+        end
+
+        context 'when not running on Linux' do
+            it 'returns false' do
+                expect(Cuboid).to receive(:linux?).and_return( false )
+                expect(described_class).to_not be_current
+            end
+        end
+    end
+end

data/spec/cuboid/system/platforms/osx_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Cuboid::System::Platforms::OSX do
+    it_should_behave_like 'Cuboid::System::Platforms::Mixins::Unix'
+
+    describe '#memory_free' do
+        it 'returns the amount of free memory' do
+            o = Object.new
+            expect(o).to receive(:free).and_return(1000)
+            expect(o).to receive(:pagesize).and_return(4096)
+            expect(subject).to receive(:memory).at_least(:once).and_return(o)
+
+            expect(subject.memory_free).to eq 4096000
+        end
+    end
+
+    describe '.current?' do
+        context 'when running on OSX' do
+            it 'returns true' do
+                expect(Cuboid).to receive(:mac?).and_return( true )
+                expect(described_class).to be_current
+            end
+        end
+
+        context 'when not running on OSX' do
+            it 'returns false' do
+                expect(Cuboid).to receive(:mac?).and_return( false )
+                expect(described_class).to_not be_current
+            end
+        end
+    end
+end

data/spec/cuboid/system/platforms/windows_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Cuboid::System::Platforms::Windows, if: Cuboid.windows? do
+    it_should_behave_like 'Cuboid::System::Platforms::Base'
+
+    subject { described_class.new }
+
+    describe '#memory_free' do
+        it 'returns the amount of free memory' do
+            expect(subject.memory_free).to be > 0
+        end
+    end
+
+    describe '#disk_space_free' do
+        it 'returns the amount of free disk space' do
+            expect(subject.disk_space_free).to be > 0
+        end
+    end
+
+    describe '#memory_for_process_group' do
+        it 'returns bytes of memory used by the group' do
+            expect(subject.memory_for_process_group( Process.pid )).to be > 0
+        end
+    end
+
+    describe '.current?' do
+        context 'when running on Windows' do
+            it 'returns true'do
+                expect(Cuboid).to receive(:windows?).and_return( true )
+                expect(described_class).to be_current
+            end
+        end
+
+        context 'when not running on Windows' do
+            it 'returns false' do
+                expect(Cuboid).to receive(:windows?).and_return( false )
+                expect(described_class).to_not be_current
+            end
+        end
+    end
+end

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