alf-core 0.15.0 → 0.16.0

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

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

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

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Base, "update" do
-
-      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
-      let(:rv)  { Base.new(expr)                                }
-
-      let(:updating)  { {sname: 'Jones'}      }
-      let(:predicate) { Predicate.eq(:sid, 1) }
-
-      def update(*args)
-        @seen = args
-      end
-
-      subject{ rv.update(updating, predicate) }
-
-      it 'delegates the call to the connection' do
-        subject
-        @seen.should eq([:suppliers, updating, predicate])
-      end
-
-    end
-  end
-end

data/spec/unit/alf-relvar/read_only/test_to_relation.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe ReadOnly, "to_relation" do
-
-      let(:value){ Relation(id: 1)     }
-      let(:rv)   { ReadOnly.new(value) }
-
-      subject{ rv.to_relation }
-
-      it 'is as expected' do
-        subject.should be(value)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-relvar/read_only/test_type.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe ReadOnly, "type" do
-
-      let(:value){ Relation(id: 1)     }
-      let(:rv)   { ReadOnly.new(value) }
-
-      subject{ rv.type }
-
-      it 'is as expected' do
-        subject.should eq(Relation[id: Fixnum])
-      end
-
-    end
-  end
-end

data/spec/unit/alf-relvar/shared/test_empty.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relvar, 'empty?' do
-    include Relvar
-
-    subject{ empty? }
-
-    context 'on an empty relvar' do
-      let(:to_cog){ [] }
-
-      it{ should be_true }
-    end
-
-    context 'on an non empty relvar' do
-      let(:to_cog){ [ 1 ] }
-
-      it{ should be_false }
-    end
-
-  end
-end

data/spec/unit/alf-relvar/shared/test_empty_bang.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relvar, 'empty!' do
-    include Relvar
-
-    subject{ empty! }
-
-    context 'on an empty relvar' do
-      let(:to_cog){ [] }
-
-      it{ should be(self) }
-    end
-
-    context 'on an non empty relvar' do
-      let(:to_cog){ [ 1 ] }
-
-      it "should raise a fact error" do
-        lambda{ subject }.should raise_error(Alf::FactAssertionError)
-      end
-    end
-
-    context 'on an non empty relvar with an error message' do
-      let(:to_cog){ [ 1 ] }
-
-      it "should raise a fact error" do
-        lambda{ empty!("foo") }.should raise_error(Alf::FactAssertionError, /foo/)
-      end
-    end
-
-  end
-end

data/spec/unit/alf-relvar/shared/test_not_empty_bang.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relvar, 'not_empty!' do
-    include Relvar
-
-    subject{ not_empty! }
-
-    context 'on an empty relvar' do
-      let(:to_cog){ [] }
-
-      it "should raise a fact error" do
-        lambda{ subject }.should raise_error(Alf::FactAssertionError)
-      end
-    end
-
-    context 'on an non empty relvar' do
-      let(:to_cog){ [ 1 ] }
-
-      it{ should be(self) }
-    end
-
-    context 'on an empty relvar with an error message' do
-      let(:to_cog){ [] }
-
-      it "should raise a fact error" do
-        lambda{ not_empty!("foo") }.should raise_error(Alf::FactAssertionError, /foo/)
-      end
-    end
-
-  end
-end

data/spec/unit/alf-relvar/shared/test_to_relation.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relvar, 'to_relation' do
-    include Relvar
-
-    subject{ to_relation }
-
-    let(:expected_value){ Relation(sid: 1, name: "Smith") }
-
-    def to_cog
-      [{sid: 1, name: "Smith"}]
-    end
-
-    context 'when the heading is supported' do
-
-      def heading(*)
-        Heading.new(sid: Integer, name: String)
-      end
-
-      it 'trusts the heading' do
-        subject.class.heading[:sid].should eq(Integer)
-      end
-
-      it 'gets the tuples from the cog' do
-        subject.should eq(expected_value)
-      end
-    end
-
-    context 'when the heading is not supported' do
-
-      def heading(*)
-        raise NotSupportedError
-      end
-
-      it 'infers the heading' do
-        subject.class.heading[:sid].should eq(Fixnum)
-      end
-
-      it 'gets the tuples from the cog' do
-        subject.should eq(expected_value)
-      end
-    end
-
-  end
-end

