alf-core 0.13.0

data/spec/unit/alf-database/connection/test_parse.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Connection, "parse" do
+
+      let(:conn){ sap_conn }
+
+      shared_examples_for 'a bound expression' do
+
+        it{ should be_bound }
+        
+        it 'has the expected connection' do
+          subject.connection!.should be(conn)
+        end
+
+        it 'has bound operands too' do
+          subject.operands.all?{|op|
+            op.should be_bound
+            op.connection!.should be(conn)
+          } if subject.is_a?(Algebra::Operator)
+        end
+      end
+
+      shared_examples_for 'a named operand on suppliers' do
+
+        it_should_behave_like 'a bound expression'
+        
+        it{ should be_a(Algebra::Operand::Named) }
+
+        it 'has the expected name' do
+          subject.name.should eq(:suppliers)
+        end
+      end
+
+      shared_examples_for 'a join operand on suppliers and supplies' do
+
+        it_should_behave_like 'a bound expression'
+        
+        it{ should be_a(Algebra::Join) }
+      end
+
+      context 'when a single leaf operand' do
+
+        context 'parsed from a Symbol' do
+          subject{ conn.parse(:suppliers) }
+
+          it_should_behave_like 'a named operand on suppliers'
+        end
+
+        context 'parsed from a String' do
+          subject{ conn.parse('suppliers') }
+
+          it_should_behave_like 'a named operand on suppliers'
+        end
+
+        context 'parsed from a Proc' do
+          subject{ conn.parse{ suppliers } }
+
+          it_should_behave_like 'a named operand on suppliers'
+        end
+
+        context 'parsed from an existing operand' do
+          let(:expr){ Algebra.named_operand(:suppliers, 12) }
+
+          subject{ conn.parse(expr) }
+
+          it_should_behave_like 'a named operand on suppliers'
+
+          it 'does not touch the original expr' do
+            subject.should_not be(expr)
+            expr.connection.should eq(12)
+          end
+        end
+      end
+
+      context 'when a complex expression' do
+
+        context 'with a String' do
+          subject{ conn.parse('join(project(suppliers, [:sid]), supplies)') }
+
+          it_should_behave_like 'a join operand on suppliers and supplies'
+        end
+
+        context 'with a Proc' do
+          subject{ conn.parse{ join(project(suppliers, [:sid]), supplies) } }
+
+          it_should_behave_like 'a join operand on suppliers and supplies'
+        end
+
+        context 'with an expression' do
+          let(:expr){
+            conn.parse{ join(project(suppliers, [:sid]), supplies) }.bind(12)
+          }
+
+          subject{ conn.parse(expr) }
+
+          it_should_behave_like 'a join operand on suppliers and supplies'
+
+          it 'does not touch the original expr' do
+            subject.should_not be(expr)
+            expr.connection.should eq(12)
+            expr.operands.all?{|op| op.connection.should eq(12) }
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/connection/test_query.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Connection, "query" do
+
+      let(:conn){ sap_conn }
+
+      context 'with a leaf operand' do
+        subject{ conn.query{ suppliers } }
+
+        it{ should be_a(Relation) }
+      end
+
+      context 'with a complex expression' do
+        subject{ conn.query{ project(suppliers, [:sid]) } }
+
+        it{ should be_a(Relation) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/connection/test_reconnect.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Connection, "reconnect" do
+
+      let(:connection_handler){ ->(opts){ self } }
+
+      let(:conn){ Connection.new(self, &connection_handler) }
+
+      subject{ conn.reconnect(opts) }
+
+      def close
+        @closed = true
+      end
+
+      before do
+        conn.should_not be_closed
+        @closed = false
+      end
+
+      context 'when only physical options are changed' do
+        let(:opts){ {schema_cache: true} }
+
+        it 'should close the underlying connection' do
+          subject
+          @closed.should be_true
+        end
+      end
+
+      context 'when only logical options are changed' do
+        let(:opts){ {default_viewpoint: Viewpoint::NATIVE} }
+
+        it 'should not close the underlying connection' do
+          subject
+          @closed.should be_false
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/connection/test_relvar.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Connection, "relvar" do
+
+      let(:conn){ sap_conn }
+
+      context 'with a leaf operand' do
+        subject{ conn.relvar{ suppliers } }
+
+        it{ should be_a(Relvar::Base) }
+
+        it 'has the expected name' do
+          subject.name.should eq(:suppliers)
+        end
+
+        it 'is bound to the serving connection' do
+          subject.connection!.should be(conn)
+        end
+      end
+
+      context 'with a complex expression' do
+        subject{ conn.relvar{ project(suppliers, [:sid]) } }
+
+        it{ should be_a(Relvar::Virtual) }
+
+        it 'has the expected expression' do
+          subject.expr.should be_a(Algebra::Project)
+        end
+
+        it 'is bound to the serving connection' do
+          subject.connection!.should be(conn)
+        end
+
+        it 'has a bound expression as well' do
+          subject.expr.connection!.should be(conn)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/connection/test_tuple_extract.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Connection, "tuple_extract" do
+
+      let(:conn){ sap_conn }
+
+      context 'when more than one tuple' do
+        subject{ conn.tuple_extract{ suppliers } }
+
+        it 'raises a NoSuchTupleError' do
+          lambda{
+            subject
+          }.should raise_error(NoSuchTupleError)
+        end
+      end
+
+      context 'when zero tuple' do
+        subject{ conn.tuple_extract{ restrict(suppliers, ->{ false }) } }
+
+        it 'raises a NoSuchTupleError' do
+          lambda{
+            subject
+          }.should raise_error(NoSuchTupleError)
+        end
+      end
+
+      context 'when exactly one tuple' do
+        subject{ conn.tuple_extract{ restrict(suppliers, ->{ sid == 'S1' }) } }
+
+        it 'returns a Tuple instance' do
+          subject.should be_a(Tuple)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/database/test_connect.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Alf
+  describe Database, 'connect' do
+
+    context 'without a block' do
+      subject{ Database.connect(Path.dir) }
+
+      it{ should be_a(Database::Connection) }
+
+      it 'should not be closed' do
+        subject.should_not be_closed
+      end
+    end
+
+    context 'with a block' do
+      subject{
+        Database.connect(Path.dir){|c| 
+          c.should be_a(Database::Connection)
+          c.should_not be_closed
+          @seen = c
+        }
+      }
+
+      it 'yields the block with a connection instance' do
+        subject
+        @seen.should be_a(Database::Connection)
+      end
+
+      it 'close the connection at the end' do
+        subject
+        @seen.should be_closed
+      end
+    end
+
+    context 'when passing options' do
+      subject{ Database.connect(Path.dir, schema_cache: false) }
+
+      it 'overrides default options' do
+        subject.schema_cache?.should eq(false)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-database/database/test_connection.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Alf
+  describe Database, 'connection' do
+
+    let(:db){ Database.new(Path.dir) }
+
+    subject{ db.connection }
+
+    after do
+      subject.close
+    end
+
+    it{ should be_a(Database::Connection) }
+
+    it 'sets a copy of the original options' do
+      subject.options.should be_a(Database::Options)
+      subject.options.should_not be(db.default_options)
+    end
+
+  end
+end

data/spec/unit/alf-database/database/test_default_options.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe Database, 'default_options' do
+
+    subject{ Database.new(Path.dir) }
+
+    it_should_behave_like "a facade on database options"
+
+    it 'should allow default options to be consulted' do
+      subject.default_options.should be_a(Database::Options)
+    end
+
+  end
+end

data/spec/unit/alf-database/database/test_new.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Alf
+  describe Database, '.new' do
+
+    let(:adapter){ Adapter.new(nil) }
+
+    after do
+      subject.adapter.should be_a(Adapter)
+    end
+
+    context 'on a single adapter' do
+      subject{ Database.new(adapter) }
+
+      it 'uses the specified adapter' do
+        subject.adapter.should be(adapter)
+      end
+
+      it 'uses default options' do
+        subject.schema_cache?.should be_true
+      end
+    end
+
+    context 'on an adapter to be coerced' do
+      subject{ Database.new(Path.dir) }
+
+      it 'coerces the adapter' do
+        subject.adapter.should be_a(Adapter::Folder)
+      end
+
+      it 'uses default options' do
+        subject.schema_cache?.should be_true
+      end
+    end
+
+    context 'when passing options' do
+      subject{ Database.new(adapter, schema_cache: false) }
+
+      it 'set the options correctly' do
+        subject.schema_cache?.should be_false
+      end
+    end
+
+    context 'when a block is given' do
+      subject{ Database.new(adapter){|d| @seen = d } }
+
+      it 'yields the block' do
+        subject.should be_a(Database)
+        @seen.should be_a(Database::Options)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-database/options/test_default_viewpoint.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Options, "default_viewpoint" do
+
+      subject{ opts.default_viewpoint }
+
+      let(:opts){ Options.new }
+
+      context 'by default' do
+
+        it { should be(Viewpoint::NATIVE) }
+      end
+
+      context 'when explicitely set' do
+        let(:mod){ Module.new{ include Alf::Viewpoint } }
+
+        before{ opts.default_viewpoint = mod }
+
+        it{ should be(mod) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/options/test_freeze.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Options, "freeze" do
+
+      let(:opts){ Options.new(schema_cache: true) }
+
+      subject{ opts.freeze }
+
+      it{ should be(opts) }
+
+      it 'should prevent further modifications' do
+        lambda{
+          subject.schema_cache = false
+        }.should raise_error(/can't modify frozen/)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-database/options/test_merge.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Options, "merge" do
+
+      let(:opts){ Options.new(schema_cache: true) }
+
+      subject{ opts.merge(schema_cache: false) }
+
+      it{ should be_a(Options) }
+
+      it 'is not the original' do
+        subject.should_not be(opts)
+      end
+
+      it 'merges the new options' do
+        subject.schema_cache?.should eq(false)
+      end
+
+      it 'does not touch the original' do
+        opts.schema_cache?.should eq(true)
+      end
+
+    end
+  end
+end