alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-optimizer/test_infer_heading.rb

@@ -1,9 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  describe "infer_heading" do
-
-    subject{ infer_heading(an_operand) }
-
-    it_should_behave_like "an unoptimizable expression for restrict"
-  end
-end

data/spec/unit/alf-predicate/grammar/test_parse.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe Grammar, 'parse' do
-
-      let(:source){ "x < 2" }
-
-      subject{ Grammar.parse(source) }
-
-      it{ should be_a(Sexpr) }
-      it{ should be_a(Native) }
-
-      specify{
-        subject.to_ruby_code.should eq("x < 2")
-      }
-
-      specify{
-        subject.to_proc.to_ruby_literal.should eq("lambda{ x < 2 }")
-      }
-      
-    end
-  end
-end

data/spec/unit/alf-predicate/nodes/var_ref/test_var_name.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Predicate
-    describe VarRef, "var_name" do
-
-      let(:expr){ Factory.var_ref(:id) }
-
-      subject{ expr.var_name }
-
-      it{ should eq(:id) }
-
-    end
-  end
-end

data/spec/unit/alf-relvar/base/test_name.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Base, "name" do
-
-      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
-      let(:rv)  { Base.new(expr)                                }
-
-      subject{ rv.name }
-
-      it{ should eq(:suppliers) }
-
-    end
-  end
-end

data/spec/unit/alf-relvar/virtual/test_connection.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, "connection" do
-
-      let(:expr){ Algebra::Operand::Named.new(:aname, :aconn) }
-      let(:rv)  { Virtual.new(expr)                           }
-
-      subject{ rv.connection }
-
-      it{ should eq(:aconn) }
-
-    end
-  end
-end

data/spec/unit/alf-support/bindable/test_bind.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Bindable, "bind" do
-
-      let(:bindable){ clazz.new  }
-      let(:conn)    { Object.new }
-
-      subject{ bindable.bind(conn) }
-
-      context 'when called from the ouside' do
-        let(:clazz){
-          Class.new{ include Bindable }
-        }
-
-        it 'returns a dup of the original bindable' do
-          subject.should be_a(clazz)
-          subject.should_not be(bindable)
-        end
-
-        it 'sets the connection on the new one' do
-          subject.connection.should be(conn)
-        end
-
-        it 'lets the original one unchanged' do
-          bindable.connection.should be_nil
-        end
-      end
-
-      context 'when called from a subclass' do
-        let(:clazz){
-          Class.new{
-            attr_accessor :name
-            include Bindable
-            def initialize
-              @name = "default"
-            end
-            def bind(conn)
-              super(conn){|c| c.name = "changed" }
-            end
-          }
-        }
-
-        it 'sets the connection on the new one' do
-          subject.connection.should be(conn)
-        end
-
-        it 'returns a copy with name being changed' do
-          subject.name.should eq("changed")
-        end
-
-        it 'lets the original one unchanged' do
-          bindable.name.should eq("default")
-          bindable.connection.should be_nil
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/bindable/test_bound.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Bindable, "bound?" do
-
-      let(:clazz){
-        Class.new{
-          include Bindable
-          def initialize(conn = nil)
-            @connection = conn
-          end
-        }
-      }
-
-      subject{ bindable.bound? }
-
-      context 'on an unbound object' do
-        let(:bindable){ clazz.new }
-
-        it{ should be_false }
-      end
-
-      context 'on a bound object' do
-        let(:bindable){ clazz.new(self) }
-
-        it{ should be_true }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/bindable/test_connection.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Bindable, "connection" do
-
-      let(:clazz){
-        Class.new{
-          include Bindable
-          def initialize(conn = nil)
-            @connection = conn
-          end
-        }
-      }
-
-      subject{ bindable.connection }
-
-      context 'on an unbound object' do
-        let(:bindable){ clazz.new }
-
-        it{ should be_nil }
-      end
-
-      context 'on a bound object' do
-        let(:bindable){ clazz.new(self) }
-
-        it{ should be(self) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-support/bindable/test_connection_bang.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Support
-    describe Bindable, "connection!" do
-
-      let(:clazz){
-        Class.new{
-          include Bindable
-          def initialize(conn = nil)
-            @connection = conn
-          end
-        }
-      }
-
-      subject{ bindable.connection! }
-
-      context 'on an unbound object' do
-        let(:bindable){ clazz.new }
-
-        it 'raises an UnboundError' do
-          lambda{
-            subject
-          }.should raise_error(UnboundError)
-        end
-      end
-
-      context 'on a bound object' do
-        let(:bindable){ clazz.new(self) }
-
-        it{ should be(self) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-update/inserter/test_type_safe.rb

@@ -1,72 +0,0 @@
-require 'update_helper'
-module Alf
-  module Update
-    describe Inserter, 'type_safe' do
-
-      subject{ insert(expr, inserted); db_context.requests }
-
-      context 'when not strict' do
-        let(:expr){ type_safe(suppliers, {status: Integer, name: String}) }
-
-        context 'when the inserted tuples are ok' do
-          let(:inserted) { [ {status: 10, name: "Smith"} ] }
-
-          it 'does not complain and passes the tuples through' do
-            subject.should eq([ [:insert, :suppliers, inserted] ])
-          end
-        end
-
-        context 'when the inserted tuples are projections' do
-          let(:inserted) { [ {status: 10} ] }
-
-          it 'does not complain and passes the tuples through' do
-            subject.should eq([ [:insert, :suppliers, inserted] ])
-          end
-        end
-
-        context 'when the inserted tuples are ko' do
-          let(:inserted) { [ {status: '10'} ] }
-
-          it 'complains with a TypeCheckError' do
-            lambda{
-              subject
-            }.should raise_error(TypeCheckError)
-          end
-        end
-      end
-
-      context 'when strict' do
-        let(:expr){ type_safe(suppliers, {status: Integer, name: String}, strict: true) }
-
-        context 'when the inserted tuples are ok' do
-          let(:inserted) { [ {status: 10, name: "Smith"} ] }
-
-          it 'does not complain and passes the tuples through' do
-            subject.should eq([ [:insert, :suppliers, inserted] ])
-          end
-        end
-
-        context 'when the inserted tuples are projections' do
-          let(:inserted) { [ {status: 10} ] }
-
-          it 'complains with a TypeCheckError' do
-            lambda{
-              subject
-            }.should raise_error(TypeCheckError)
-          end
-        end
-
-        context 'when the inserted tuples are ko' do
-          let(:inserted) { [ {status: '10'} ] }
-
-          it 'complains with a TypeCheckError' do
-            lambda{
-              subject
-            }.should raise_error(TypeCheckError)
-          end
-        end
-      end
-
-    end
-  end
-end