data/spec/unit/alf-relvar/shared/test_type.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relvar, 'type' do
-    include Relvar
-
-    def heading(*)
-      Heading.new(sid: Integer, name: String)
-    end
-
-    subject{ type }
-
-    it 'returns the expected type' do
-      subject.should eq(Relation[heading])
-    end
-
-    it 'memoizes used instance' do
-      subject.should be(type)
-    end
-
-  end
-end

data/spec/unit/alf-relvar/shared/test_upsert.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relvar, "upsert" do
-    include Relvar
-
-    let(:tuples){ Relation.coerce(:id => 1) }
-
-    def insert(*args)
-      @method = :insert
-      @seen = args
-    end
-
-    def update(*args)
-      @method = :update
-      @seen = args
-    end
-
-    subject{ upsert(tuples) }
-
-    context 'when the relvar is not empty' do
-      let(:empty?){ false }
-
-      it 'delegates an update to the connection' do
-        subject
-        @method.should eq(:update)
-        @seen.should eq([tuples])
-      end
-    end
-
-    context 'when the relvar is empty' do
-      let(:empty?){ true }
-
-      it 'delegates an insert to the connection' do
-        subject
-        @method.should eq(:insert)
-        @seen.should eq([tuples])
-      end
-    end
-
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, "delete" do
-
-      let(:rv)        { Virtual.new(expr)                       }
-      let(:expr)      { Algebra.named_operand(:suppliers, self) }
-
-      def delete(*args)
-        @seen = args
-      end
-
-      def relvar(name)
-        Relvar::Base.new(Algebra.named_operand(name, self))
-      end
-
-      context 'with a predicate' do
-        let(:predicate) { Predicate.eq(:sid, 1) }
-
-        subject{ rv.delete(predicate) }
-
-        it 'delegates the call to the connection' do
-          subject
-          @seen.should eq([:suppliers, predicate])
-        end
-      end
-
-      context 'without predicate' do
-
-        subject{ rv.delete }
-
-        it 'uses a tautology' do
-          subject
-          @seen.should eq([:suppliers, Predicate.tautology])
-        end
-      end
-
-    end
-  end
-end

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

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

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, "heading" do
-
-      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
-      let(:rv)  { Virtual.new(expr)                         }
-
-      def heading(name)
-        "a heading for #{name}"
-      end
-
-      subject{ rv.heading }
-
-      it 'delegates to the expression' do
-        subject.should eq("a heading for aname")
-      end
-
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, "insert" do
-
-      let(:rv)        { Virtual.new(expr)                             }
-      let(:expr)      { Algebra.named_operand(:suppliers, connection) }
-      let(:tuples)    { Relation.coerce(:id => 1)                     }
-      let(:connection){ self                                          }
-
-      def insert(name, tuples)
-        @seen = [name, tuples.to_relation]
-      end
-
-      def relvar(name)
-        Relvar::Base.new(name)
-      end
-
-      subject{ rv.insert(tuples) }
-
-      it 'delegates the call to the connection' do
-        subject
-        @seen.should eq([:suppliers, tuples])
-      end
-
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, "keys" do
-
-      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
-      let(:rv)  { Virtual.new(expr)                         }
-
-      def keys(name)
-        "some keys for #{name}"
-      end
-
-      subject{ rv.keys }
-
-      it 'delegates to the expression' do
-        subject.should eq("some keys for aname")
-      end
-
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, 'OO relational language' do
-
-      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
-      let(:base){ Base.new(expr)                                }
-      let(:rv)  { Virtual.new(base)                             }
-
-      subject{ rv.project([:sid]) }
-
-      it 'is a relation variable' do
-        subject.should be_a(Relvar)
-      end
-
-      it 'is a virtual relation variable' do
-        subject.should be_a(Relvar::Virtual)
-      end
-
-      it 'should have a projection expression' do
-        subject.expr.should be_a(Algebra::Project)
-      end
-
-      it 'should have the base relvar as projection operand' do
-        subject.expr.operand.should be(base)
-      end
-
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Relvar
-    describe Virtual, "to_cog" do
-
-      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
-      let(:rv)  { Virtual.new(expr)                         }
-
-      subject{ rv.to_cog(12) }
-
-      def cog(*args)
-        @seen = args
-      end
-
-      it{ should eq([12, expr]) }
-
-    end
-  end
-end