cuboid 0.0.0 → 0.0.3

data/spec/cuboid/support/database/scheduler_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Database::Queue do
+
+    subject { described_class.new }
+    let(:sample_size) { 2 * subject.max_buffer_size }
+
+    it 'maintains stability and consistency under load' do
+        subject
+
+        entries = 1000
+        poped   = Queue.new
+        t       = []
+
+        10.times do
+            t << Thread.new do
+                loop do
+                    poped << subject.pop
+                end
+            end
+        end
+
+        entries.times do |i|
+            subject << 'a' * i
+        end
+
+        sleep 0.1 while !subject.empty?
+
+        consumed = []
+        consumed << poped.pop while !poped.empty?
+
+        expect(consumed.sort).to eq((0...entries).map { |i| 'a' * i })
+    end
+
+    describe "#{described_class}::DEFAULT_MAX_BUFFER_SIZE" do
+        it 'returns 100' do
+            expect(described_class::DEFAULT_MAX_BUFFER_SIZE).to eq(100)
+        end
+    end
+
+    describe '#initialize' do
+        describe ':max_buffer_size' do
+            it 'sets #max_buffer_size' do
+                expect(
+                    described_class.new( max_buffer_size: 1 ).max_buffer_size
+                ).to eq 1
+            end
+        end
+
+        describe ':dumper' do
+            it 'defaults to Marshal' do
+                d = described_class.new( max_buffer_size: 0 )
+                d << 1
+
+                expect(d.unserialize(IO.binread(d.disk.first))).to eq 1
+            end
+
+            context 'it responds to :dump' do
+                it 'gets called to serialize the object' do
+                    class Dumper; def self.dump(o) o.to_s << '-' end ;end
+
+                    d = described_class.new(
+                        max_buffer_size: 0,
+                        dumper: Dumper
+                    )
+                    d << 1
+
+                    expect(Zlib::Inflate.inflate IO.binread(d.disk.first)).to eq '1-'
+                end
+            end
+
+            context 'it responds to :call' do
+                it 'gets called to serialize the object' do
+                    d = described_class.new(
+                        max_buffer_size: 0,
+                        dumper: proc do |o|
+                            o.to_s << '-'
+                        end
+                    )
+                    d << 1
+
+                    expect(Zlib::Inflate.inflate IO.binread(d.disk.first)).to eq '1-'
+                end
+            end
+        end
+
+        describe ':load' do
+            context 'it responds to :load' do
+                it 'gets called to unserialize the object' do
+                    class Loader; def self.load(o) o + '-' end ;end
+
+                    d = described_class.new(
+                        max_buffer_size: 0,
+                        loader: Loader
+                    )
+                    d << 1
+
+                    expect(d.pop).to eq Marshal.dump( 1 ) + '-'
+                end
+            end
+
+            context 'it responds to :call' do
+                it 'gets called to serialize the object' do
+                    d = described_class.new(
+                        max_buffer_size: 0,
+                        loader: proc do |o|
+                            o + '-'
+                        end
+                    )
+                    d << 1
+
+                    expect(d.pop).to eq Marshal.dump( 1 ) + '-'
+                end
+            end
+        end
+    end
+
+    describe '#buffer' do
+        it 'returns the objects stored in the memory buffer' do
+            subject << 1
+            subject << 2
+
+            expect(subject.buffer).to eq([1, 2])
+        end
+    end
+
+    describe '#disk' do
+        it 'returns paths to the files of objects stored to disk' do
+            subject.max_buffer_size = 0
+            subject << 1
+            subject << 2
+
+            expect(subject.disk.size).to eq(2)
+            subject.disk.each do |path|
+                expect(File.exists?( path )).to be_truthy
+            end
+        end
+    end
+
+    describe '#max_buffer_size' do
+        context 'by default' do
+            it "returns #{described_class}::DEFAULT_MAX_BUFFER_SIZE" do
+                expect(subject.max_buffer_size).to eq(described_class::DEFAULT_MAX_BUFFER_SIZE)
+            end
+        end
+    end
+
+    describe '#max_buffer_size=' do
+        it 'sets #max_buffer_size' do
+            subject.max_buffer_size = 10
+            expect(subject.max_buffer_size).to eq(10)
+        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 false' do
+                subject << :stuff
+                expect(subject.empty?).to be_falsey
+            end
+        end
+    end
+
+    describe '#<<' do
+        it 'pushes an object' do
+            sample_size.times do |i|
+                subject << "stuff #{i}"
+            end
+
+            sample_size.times do |i|
+                expect(subject.pop).to eq("stuff #{i}")
+            end
+        end
+    end
+
+    describe '#push' do
+        it 'pushes an object' do
+            subject.push :stuff
+            expect(subject.pop).to eq(:stuff)
+        end
+
+        it 'increments .disk_space' do
+            sz = described_class.disk_space
+
+            subject.max_buffer_size = 0
+            subject.push 'a' * 100
+
+            expect(described_class.disk_space).to be > sz
+        end
+    end
+
+    describe '#enq' do
+        it 'pushes an object' do
+            subject.enq :stuff
+            expect(subject.pop).to eq(:stuff)
+        end
+    end
+
+    describe '#pop' do
+        it 'removes an object' do
+            sample_size.times do |i|
+                subject << "stuff #{i}"
+            end
+
+            sample_size.times do |i|
+                expect(subject.pop).to eq("stuff #{i}")
+            end
+        end
+
+        it 'blocks until an entry is available' do
+            val = nil
+
+            t = Thread.new { val = subject.pop }
+            sleep 1
+            Thread.new { subject << :stuff }
+            t.join
+
+            expect(val).to eq(:stuff)
+        end
+
+        it 'decrements .disk_space' do
+            subject.max_buffer_size = 0
+            subject.push 'a' * 100
+
+            sz = described_class.disk_space
+            subject.pop
+
+            expect(described_class.disk_space).to be < sz
+        end
+    end
+
+    describe '#deq' do
+        it 'removes an object' do
+            subject << :stuff
+            expect(subject.deq).to eq(:stuff)
+        end
+    end
+
+    describe '#shift' do
+        it 'removes an object' do
+            subject << :stuff
+            expect(subject.shift).to eq(:stuff)
+        end
+    end
+
+    describe '#size' do
+        it 'returns the size of the queue' do
+            sample_size.times { |i| subject << i }
+            expect(subject.size).to eq(sample_size)
+        end
+    end
+
+    describe '#free_buffer_size' do
+        it 'returns the size of the available buffer' do
+            (subject.max_buffer_size - 2).times { |i| subject << i }
+            expect(subject.free_buffer_size).to eq(2)
+        end
+    end
+
+    describe '#buffer_size' do
+        it 'returns the size of the in-memory entries' do
+            expect(subject.buffer_size).to eq(0)
+
+            (subject.max_buffer_size - 1).times { |i| subject << i }
+            expect(subject.buffer_size).to eq(subject.max_buffer_size - 1)
+
+            subject.clear
+
+            sample_size.times { |i| subject << i }
+            expect(subject.buffer_size).to eq(subject.max_buffer_size)
+        end
+    end
+
+    describe '#disk_size' do
+        it 'returns the size of the disk entries' do
+            expect(subject.buffer_size).to eq(0)
+
+            (subject.max_buffer_size + 1).times { |i| subject << i }
+            expect(subject.disk_size).to eq(1)
+
+            subject.clear
+
+            sample_size.times { |i| subject << i }
+            expect(subject.disk_size).to eq(sample_size - subject.max_buffer_size)
+        end
+    end
+
+    describe '#num_waiting' do
+        it 'returns the amount of threads waiting to pop' do
+            expect(subject.num_waiting).to eq(0)
+
+            2.times do
+                Thread.new { subject.pop }
+            end
+            sleep 0.1
+
+            expect(subject.num_waiting).to eq(2)
+        end
+    end
+
+    describe '#clear' do
+        it 'empties the queue' do
+            sample_size.times { |i| subject << i }
+            subject.clear
+            expect(subject.size).to eq(0)
+        end
+
+        it 'decrements .disk_space' do
+            subject.max_buffer_size = 0
+            subject.push 'a' * 100
+
+            sz = described_class.disk_space
+            subject.clear
+
+            expect(described_class.disk_space).to be < sz
+        end
+    end
+
+end

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