cuboid 0.0.0 → 0.0.1alpha

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

@@ -0,0 +1,204 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Database::Hash do
+
+    before :each do
+        subject.update seeds
+    end
+
+    subject { described_class.new }
+    let(:non_existent) { 'blahblahblah' }
+    let(:seeds) do
+        {
+            'key' => 'val',
+            :key  => 'val2',
+            { 'key' => 'val' } => 'val4'
+        }
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-empty?
+    it 'implements #empty?' do
+        subject = described_class.new
+        expect(subject.empty?).to eq({}.empty?)
+
+        nh = { :k => 'v' }
+        subject[:k] = 'v'
+
+        expect(subject.empty?).to eq(nh.empty?)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-5B-5D-3D
+    it 'implements #[]=( k, v ) (and store( k, v ))' do
+        seeds.each do |k, v|
+            expect(subject[k] = v).to eq(v)
+        end
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-5B-5D
+    it 'implements #[]' do
+        seeds.each do |k, v|
+            expect(subject[k]).to eq(v)
+        end
+
+        expect(subject[non_existent]).to eq(seeds[non_existent])
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-assoc
+    it 'implements #assoc( k )' do
+        seeds.dup.each do |k, v|
+            expect(subject.assoc( k )).to eq(seeds.assoc( k ))
+        end
+
+        expect(subject.assoc( non_existent )).to eq(seeds.assoc( non_existent ))
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-rassoc
+    it 'implements #rassoc( k )' do
+        seeds.each do |k, v|
+            expect(subject.rassoc( v )).to eq(seeds.rassoc( v ))
+        end
+
+        expect(subject.rassoc( non_existent )).to eq(seeds.rassoc( non_existent ))
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-delete
+    it 'implements #delete( k, &block )' do
+        expect(subject.delete( non_existent )).to eq(seeds.delete( non_existent ))
+        seeds[non_existent] = subject[non_existent] = 'foo'
+        expect(subject.delete( non_existent )).to eq(seeds.delete( non_existent ))
+
+        expect(subject.delete( non_existent ) { |k| k }).to eq(
+            seeds.delete( non_existent ) { |k| k }
+        )
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-shift
+    it 'implements #shift' do
+        expect(subject.shift).to eq(seeds.shift)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-each
+    it 'implements #each() (and #each_pair())' do
+        subject.each do |k, v|
+            expect(seeds[k]).to eq(v)
+        end
+
+        # they must both return enumerators
+        expect(subject.each.class).to eq(seeds.each.class)
+
+        subject.each_pair do |k, v|
+            expect(seeds[k]).to eq(v)
+        end
+
+        # they must both return enumerators
+        expect(subject.each_pair.class).to eq(seeds.each_pair.class)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-each_key
+    it 'implements #each_key' do
+        subject.each_key do |k|
+            expect(seeds[k]).to eq(subject[k])
+        end
+
+        # they must both return enumerators
+        expect(subject.each_key.class).to eq(seeds.each_key.class)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-each_value
+    it 'implements #each_value' do
+        subject.each_value do |v|
+            expect(seeds[ seeds.key( v )]).to eq(v)
+        end
+
+        # they must both return enumerators
+        expect(subject.each_value.class).to eq(seeds.each_value.class)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-keys
+    it 'implements #keys' do
+        expect(subject.keys).to eq(seeds.keys)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-key
+    it 'implement #key' do
+        subject.each_key do |k|
+            expect(seeds.key( k )).to eq(subject.key( k ))
+        end
+
+        expect(subject.key( non_existent )).to eq(seeds.key( non_existent ))
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-values
+    it 'implements #values' do
+        expect(subject.values).to eq(seeds.values)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-include?
+    it 'implements #include? (and #member?, #key?, #has_key?)' do
+        subject.each_key {
+            |k|
+            expect(seeds.include?( k )).to eq(subject.include?( k ))
+            expect(seeds.member?( k )).to eq(subject.member?( k ))
+            expect(seeds.key?( k )).to eq(subject.key?( k ))
+            expect(seeds.has_key?( k )).to eq(subject.has_key?( k ))
+        }
+
+        expect(subject.include?( non_existent )).to eq(seeds.include?( non_existent ))
+        expect(subject.member?( non_existent )).to eq(seeds.member?( non_existent ))
+        expect(subject.key?( non_existent )).to eq(seeds.key?( non_existent ))
+        expect(subject.has_key?( non_existent )).to eq(seeds.has_key?( non_existent ))
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-merge
+    it 'implements #merge' do
+        mh = { :another_key => 'another value' }
+
+        nh = subject.merge( mh )
+        expect(nh.keys).to eq(seeds.merge( mh ).keys)
+        expect(nh.values).to eq(seeds.merge( mh ).values)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-merge!
+    it 'implements #merge! (and #update)' do
+        mh = { :another_other_key => 'another other value' }
+        mh2 = { :another_other_key2 => 'another other value2' }
+
+        subject.merge!( mh )
+        seeds.merge!( mh )
+
+        subject.update( mh2 )
+        seeds.update( mh2 )
+
+        expect(subject.keys).to eq(seeds.keys)
+        expect(subject.values).to eq(seeds.values)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-to_hash
+    it 'implements #to_hash' do
+        expect(subject.to_hash).to eq(seeds.to_hash)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-to_a
+    it 'implements #to_a' do
+        expect(subject.to_a).to eq(seeds.to_a)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-size
+    it 'implements #size' do
+        expect(subject.size).to eq(seeds.size)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-3D-3D
+    it 'implements #== (and #eql?)' do
+        expect(subject == subject.merge( {} )).to eq(true)
+        expect(subject == seeds).to eq(true)
+    end
+
+    # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-clear
+    it 'implements #clear' do
+        subject.clear
+        seeds.clear
+        expect(subject.size).to eq(seeds.size)
+    end
+
+end

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