alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-algebra/operand/test_coerce.rb

@@ -12,8 +12,6 @@ module Alf
           subject.should be_a(Operand::Named)
           subject.name.should eq(:suppliers)
         end
-
-        it{ should_not be_bound }
       end
 
       context "on a Hash" do
@@ -23,8 +21,6 @@ module Alf
           subject.should be_a(Operand::Proxy)
           subject.subject.should eq([ arg ])
         end
-
-        it{ should_not be_bound }
       end
 
       context "on a Tuple" do
@@ -34,8 +30,6 @@ module Alf
           subject.should be_a(Operand::Proxy)
           subject.subject.should eq([ arg ])
         end
-
-        it{ should_not be_bound }
       end
 
     end

data/spec/unit/alf-algebra/operand/test_proxy.rb

@@ -28,7 +28,7 @@ module Alf
             end
           end
 
-          context "with #{method} with knowing victim" do
+          context "with #{method} with unknowing victim" do
             let(:method){
               method
             }

data/spec/unit/alf-algebra/operator/allbut/test_key_preserving.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 module Alf
   module Algebra
-    describe "Allbut", 'key_preserving?' do
+    describe Allbut, 'key_preserving?' do
 
       let(:operand){
         an_operand.with_heading(:id => Integer, :name => String, :status => String).

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 module Alf
   module Algebra
-    describe "Allbut", 'keys' do
+    describe Allbut, 'keys' do
 
       let(:operand){
         an_operand.with_heading(id: Integer, name: String, status: String).

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

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Allbut, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          allbut(suppliers, [:sid, :name])
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when projectping unexisting attribute' do
+        let(:op){ 
+          allbut(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){ 
+          allbut(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/autonum/test_type_check.rb

@@ -0,0 +1,30 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Autonum, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          autonum(suppliers, :auto)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when name clash' do
+        let(:op){ 
+          autonum(suppliers, :name)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `name`/)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Clip, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          clip(suppliers, [:sid, :name])
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when clipping unexisting attribute' do
+        let(:op){ 
+          clip(suppliers, [:sid, :unknown])
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `unknown`/)
+        end
+      end
+
+      context 'when clipping unexisting attributes' do
+        let(:op){ 
+          clip(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/coerce/test_type_check.rb

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Coerce, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          coerce(suppliers, sid: Float)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when unexisting attribute' do
+        let(:op){ 
+          coerce(suppliers, sid: Float, unknown: String)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `unknown`/)
+        end
+      end
+
+      context 'when unexisting attributes' do
+        let(:op){ 
+          coerce(suppliers, sid: Float, foo: String, bar: String)
+        }
+
+        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/commons/test_resulting_type.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Operator, "resulting_type" do
+
+      subject{ operator.resulting_type }
+
+      context 'on an unary operator' do
+        let(:operator){
+          project(suppliers, [:sid, :name])
+        }
+
+        it 'returns the expected type' do
+          subject.should eq(Relation[sid: String, name: String])
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/commons/test_to_ascii_tree.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Operator, "to_ascii_tree" do
+
+      subject{ operator.to_ascii_tree }
+
+      context 'on an unary operator' do
+        let(:operator){
+          project(suppliers, [:sid, :name])
+        }
+
+        it 'returns the expected tree' do
+          subject.should eq("project(..., [:sid, :name])\n+-- suppliers\n")
+        end
+      end
+
+      context 'on an unary operator with options' do
+        let(:operator){
+          project(suppliers, [:sid, :name], allbut: true)
+        }
+
+        it 'returns the expected tree' do
+          subject.should eq("project(..., [:sid, :name], {:allbut => true})\n+-- suppliers\n")
+        end
+      end
+
+      context 'on an binary operator' do
+        let(:operator){
+          union(suppliers, parts)
+        }
+
+        it 'returns the expected tree' do
+          subject.should eq("union(...)\n+-- suppliers\n+-- parts\n")
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Extend, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          extend(suppliers, foo: 12)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when clash attribute' do
+        let(:op){ 
+          extend(suppliers, sid: ->{}, foo: 12)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `sid`/)
+        end
+      end
+
+      context 'when unexisting attributes' do
+        let(:op){ 
+          extend(suppliers, sid: ->{}, name: ->{}, bar: String)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `sid`,`name`/)
+        end
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,50 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Group, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          group(suppliers, [:status, :city], :extra)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when ok (allowed overriding)' do
+        let(:op){ 
+          group(suppliers, [:status, :city], :status)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when no such attributes' do
+        let(:op){ 
+          group(suppliers, [:status, :foo, :bar], :extra)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attributes `foo`,`bar`/)
+        end
+      end
+
+      context 'when diasllowed overriding' do
+        let(:op){ 
+          group(suppliers, [:status, :city], :name)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `name`/)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Hierarchize, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          hierarchize(supplies, [:sid], [:pid], :children)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when no such attribute on identifier' do
+        let(:op){ 
+          hierarchize(supplies, [:foo], [:pid], :children)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+      context 'when no such attribute on mapping children' do
+        let(:op){ 
+          hierarchize(supplies, [:sid], [:bar], :children)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `bar`/)
+        end
+      end
+
+      context 'when diasllowed overriding' do
+        let(:op){ 
+          hierarchize(supplies, [:sid], [:pid], :qty)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `qty`/)
+        end
+      end
+
+    end
+  end
+end