cuboid 0.0.0 → 0.0.1alpha

data/spec/cuboid/support/cache/least_recently_used_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Cache::LeastRecentlyUsed do
+    it_behaves_like 'cache'
+
+    it 'prunes itself by removing Least Recently Used entries' do
+        subject.max_size = 3
+
+        subject[:k]  = '1'
+        subject[:k2] = '2'
+        subject[:k]
+        subject[:k3] = '3'
+        subject[:k4] = '4'
+
+        expect(subject.size).to eq(3)
+
+        expect(subject[:k]).to be_truthy
+        expect(subject[:k4]).to be_truthy
+        expect(subject[:k3]).to be_truthy
+        expect(subject[:k2]).to be_nil
+    end
+
+    describe '#[]=' do
+        it 'stores an object' do
+            v = 'val'
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
+        end
+        it 'alias of #store' do
+            v = 'val2'
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
+        end
+    end
+
+    describe '#[]' do
+        it 'retrieves an object by key' do
+            v = 'val2'
+            subject[:key] = v
+            expect(subject[:key]).to eq(v)
+            expect(subject.empty?).to be_falsey
+        end
+
+        context 'when the key does not exist' do
+            it 'returns nil' do
+                expect(subject[:some_key]).to be_nil
+            end
+        end
+    end
+
+    describe '#delete' do
+        context 'when the key exists' do
+            it 'deletes a key and return its value' do
+                v = 'my_val'
+                subject[:my_key] = v
+                expect(subject.delete( :my_key )).to eq(v)
+                expect(subject[:my_key]).to be_nil
+                expect(subject.include?( :my_key )).to be_falsey
+            end
+        end
+        context 'when the key does not exist' do
+            it 'returns nil' do
+                expect(subject.delete( :my_key2 )).to be_nil
+            end
+        end
+    end
+
+    describe '#clear' do
+        it 'empties the cache' do
+            subject[:my_key2] = 'v'
+            expect(subject.size).to be > 0
+            expect(subject.empty?).to be_falsey
+            subject.clear
+
+            expect(subject.size).to eq(0)
+            expect(subject.empty?).to be_truthy
+        end
+    end
+
+end

data/spec/cuboid/support/cache/preference_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Cache::Preference do
+    it_behaves_like 'cache'
+
+    it 'prunes itself by removing entries returned by the given block' do
+        subject.max_size = 3
+
+        subject.prefer { :k2 }
+
+        k = [ :k, :k2, :k3, :k4 ]
+        subject[k[0]] = '1'
+        subject[k[1]] = '2'
+        subject[k[2]] = '3'
+        subject[k[3]] = '4'
+        expect(subject.size).to eq(3)
+
+        expect(k.map { |key| subject[key] }.count( nil )).to eq(1)
+
+        subject.clear
+    end
+
+    it 'does not remove entries which are not preferred even if the max size has been exceeded' do
+        subject.prefer { :k2 }
+
+        k = [ :k, :k2, :k3, :k4 ]
+
+        subject.max_size = 1
+        subject[k[0]]  = '1'
+        subject[k[1]] = '3'
+        subject[k[2]] = '4'
+        expect(subject.size).to eq(2)
+
+        expect(k[0...3].map { |key| subject[key] }.count( nil )).to eq(1)
+    end
+
+end

data/spec/cuboid/support/cache/random_replacement_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Cuboid::Support::Cache::RandomReplacement do
+    it_behaves_like 'cache'
+
+    it 'prunes itself by removing random entries (Random Replacement)' do
+        subject.max_size = 3
+
+        k = [ :k, :k2, :k3, :k4 ]
+        subject[k[0]] = '1'
+        subject[k[1]] = '2'
+        subject[k[2]] = '3'
+        subject[k[3]] = '4'
+        expect(subject.size).to eq(3)
+
+        expect(k.map { |key| subject[key] }.count( nil )).to eq(1)
+
+        subject.clear
+
+        subject.max_size = 1
+        subject[k[0]]  = '1'
+        subject[k[1]] = '3'
+        subject[k[2]] = '4'
+        expect(subject.size).to eq(1)
+
+        expect(k[0...3].map { |key| subject[key] }.count( nil )).to eq(2)
+    end
+
+    describe '#[]=' do
+        it 'stores an object' do
+            v = 'val'
+            expect(subject[:key] = v).to eq(v)
+            expect(subject[:key]).to eq(v)
+        end
+        it 'alias of #store' do
+            v = 'val2'
+            expect(subject.store( :key2, v )).to eq(v)
+            expect(subject[:key2]).to eq(v)
+        end
+    end
+
+end

data/spec/cuboid/support/crypto/rsa_aes_cbc_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe Cuboid::Support::Crypto::RSA_AES_CBC do
+
+    SEED = 'seed data'
+
+    let(:public_key_file_path) do
+        key  = private_key.public_key
+        file = Tempfile.new( 'public_key.pem' )
+        file.write( key.to_pem )
+        file.close
+        file.path
+    end
+    let(:private_key_file_path) do
+        file = Tempfile.new( 'private_key.pem' )
+        file.write( private_key.to_pem )
+        file.close
+        file.path
+    end
+    let(:private_key) { OpenSSL::PKey::RSA.generate( 1024 ) }
+    subject { described_class.new( public_key_file_path, private_key_file_path ) }
+
+    it 'generates matching encrypted and decrypted data' do
+        expect(subject.decrypt( subject.encrypt( SEED ) )).to eq(SEED)
+    end
+
+end

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