alf-core 0.13.1 → 0.14.0

data/spec/unit/alf-relation/relation/class/test_recursive_type.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.type for recursive types' do
+
+    shared_examples_for 'the expected recursive type' do
+      it{ should be_a(Class) }
+
+      it 'should have correct super class' do
+        subject.superclass.should be(Relation)
+      end
+
+      it 'should have correct heading' do
+        subject.heading.should eq(Heading[name: Integer, children: subject])
+      end
+    end
+
+    context 'with a hash' do
+      subject{
+        Relation.type(name: Integer){|r| {children: r} }
+      }
+
+      it_should_behave_like 'the expected recursive type'
+    end
+
+    context 'with a heading' do
+      subject{
+        Relation.type(Heading[name: Integer]){|r| {children: r} }
+      }
+
+      it_should_behave_like 'the expected recursive type'
+    end
+
+    context 'with a tuple type' do
+      subject{
+        Relation.type(Tuple[name: Integer]){|r| {children: r} }
+      }
+
+      it_should_behave_like 'the expected recursive type'
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/test_equality.rb

@@ -8,7 +8,7 @@ module Alf
 
     context '==' do
 
-      it 'returns true for all pairs' do
+      it 'returns true for all pairs above' do
         rel.should eq(subrel)
         subrel.should eq(rel)
         rel.should eq(suprel)
@@ -16,6 +16,24 @@ module Alf
         subrel.should eq(suprel)
         suprel.should eq(subrel)
       end
+
+      it 'returns true on empty relations' do
+        Relation([]).should eq(Relation([]))
+      end
+
+      it 'returns true on empty factored relations' do
+        type = Relation[id: Integer]
+        type.new(Set.new).should eq(type.new(Set.new))
+      end
+
+      it 'returns true on empty recursively defined relations' do
+        type = Relation.type(id: Integer){|r| {children: r} }
+
+        type.new(Set.new).should eq(type.new(Set.new))
+
+        tuple = {id: 1, children: []}
+        type.coerce(tuple).should eq(type.coerce(tuple))
+      end
     end
 
     context 'eql?' do

data/spec/unit/alf-relation/relation/test_relops.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 module Alf
   describe Relation do
 
-    let(:rel1){Alf::Relation(sid: ['S1', 'S2', 'S3']) }
-    let(:rel2){Alf::Relation(sid: ['S5', 'S2'])       }
+    let(:rel1){ Alf::Relation(sid: ['S1', 'S2', 'S3']) }
+    let(:rel2){ Alf::Relation(sid: ['S5', 'S2'])       }
 
     it 'should have all relational operators installed' do
       Algebra::Operator.each do |op|
@@ -58,5 +58,17 @@ module Alf
       (rel1 !~ rel2).should == Alf::Relation(sid: ['S1', 'S3'])
     end # intersect
 
+    specify "page" do
+      rel1.page([[:sid, :asc]], 1, page_size: 2).should == Alf::Relation(sid: ['S1', 'S2'])
+      rel1.page([[:sid, :asc]], -1, page_size: 2).should == Alf::Relation(sid: ['S2', 'S3'])
+      rel1.page([[:sid, :asc]], 2, page_size: 2).should == Alf::Relation(sid: ['S3'])
+      rel1.page([[:sid, :asc]], -2, page_size: 2).should == Alf::Relation(sid: ['S1'])
+    end
+
+    specify "frame" do
+      rel1.frame([[:sid, :asc]], 1, 2).should == Alf::Relation(sid: ['S2', 'S3'])
+      rel1.frame([[:sid, :asc]], 2, 12).should == Alf::Relation(sid: ['S3'])
+    end
+
   end
 end

data/spec/unit/alf-relation/relation/test_to_hash.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Alf
+  describe "Relation#to_hash" do
+
+    let(:rel){
+      Alf::Relation([
+        {sid: 'S1', name: 'Jones', city: 'London', status: 20},
+        {sid: 'S2', name: 'Blake', city: 'London', status: 20},
+      ])
+    }
+
+    specify "with :sid => :name" do
+      rel.to_hash(:sid => :name).should eq('S1' => 'Jones', 'S2' => 'Blake')
+    end
+
+    specify "with :sid => :city" do
+      rel.to_hash(:sid => :city).should eq('S1' => 'London', 'S2' => 'London')
+    end
+
+    specify "with :city => :sid" do
+      lambda{
+        rel.to_hash(:city => :sid)
+      }.should raise_error(/Key expected for `city`, divergence found on `London`/)
+    end
+
+    specify "with :city => :status" do
+      rel.to_hash(:city => :status).should eq('London' => 20)
+    end
+
+  end
+end

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

@@ -3,11 +3,17 @@ module Alf
   module Relvar
     describe Base, "connection" do
 
-      let(:rv){ Base.new(:name, :connection) }
+      let(:expr){
+        Algebra::Operand::Named.new(:aname, :aconn)
+      }
+
+      let(:rv){
+        Base.new(expr)
+      }
 
       subject{ rv.connection }
 
-      it{ should eq(:connection) }
+      it{ should eq(:aconn) }
 
     end
   end

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

@@ -3,8 +3,8 @@ module Alf
   module Relvar
     describe Base, "delete" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:connection){ self                             }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr) }
 
       def delete(*args)
         @seen = args

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

@@ -3,8 +3,8 @@ module Alf
   module Relvar
     describe Base, "heading" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:connection){ self                             }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr) }
 
       def heading(*args)
         @seen = args

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

@@ -3,9 +3,9 @@ module Alf
   module Relvar
     describe Base, "insert" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:tuples)    { Relation.coerce(:id => 1)        }
