cuboid 0.0.0 → 0.0.3

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

@@ -0,0 +1,327 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Database::CategorizedQueue do
+
+    class Item
+        attr_accessor :category
+        attr_accessor :data
+
+        def initialize( data )
+            @data = data
+        end
+
+        def ==( other )
+            data == other.data
+        end
+
+        def hash
+            data.hash
+        end
+    end
+
+    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 << Item.new( 'a' * i )
+        end
+
+        sleep 0.1 while !subject.empty?
+
+        consumed = []
+        consumed << poped.pop.data 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'
+
+            context 'it responds to :dump' do
+                it 'gets called to serialize the object'
+            end
+
+            context 'it responds to :call' do
+                it 'gets called to serialize the object'
+            end
+        end
+
+        describe ':load' do
+            context 'it responds to :load' do
+                it 'gets called to unserialize the object'
+            end
+
+            context 'it responds to :call' do
+                it 'gets called to serialize the object'
+            end
+        end
+
+        describe '&block' do
+            it 'sets the #prefer block' do
+                prefer = proc {}
+
+                expect( described_class.new( &prefer ).prefer ).to be prefer
+            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 << Item.new( :stuff )
+                expect(subject.empty?).to be_falsey
+            end
+        end
+    end
+
+    describe '#<<' do
+        it 'pushes an object' do
+            sample_size.times do |i|
+                subject << Item.new( "stuff #{i}" )
+            end
+
+            sample_size.times do |i|
+                expect(subject.pop).to eq(Item.new( "stuff #{i}" ))
+            end
+        end
+
+        context 'when no #prefer block has been set' do
+            it "raises #{ArgumentError}" do
+                expect {
+                    described_class.new << Item.new( '' )
+                }.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#push' do
+        it 'pushes an object' do
+            subject.push Item.new( :stuff )
+            expect(subject.pop).to eq(Item.new( :stuff ))
+        end
+
+        it 'increments .disk_space' do
+            sz = described_class.disk_space
+
+            subject.max_buffer_size = 0
+            subject.push Item.new( :stuff )
+
+            expect(described_class.disk_space).to be > sz
+        end
+    end
+
+    describe '#enq' do
+        it 'pushes an object' do
+            subject.enq Item.new( :stuff )
+            expect(subject.pop).to eq(Item.new( :stuff ))
+        end
+    end
+
+    describe '#pop' do
+        it 'removes an object' do
+            sample_size.times do |i|
+                subject << Item.new( "stuff #{i}" )
+            end
+
+            sample_size.times do |i|
+                expect(subject.pop).to eq(Item.new( "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 << Item.new( :stuff ) }
+            t.join
+
+            expect(val).to eq(Item.new( :stuff ))
+        end
+
+        it 'gives preference to the category provided by the block' do
+            subject = described_class.new { :stuff2 }
+
+            subject << Item.new( 1 ).tap { |s| s.category = :stuff }
+            subject << Item.new( 2 ).tap { |s| s.category = :stuff2 }
+            subject << Item.new( 3 ).tap { |s| s.category = :stuff3 }
+
+            expect(subject.pop.data).to eq 2
+            expect(subject.pop.data).to eq 3
+            expect(subject.pop.data).to eq 1
+        end
+
+        it 'decrements .disk_space' do
+            subject.max_buffer_size = 0
+            subject.push Item.new( "stuff" )
+
+            sz = described_class.disk_space
+            subject.pop
+
+            expect(described_class.disk_space).to be < sz
+        end
+
+        context 'when the block specified category is empty' do
+            it 'returns an item from the next one' do
+                subject = described_class.new { :stuff4 }
+
+                subject << Item.new( 1 ).tap { |s| s.category = :stuff }
+                subject << Item.new( 2 ).tap { |s| s.category = :stuff2 }
+                subject << Item.new( 3 ).tap { |s| s.category = :stuff3 }
+
+                expect(subject.pop.data).to eq 3
+                expect(subject.pop.data).to eq 2
+                expect(subject.pop.data).to eq 1
+            end
+        end
+
+        context 'when no #prefer block has been set' do
+            it "raises #{ArgumentError}" do
+                expect {
+                    described_class.new.pop
+                }.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#deq' do
+        it 'removes an object' do
+            subject << Item.new( :stuff )
+            expect(subject.deq).to eq(Item.new( :stuff ))
+        end
+    end
+
+    describe '#shift' do
+        it 'removes an object' do
+            subject << Item.new( :stuff )
+            expect(subject.shift).to eq(Item.new( :stuff ))
+        end
+    end
+
+    describe '#size' do
+        it 'returns the size of the queue' do
+            sample_size.times { |i| subject << Item.new( 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 << Item.new( 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 << Item.new( i ) }
+            expect(subject.buffer_size).to eq(subject.max_buffer_size - 1)
+
+            subject.clear
+
+            sample_size.times { |i| subject << Item.new( 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 << Item.new( i ) }
+            expect(subject.disk_size).to eq(1)
+
+            subject.clear
+
+            sample_size.times { |i| subject << Item.new( 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 << Item.new( i ) }
+            subject.clear
+            expect(subject.size).to eq(0)
+            expect((subject.pop( true ) rescue nil)).to eq(nil)
+        end
+
+        it 'decrements .disk_space' do
+            subject.max_buffer_size = 0
+            subject.push Item.new( "stuff" )
+
+            sz = described_class.disk_space
+            subject.clear
+
+            expect(described_class.disk_space).to be < sz
+        end
+    end
+
+end

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