alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-algebra/operator/intersect/test_type_check.rb

@@ -0,0 +1,30 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Intersect, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          intersect(suppliers, suppliers)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when heading mismatch' do
+        let(:op){ 
+          intersect(suppliers, supplies)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /heading mismatch/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/join/test_type_check.rb

@@ -0,0 +1,62 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Join, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          join(suppliers, suppliers)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when nothing in common' do
+        let(:right){
+          an_operand.with_heading(foo: Integer)
+        }
+        let(:left){
+          an_operand.with_heading(bar: String)
+        }
+        let(:op){ 
+          join(left, right)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when heading mismatch' do
+        let(:right){
+          an_operand.with_heading(sid: Integer)
+        }
+        let(:left){
+          an_operand.with_heading(sid: String)
+        }
+        let(:op){ 
+          join(left, right)
+        }
+
+        context 'when strict' do
+          subject{ op.type_check(strict: true) }
+
+          it 'should raise an error' do
+            lambda{
+              subject
+            }.should raise_error(TypeCheckError, /heading mismatch/)
+          end
+        end
+
+        context 'when not strict' do
+          subject{ op.type_check }
+
+          it 'should not raise an error' do
+            subject.should eq(op.heading)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/matching/test_keys.rb

@@ -32,7 +32,7 @@ module Alf
         }
 
         let(:expected){
-          Keys[ [:name], [:id] ]
+          Keys[ [:name] ]
         }
 
         it { should eq(expected) }

data/spec/unit/alf-algebra/operator/matching/test_type_check.rb

@@ -0,0 +1,62 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Matching, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          matching(suppliers, suppliers)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when nothing in common' do
+        let(:right){
+          an_operand.with_heading(foo: Integer)
+        }
+        let(:left){
+          an_operand.with_heading(bar: String)
+        }
+        let(:op){ 
+          matching(left, right)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when heading mismatch' do
+        let(:right){
+          an_operand.with_heading(sid: Integer)
+        }
+        let(:left){
+          an_operand.with_heading(sid: String)
+        }
+        let(:op){ 
+          matching(left, right)
+        }
+
+        context 'when strict' do
+          subject{ op.type_check(strict: true) }
+
+          it 'should raise an error' do
+            lambda{
+              subject
+            }.should raise_error(TypeCheckError, /heading mismatch/)
+          end
+        end
+
+        context 'when not strict' do
+          subject{ op.type_check }
+
+          it 'should not raise an error' do
+            subject.should eq(op.heading)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/minus/test_type_check.rb

@@ -0,0 +1,30 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Minus, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          minus(suppliers, suppliers)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when heading mismatch' do
+        let(:op){ 
+          minus(suppliers, supplies)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /heading mismatch/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/not_matching/test_type_check.rb

@@ -0,0 +1,62 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe NotMatching, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          not_matching(suppliers, suppliers)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when nothing in common' do
+        let(:right){
+          an_operand.with_heading(foo: Integer)
+        }
+        let(:left){
+          an_operand.with_heading(bar: String)
+        }
+        let(:op){ 
+          not_matching(left, right)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when heading mismatch' do
+        let(:right){
+          an_operand.with_heading(sid: Integer)
+        }
+        let(:left){
+          an_operand.with_heading(sid: String)
+        }
+        let(:op){ 
+          not_matching(left, right)
+        }
+
+        context 'when strict' do
+          subject{ op.type_check(strict: true) }
+
+          it 'should raise an error' do
+            lambda{
+              subject
+            }.should raise_error(TypeCheckError, /heading mismatch/)
+          end
+        end
+
+        context 'when not strict' do
+          subject{ op.type_check }
+
+          it 'should not raise an error' do
+            subject.should eq(op.heading)
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/page/test_type_check.rb

@@ -0,0 +1,50 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Page, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          page(suppliers, [], 1, page_size: 12)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when negative page index' do
+        let(:op){ 
+          page(suppliers, [], -1, page_size: 12)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when invalid ordering' do
+        let(:op){ 
+          page(suppliers, [[:sid, :asc], [:foo, :asc], [:bar, :asc]], 2)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attributes `foo`,`bar`/)
+        end
+      end
+
+      context 'when negative page_size' do
+        let(:op){ 
+          page(suppliers, [[:sid, :asc]], 2, page_size: -4)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /invalid page size `-4`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/project/test_type_check.rb

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Project, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          project(suppliers, [:sid, :name])
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when projectping unexisting attribute' do
+        let(:op){ 
+          project(suppliers, [:sid, :unknown])
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `unknown`/)
+        end
+      end
+
+      context 'when projectping unexisting attributes' do
+        let(:op){ 
+          project(suppliers, [:sid, :foo, :bar])
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attributes `foo`,`bar`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/quota/test_type_check.rb

@@ -0,0 +1,54 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Quota, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          quota(supplies, [:sid], [[:sid, :asc]], :sum => sum{ qty })
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when unknown by' do
+        let(:op){ 
+          quota(supplies, [:foo], [[:sid, :asc]], :sum => sum{ qty })
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+      context 'when invalid ordering' do
+        let(:op){ 
+          quota(supplies, [:sid], [[:bar, :asc]], :sum => sum{ qty })
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `bar`/)
+        end
+      end
+
+      context 'when name clash' do
+        let(:op){ 
+          quota(supplies, [:sid], [[:sid, :asc]], :qty => sum{ qty })
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `qty`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/rank/test_type_check.rb

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Rank, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          rank(suppliers, [[:name, :asc]], :rank)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when invalid ordering' do
+        let(:op){ 
+          rank(suppliers, [[:foo, :asc]], :rank)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+      context 'when name clash' do
+        let(:op){ 
+          rank(suppliers, [[:name, :asc]], :name)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `name`/)
+        end
+      end
+
+    end
+  end
+end