-      let(:connection){ self                             }
+      let(:expr)  { Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)    { Base.new(expr)                                }
+      let(:tuples){ Relation.coerce(:id => 1)                     }
 
       def insert(*args)
         @seen = args

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

@@ -3,8 +3,8 @@ module Alf
   module Relvar
     describe Base, "keys" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:connection){ self                             }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       def keys(*args)
         @seen = args

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

@@ -3,8 +3,8 @@ module Alf
   module Relvar
     describe Base, "insert" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:connection){ self                             }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       def lock(*args)
         yield(args)

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

@@ -3,11 +3,12 @@ module Alf
   module Relvar
     describe Base, "name" do
 
-      let(:rv){ Base.new(:name, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       subject{ rv.name }
 
-      it{ should eq(:name) }
+      it{ should eq(:suppliers) }
 
     end
   end

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

@@ -3,7 +3,8 @@ module Alf
   module Relvar
     describe Base, 'OO relational language' do
 
-      let(:rv){ Base.new(:suppliers, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       subject{ rv.project([:sid]) }
 

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

@@ -3,8 +3,8 @@ module Alf
   module Relvar
     describe Base, "to_cog" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:connection){ self                             }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       def cog(*args)
         @seen = args
@@ -14,7 +14,7 @@ module Alf
 
       it 'delegates to the connection' do
         subject
-        @seen.should eq([:suppliers])
+        @seen.should eq([:suppliers, rv])
       end
 
     end

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

@@ -3,11 +3,12 @@ module Alf
   module Relvar
     describe Base, "to_lispy" do
 
-      let(:rv){ Base.new(:name, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       subject{ rv.to_lispy }
 
-      it{ should eq("name") }
+      it{ should eq("suppliers") }
 
     end
   end

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

@@ -3,7 +3,8 @@ module Alf
   module Relvar
     describe Base, "to_relvar" do
 
-      let(:rv){ Base.new(:name, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       subject{ rv.to_relvar }
 

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

@@ -3,11 +3,12 @@ module Alf
   module Relvar
     describe Base, "to_s" do
 
-      let(:rv){ Base.new(:name, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:rv)  { Base.new(expr)                                }
 
       subject{ rv.to_s }
 
-      it{ should eq("Relvar::Base(:name)") }
+      it{ should eq("Relvar::Base(:suppliers)") }
 
     end
   end

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

@@ -3,10 +3,11 @@ module Alf
   module Relvar
     describe Base, "update" do
 
-      let(:rv)        { Base.new(:suppliers, connection) }
-      let(:updating)  { {sname: 'Jones'}                 }
-      let(:predicate) { Predicate.eq(:sid, 1)            }
-      let(:connection){ self                             }
+      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

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

@@ -3,11 +3,12 @@ module Alf
   module Relvar
     describe Virtual, "connection" do
 
-      let(:rv){ Virtual.new(:expr, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:aname, :aconn) }
+      let(:rv)  { Virtual.new(expr)                           }
 
       subject{ rv.connection }
 
-      it{ should eq(:connection) }
+      it{ should eq(:aconn) }
 
     end
   end

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

@@ -3,16 +3,15 @@ module Alf
   module Relvar
     describe Virtual, "delete" do
 
-      let(:rv)        { Virtual.new(expr, connection)                 }
-      let(:expr)      { Algebra.named_operand(:suppliers, connection) }
-      let(:connection){ self                                          }
+      let(:rv)        { Virtual.new(expr)                       }
+      let(:expr)      { Algebra.named_operand(:suppliers, self) }
 
       def delete(*args)
         @seen = args
       end
 
       def relvar(name)
-        Relvar::Base.new(name, connection)
+        Relvar::Base.new(Algebra.named_operand(name, self))
       end
 
       context 'with a predicate' do

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

@@ -3,11 +3,12 @@ module Alf
   module Relvar
     describe Virtual, "expr" do
 
-      let(:rv){ Virtual.new(:expr, :connection) }
+      let(:expr){ Algebra::Operand::Named.new(:aname, self) }
+      let(:rv)  { Virtual.new(expr)                         }
 
       subject{ rv.expr }
 
-      it{ should eq(:expr) }
+      it{ should be(expr) }
 
     end
   end

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

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

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

@@ -3,7 +3,7 @@ module Alf
   module Relvar
     describe Virtual, "insert" do
 
-      let(:rv)        { Virtual.new(expr, connection)                 }
+      let(:rv)        { Virtual.new(expr)                             }
       let(:expr)      { Algebra.named_operand(:suppliers, connection) }
       let(:tuples)    { Relation.coerce(:id => 1)                     }
       let(:connection){ self                                          }
@@ -13,7 +13,7 @@ module Alf
       end
 
       def relvar(name)
-        Relvar::Base.new(name, connection)
+        Relvar::Base.new(name)
       end
 
       subject{ rv.insert(tuples) }

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

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

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

@@ -3,8 +3,9 @@ module Alf
   module Relvar
     describe Virtual, 'OO relational language' do
 
-      let(:base){ Base.new(:suppliers, :connection) }
-      let(:rv)  { Virtual.new(base, :connection)    }
+      let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
+      let(:base){ Base.new(expr)                                }
+      let(:rv)  { Virtual.new(base)                             }
 
       subject{ rv.project([:sid]) }
 
@@ -24,6 +25,10 @@ module Alf
         subject.expr.operand.should be(base)
       end
 
+      it 'should be kept bound' do
+        subject.should be_bound
+      end
+
     end
   end
 end