alf-core 0.15.0 → 0.16.0

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

@@ -1,55 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Allbut, '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.allbut(operand, [:name])
-        }
-
-        it { should be_true }
-      end
-
-      context 'when projecting all keys away' do
-        let(:op){ 
-          a_lispy.allbut(operand, [:id, :name])
-        }
-
-        it { should be_false }
-      end
-
-      context 'when the operand is a restriction on the key' do
-        let(:operand){
-          an_operand.with_heading(sid: Integer, name: String)
-                    .with_keys([:sid])
-        }
-        let(:op){
-          a_lispy.allbut(a_lispy.restrict(operand, sid: 1), [:name])
-        }
-
-        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.allbut(a_lispy.restrict(operand, sid: 1), [:sid])
-        }
-
-        it { should be_true }
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Allbut, 'keys' do
-
-      let(:operand){
-        an_operand.with_heading(id: Integer, name: String, status: String).
-                   with_keys([:id], [:name])
-      }
-
-      subject{ op.keys }
-
-      context 'when conserving at least one key' do
-        let(:op){
-          a_lispy.allbut(operand, [:name])
-        }
-        let(:expected){
-          Keys[ [:id] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when projecting all keys away through --allbut' do
-        let(:op){
-          a_lispy.allbut(operand, [:id, :name])
-        }
-        let(:expected){
-          Keys[ [:status] ]
-        }
-
-        it { should eq(expected) }
-      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.allbut(a_lispy.restrict(operand, sid: 1), [:sid])
-        }
-        let(:expected){
-          Keys[ [:pid] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

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

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

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

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

@@ -1,22 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Autonum, 'heading' do
-
-      let(:operand){
-        an_operand.with_keys([:name])
-      }
-      let(:op){ 
-        a_lispy.autonum(operand, :auto)
-      }
-      let(:expected){
-        Keys[[:name], [:auto]]
-      }
-
-      subject{ op.keys }
-
-      it { should eq(expected) }
-
-    end
-  end
-end

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

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

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

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

@@ -1,48 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Clip, 'keys' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String, :status => String).
-                   with_keys([:id], [:name])
-      }
-
-      subject{ op.keys }
-
-      context 'when conserving at least one key' do
-        let(:op){ 
-          a_lispy.clip(operand, [:id, :status])
-        }
-        let(:expected){
-          Keys[ [:id] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when conserving at least one key (--allbut)' do
-        let(:op){ 
-          a_lispy.clip(operand, [:name], :allbut => true)
-        }
-        let(:expected){
-          Keys[ [:id] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when projecting all keys away' do
-        let(:op){ 
-          a_lispy.clip(operand, [:status])
-        }
-        let(:expected){
-          Keys[ [:status] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

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

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

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

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

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

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

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