alf-core 0.13.0

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '==' do
+
+    let(:type){ Relation[name: String, status: Integer] }
+
+    subject{ type == other }
+
+    context 'with itself' do
+      let(:other){ type }
+
+      it{ should be_true }
+    end
+
+    context 'with another equivalent' do
+      let(:other){ Relation[name: String, status: Integer] }
+
+      it{ should be_true }
+    end
+
+    context 'with another, non equivalent' do
+      let(:other){ Relation[name: String] }
+
+      it{ should be_false }
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_project.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.project' do
+
+    let(:type){ Relation[name: String, status: Integer] }
+
+    subject{ type.project(attr_list) }
+
+    context 'with an empty attribute list' do
+      let(:attr_list){ AttrList.new([]) }
+
+      it 'projects as expected' do
+        subject.should be(Relation::DUM.class)
+      end
+    end
+
+    context 'with an non empty attribute list' do
+      let(:attr_list){ AttrList.new([:name]) }
+
+      it 'projects as expected' do
+        subject.should eq(Relation[name: String])
+      end
+    end
+
+    context 'with a full attribute list' do
+      let(:attr_list){ AttrList.new([:name, :status]) }
+
+      it 'reuses the initial instance' do
+        subject.should be(type)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_rename.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.rename' do
+
+    let(:type){ Relation[name: String, status: Integer] }
+
+    subject{ type.rename(name: :first_name) }
+
+    it{ should eq(Relation[first_name: String, status: Integer]) }
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_split.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.split' do
+
+    let(:type){ Relation[name: String, status: Integer] }
+
+    subject{ type.split(attr_list) }
+
+    context 'with an empty attribute list' do
+      let(:attr_list){ AttrList.new([]) }
+
+      it 'splits as expected' do
+        subject.should eq([ Relation[{}], type ])
+      end
+
+      it 'reuses the initial instance' do
+        subject.last.should be(type)
+      end
+    end
+
+    context 'with an non empty attribute list' do
+      let(:attr_list){ AttrList.new([:name]) }
+
+      it 'splits as expected' do
+        subject.should eq([ Relation[name: String], Relation[status: Integer] ])
+      end
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_to_ruby_literal.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  describe Relation, 'to_ruby_literal' do
+
+    let(:type){ Relation[name: String, status: Integer] }
+
+    subject{ type.to_ruby_literal }
+
+    it 'should be human friendly' do
+      subject.should eq("Alf::Relation[{:name => String, :status => Integer}]")
+    end
+
+    it 'should allow eval roundtrip' do
+      ::Kernel.eval(subject).should eq(type)
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/factored-types/test_triple_equal.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '===' do
+
+    let(:type){ Relation[heading] }
+
+    subject{ type === value }
+
+    context 'when the exact types' do
+      let(:heading){ Heading.new(name: String, status: Fixnum) }
+
+      context 'on a valid value built with itself' do
+        let(:value){ type.coerce(name: "Smith", status: 20) }
+
+        it{ should be_true }
+      end
+
+      context 'on a valid value but built with Relation' do
+        let(:value){ Relation.coerce(name: "Smith", status: 20) }
+
+        it{ should be_true }
+      end
+    end
+
+    context 'with a super type' do
+      let(:heading){ Heading.new(name: String, status: Integer) }
+
+      context 'on a valid value built with itself' do
+        let(:value){ type.coerce(name: "Smith", status: 20) }
+
+        it{ should be_true }
+      end
+
+      context 'on a valid value but built with Relation' do
+        let(:value){ Relation.coerce(name: "Smith", status: 20) }
+
+        it{ should be_true }
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  describe Relation, "aggregation methods" do
+
+    let(:rel){ Alf::Relation(qty: [1, 2, 3, 4]) }
+
+    it "avg" do
+      rel.avg{ qty }.should eq(2.5)
+    end
+
+    it "collect", :ruby19 => true do
+      rel.collect{ qty }.should eq([1, 2, 3, 4])
+    end
+
+    it "concat", :ruby19 => true do
+      rel.concat{ qty }.should eq("1234")
+    end
+
+    it "count" do
+      rel.count.should eq(4)
+    end
+
+    it "max" do
+      rel.max{ qty }.should eq(4)
+    end
+
+    it "min" do
+      rel.min{ qty }.should eq(1)
+    end
+
+    it "sum" do
+      rel.sum{ qty }.should eq(10)
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  describe Relation, "equality" do
+
+    let(:rel)   { Relation[id: Integer].coerce(id: 12) }
+    let(:subrel){ Relation[id:  Fixnum].coerce(id: 12) }
+    let(:suprel){ Relation[id: Numeric].coerce(id: 12) }
+
+    context '==' do
+
+      it 'returns true for all pairs' do
+        rel.should eq(subrel)
+        subrel.should eq(rel)
+        rel.should eq(suprel)
+        suprel.should eq(rel)
+        subrel.should eq(suprel)
+        suprel.should eq(subrel)
+      end
+    end
+
+    context 'eql?' do
+
+      it 'returns true for all pairs' do
+        rel.should eql(subrel)
+        subrel.should eql(rel)
+        rel.should eql(suprel)
+        suprel.should eql(rel)
+        subrel.should eql(suprel)
+        suprel.should eql(subrel)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  describe Relation, 'hash' do
+
+    let(:tuple){ Relation[id: Integer].coerce(id: 12) }
+
+    subject{ tuple.hash == other.hash }
+
+    context 'on purely equal relation' do
+      let(:other){ Relation[id: Integer].coerce(id: 12) }
+
+      it{ should be_true }
+    end
+
+    context 'on equal relation but a subtype' do
+      let(:other){ Relation[id: Fixnum].coerce(id: 12) }
+
+      it{ should be_true }
+    end
+
+    context 'on equal relation but a supertype' do
+      let(:other){ Relation[id: Numeric].coerce(id: 12) }
+
+      it{ should be_true }
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  describe "Relation#heading" do
+
+    let(:rel){
+      Relation([
+        {:max => 2,   :name => "Jones"},
+        {:max => 7.3, :name => "Jones"},
+      ])
+    }
+
+    subject{ rel.heading }
+
+    it{ should eq(Heading(:max => Numeric, :name => String)) }
+
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Relation do
+    
+    let(:rel){Relation.coerce([
+      {:sid => 'S1'},
+      {:sid => 'S2'},
+      {:sid => 'S3'}
+    ])}
+    
+    describe "inspect" do
+      
+      it "should allows the litteral round-trip" do
+        Kernel.eval(rel.inspect).should == rel
+      end
+
+    end # coerce
+      
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'spec_helper'
+module Alf
+  describe Relation do
+
+    let(:tuples){[
+      {:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'},
+      {:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'},
+      {:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+    ]}
+    let(:tuples2){ tuples.sort{|t1,t2| t1[:name] <=> t2[:name]} }
+
+    let(:rel1){ Relation.coerce(tuples) }
+    let(:rel2){ Relation.coerce(tuples2) }
+    let(:rel3){ Relation.coerce(tuples[0..1]) }
+
+    it "should have a cardinality method" do
+      rel1.cardinality.should == 3
+    end
+
+    it "should have an empty? method" do
+      Alf::Relation::DUM.should be_empty
+      Alf::Relation::DEE.should_not be_empty
+      rel1.should_not be_empty
+    end
+
+    it "should define == correctly" do
+      rel1.should eq(rel2)
+      rel2.should eq(rel1)
+      rel3.should_not eq(rel1)
+    end
+
+    it "should define eql? correctly" do
+      rel1.should eql(rel2)
+      rel2.should eql(rel1)
+      rel3.should_not eql(rel1)
+    end
+
+    it "should define hash correctly" do
+      rel1.hash.should eq(rel2.hash)
+    end
+
+    it "should allow putting them in hashes" do
+      h = {}
+      h[rel1] = 1
+      h[rel2] = 2
+      h[rel3] = 3
+      h.size.should == 2
+      h[rel1].should == 2
+    end
+
+    describe "rel1" do
+      subject{ rel1 }
+      it_should_behave_like "A value"
+    end
+
+    describe "DUM" do
+      subject{ Relation::DUM }
+      it_should_behave_like "A value"
+      specify{
+        subject.cardinality.should == 0
+        subject.to_a.should == []
+        subject.should be_empty
+      }
+    end
+
+    describe "DEE" do
+      subject{ Relation::DEE }
+      it_should_behave_like "A value"
+      specify{
+        subject.cardinality.should == 1
+        subject.to_a.should == [Tuple::EMPTY]
+        subject.should_not be_empty
+      }
+    end
+
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'spec_helper'
+module Alf
+  describe Relation do
+
+    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|
+        rel1.should respond_to(op.rubycase_name)
+      end
+    end
+
+    specify "project" do
+      rel1.project([]).should eq(Alf::Relation::DEE)
+      rel1.project([:sid], allbut: true).should eq(Alf::Relation::DEE)
+    end
+
+    specify "allbut" do
+      rel1.allbut([:sid]).should eq(Alf::Relation::DEE)
+    end
+
+    specify "extend" do
+      rel1.extend(x: lambda{ sid.downcase }).should == Alf::Relation([
+        {sid: 'S1', x: 's1'},
+        {sid: 'S2', x: 's2'},
+        {sid: 'S3', x: 's3'}
+      ])
+    end
+
+    specify "union" do
+      (rel1 + rel1).should == rel1
+      (rel1 | rel1).should == rel1
+      (rel1 + rel2).should == Alf::Relation(sid: ['S1','S3','S2','S5'])
+    end # union
+
+    specify "difference" do
+      (rel1 - rel1).should == Alf::Relation::DUM
+      (rel1 - rel2).should == Alf::Relation(sid: ['S1', 'S3'])
+      (rel2 - rel1).should == Alf::Relation(sid: 'S5')
+    end # difference
+
+    specify "join" do
+      (rel1 * rel2).should == Alf::Relation(sid: 'S2')
+      (rel2 * rel1).should == Alf::Relation(sid: 'S2')
+    end # join
+
+    specify "intersect" do
+      (rel1 & rel2).should == Alf::Relation(sid: 'S2')
+      (rel2 & rel1).should == Alf::Relation(sid: 'S2')
+    end # intersect
+
+    specify "matching" do
+      (rel1 =~ rel2).should == Alf::Relation(sid: 'S2')
+    end # intersect
+
+    specify "not matching" do
+      (rel1 !~ rel2).should == Alf::Relation(sid: ['S1', 'S3'])
+    end # intersect
+
+  end
+end