alf-core 0.15.0 → 0.16.0

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Project, 'heading' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String)
-      }
-
-      subject{ op.heading }
-
-      context '-no-allbut' do
-        let(:op){ 
-          a_lispy.project(operand, [:id])
-        }
-        let(:expected){
-          Heading[:id => Integer]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context '--allbut' do
-        let(:op){ 
-          a_lispy.project(operand, [:name], :allbut => true)
-        }
-        let(:expected){
-          Heading[:id => Integer]
-        }
-
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Project, 'key_preserving?' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String, :status => String).
-                   with_keys([:id], [:name])
-      }
-
-      subject{ op.key_preserving? }
-
-      context 'when conserving at least one key' do
-        let(:op){ 
-          a_lispy.project(operand, [:id, :status])
-        }
-
-        it { should be_true }
-      end
-
-      context 'when projecting all keys away' do
-        let(:op){ 
-          a_lispy.project(operand, [:status])
-        }
-
-        it { should be_false }
-      end
-
-      context 'when the operand is a restriction on the key' do
-        ## [:sid]
-        let(:operand){
-          an_operand.with_heading(sid: Integer, name: String)
-                    .with_keys([:sid])
-        }
-        # restrict: []
-        # project: []
-        let(:op){
-          a_lispy.project(a_lispy.restrict(operand, sid: 1), [:sid])
-        }
-
-        it { should be_true }
-      end
-
-      context 'when a key is projected due to a constant restriction' do
-        let(:operand){
-          an_operand.with_heading(sid: Integer, pid: Integer)
-                    .with_keys([:sid, :pid])
-        }
-        let(:op){
-          a_lispy.project(a_lispy.restrict(operand, sid: 1), [:pid])
-        }
-
-        it { should be_true }
-      end
-
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Project, 'keys' do
-
-      subject{ op.keys }
-
-      context 'with two single keys' do
-        let(:operand){
-          an_operand.with_heading(id: Integer, name: String, status: String, city: String).
-                     with_keys([:id], [:name])
-        }
-
-        context 'when conserving at least one key' do
-          let(:op){
-            a_lispy.project(operand, [:id, :status])
-          }
-          let(:expected){
-            Keys[ [:id] ]
-          }
-
-          it { should eq(expected) }
-        end
-
-        context 'when projecting all keys away' do
-          let(:op){
-            a_lispy.project(operand, [:status])
-          }
-          let(:expected){
-            Keys[ [:status] ]
-          }
-
-          it { should eq(expected) }
-        end
-      end
-
-      context 'when a key is cut' do
-        # 1, 1, 1
-        # 1, 2, 3
-        let(:operand){
-          an_operand.with_heading(sid: Integer, pid: Integer, qty: Integer)
-                    .with_keys([:sid, :pid])
-        }
-        # 1, _, 1
-        # 1, _, 3
-        let(:op){
-          a_lispy.project(operand, [:sid, :qty])
-        }
-        let(:expected){
-          Keys[ [:sid, :qty] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when a key is projected due to a constant restriction' do
-        # 1, 1, 1
-        # 1, 2, 3
-        let(:operand){
-          an_operand.with_heading(sid: Integer, pid: Integer)
-                    .with_keys([:sid, :pid])
-        }
-        # 1, _, 1
-        let(:op){
-          a_lispy.project(a_lispy.restrict(operand, pid: 1), [:sid, :qty])
-        }
-        let(:expected){
-          Keys[ [:sid] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when a projection leads to an empty key' do
-        ## 1, Jones
-        let(:operand){
-          an_operand.with_heading(sid: Integer, name: String)
-                    .with_keys([:sid])
-        }
-        let(:op){
-          a_lispy.project(a_lispy.restrict(operand, sid: 1), [:sid])
-        }
-
-        it { should eq(Keys[[]]) }
-      end
-
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-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_heading.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Quota, 'heading' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String)
-      }
-      let(:op){ 
-        a_lispy.quota(operand, [:id], [[:name, :asc]], :sum => a_lispy.sum{ id })
-      }
-
-      subject{ op.heading }
-
-      let(:expected){
-        Heading[:id => Integer, :name => String, :sum => Object]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Quota, 'keys' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String).with_keys([ :id ])
-      }
-      let(:op){ 
-        a_lispy.quota(operand, [:id], [[:name, :asc]], :sum => a_lispy.sum{ id })
-      }
-
-      subject{ op.keys }
-
-      let(:expected){
-        Keys[ [ :id ] ]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-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_heading.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Rank, 'heading' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String)
-      }
-      let(:op){ 
-        a_lispy.rank(operand, [[:name, :asc]], :rank)
-      }
-
-      subject{ op.heading }
-
-      let(:expected){
-        Heading[:id => Integer, :name => String, :rank => Integer]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Rank, 'keys' do
-
-      let(:operand){
-        an_operand.with_heading(id: Integer, name: String, hobby: Tuple[name: String]).with_keys([:id])
-      }
-
-      subject{ op.keys }
-
-      context 'when the order relation does not contain a key' do
-        let(:op){ 
-          a_lispy.rank(operand, [[:name, :asc]], :rank)
-        }
-        let(:expected){
-          Keys[ [:id] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when the order relation does contain a key' do
-        let(:op){ 
-          a_lispy.rank(operand, [[[:hobby, :name], :asc], [:id, :desc]], :rank)
-        }
-        let(:expected){
-          Keys[ [:id], [:rank] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-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

data/spec/unit/alf-algebra/operator/rename/test_complete_renaming.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Rename, 'complete_renaming' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String)
-      }
-      let(:op){ 
-        a_lispy.rename(operand, :name => :foo)
-      }
-
-      subject{ op.complete_renaming }
-
-      let(:expected){
-        Renaming[:id => :id, :name => :foo]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end