alf-core 0.13.0

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '[]' do
+
+    let(:rel){ Alf::Relation(sid: 'S1', sname: "Jones", city: "London") }
+
+    context 'as a selection' do
+      subject{ rel[:pid => :sid] }
+
+      let(:expected){ Alf::Relation(pid: 'S1') }
+
+      it{ should eq(expected) }
+    end
+
+    context 'as a selection mixing symbols and values' do
+      subject{ rel[pid: :sid, test: ""] }
+
+      let(:expected){ Alf::Relation(pid: 'S1', test: "") }
+
+      it{ should eq(expected) }
+    end
+
+    context 'as a selection mixing list, then selection' do
+      subject{ rel[:sid, pid: :sid, test: ""] }
+
+      let(:expected){ Alf::Relation(sid: 'S1', pid: 'S1', test: "") }
+
+      it{ should eq(expected) }
+    end
+
+    context 'as a projection' do
+      subject{ rel[:sid, :city] }
+
+      let(:expected){ Alf::Relation(sid: 'S1', city: "London") }
+
+      it{ should eq(expected) }
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Alf
+  describe "Relation#to_a" do
+
+    let(:rel){Alf::Relation(sid: ['S2', 'S1', 'S3']) }
+
+    specify "without an ordering key" do
+      rel.to_a.sort{|k1,k2| k1[:sid] <=> k2[:sid]}.should eq([
+        Tuple(:sid => 'S1'),
+        Tuple(:sid => 'S2'),
+        Tuple(:sid => 'S3')
+      ])
+    end
+
+    specify "with an ordering key" do
+      rel.to_a([:sid]).should eq([
+        Tuple(:sid => 'S1'),
+        Tuple(:sid => 'S2'),
+        Tuple(:sid => 'S3')
+      ])
+      rel.to_a([[:sid, :desc]]).should eq([
+        Tuple(:sid => 'S3'),
+        Tuple(:sid => 'S2'),
+        Tuple(:sid => 'S1')
+      ])
+    end
+
+    specify "ON DUM" do
+      Relation::DUM.to_a.should eq([])
+    end
+
+    specify "ON DEE" do
+      Relation::DEE.to_a.should eq([Tuple::EMPTY])
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe "Relation#to_relation" do
+
+    let(:rel){ Relation(:sid => ['S1', 'S2', 'S3']) }
+
+    subject{ rel.to_relation }
+
+    it 'should return self' do
+      subject.object_id.should eq(rel.object_id)
+    end
+
+  end
+end

data/spec/unit/alf-relation/tuple/class/test_coerce.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, '.coerce' do
+
+      subject{ Tuple.coerce(arg) }
+
+      let(:expected){ Tuple[name: String].new(:name => "bla") }
+
+      context 'on self' do
+        let(:arg){ expected }
+
+        it { should be(expected) }
+      end
+
+      context 'on a Tuple' do
+        let(:arg){ Tuple[name: String].new(:name => "bla") }
+
+        it{ should eq(expected) }
+      end
+
+      context 'on an unsymbolized Hash' do
+        let(:arg){ {'name' => "bla"} }
+
+        it{ should eq(expected) }
+      end
+    end
+  end
+end

data/spec/unit/alf-relation/tuple/class/test_type.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, '.type' do
+
+    let(:heading){ {name: String, status: Integer} }
+    subject{ Tuple.type(heading) }
+
+    it 'returns a subclass' do
+      subject.should be_a(Class)
+      subject.superclass.should be(Alf::Tuple)
+    end
+
+    it 'coerces the heading' do
+      subject.heading.should be_a(Heading)
+    end
+
+    it 'sets the heading correctly' do
+      subject.heading.to_hash.should eq(heading)
+    end
+
+    it 'is aliased as []' do
+      Tuple[heading].should be_a(Class)
+      Tuple[heading].should eq(subject)
+    end
+
+  end
+end

data/spec/unit/alf-relation/tuple/factored-types/test_allbut.rb

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

data/spec/unit/alf-relation/tuple/factored-types/test_coerce.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, '.coerce' do
+
+    let(:type) { Tuple[name: String,  status: Integer] }
+
+    subject{ type.coerce(tuple) }
+
+    context 'on single attributes' do
+      let(:tuple){ {'name' => "Jones", 'status' => "20"} }
+
+      it 'coerces the attributes' do
+        subject.should eq(Tuple(name: "Jones", status: 20))
+      end
+    end
+
+    context 'with a wrapped tuple-valued attribute' do
+      let(:type){ Tuple[name: String,  hobbies: Tuple[name: String, major: Boolean]] }
+      let(:tuple){ {'name' => "Smith", 'hobbies' => {'name' => "Programming", "major" => "true"} } }
+
+      it 'coerces wrapped attributes' do
+        subject.should eq(Tuple(name: "Smith", hobbies: Tuple(name: "Programming", major: true)))
+      end
+    end
+
+    context 'with a DUM RVA' do
+      let(:type){ Tuple[sid: String, supplies: Relation[{}]] }
+      let(:tuple){ Tuple(sid: "S5", supplies: Alf::Relation([])) }
+
+      it{ should be(tuple) }
+    end
+
+    context 'from a Tuple whose declared type hides the compatibility' do
+      let(:type) { Tuple[price: Fixnum] }
+      let(:tuple){ Tuple[price: Numeric].new(price: 12) }
+
+      it{ should eq(type.new(price: 12))}
+    end
+
+    context 'on coercion failure' do
+      let(:tuple){ {name: "Jones", status: "bar"} }
+
+      it 'raises an error' do
+        lambda{
+          subject
+        }.should raise_error(TypeError, /Unable to coerce `"bar"` to `Integer`/)
+      end
+    end
+
+    context 'on missing attribute' do
+      let(:tuple){ {name: "Jones"} }
+
+      it 'raises an error' do
+        lambda{
+          subject
+        }.should raise_error(TypeError, /Missing attribute `status`/)
+      end
+    end
+
+    context 'on missing attributes' do
+      let(:tuple){ {} }
+
+      it 'raises an error' do
+        lambda{
+          subject
+        }.should raise_error(TypeError, /Missing attributes `name, status`/)
+      end
+    end
+
+    context 'on too much attribute' do
+      let(:tuple){ {name: "Jones", status: 10, foo: "bar"} }
+
+      it 'raises an error' do
+        lambda{
+          subject
+        }.should raise_error(TypeError, /Unexpected attribute `foo`/)
+      end
+    end
+
+    context 'on too much attributes' do
+      let(:tuple){ {name: "Jones", status: 10, foo: "bar", foo2: "blah"} }
+
+      it 'raises an error' do
+        lambda{
+          subject
+        }.should raise_error(TypeError, /Unexpected attributes `foo, foo2`/)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-relation/tuple/factored-types/test_comparisons.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, '<=>' do
+
+    let(:type)     { Tuple[name: String, status: Integer] }
+    let(:supertype){ Tuple[name: String, status: Numeric] }
+    let(:subtype)  { Tuple[name: String, status: Fixnum]  }
+
+    subject{ type <=> other }
+
+    context 'on something else' do
+      let(:other){ Integer }
+
+      it{ should be_nil }
+    end
+
+    context 'on itself' do
+      let(:other){ type }
+
+      it{ should eq(0) }
+    end
+
+    context 'on same type' do
+      let(:other){ Tuple[name: String, status: Integer] }
+
+      it{ should eq(0) }
+    end
+
+    context 'on a sub type' do
+      let(:other){ subtype }
+
+      it{ should eq(1) }
+    end
+
+    context 'on a super type' do
+      let(:other){ supertype }
+
+      it{ should eq(-1) }
+    end
+
+    context 'the shortcuts' do
+
+      it 'the > shortcut classifies correctly' do
+        (supertype > supertype).should be_false
+        (supertype > type).should be_true
+        (supertype > subtype).should be_true
+      end
+
+      it 'the >= shortcut classifies correctly' do
+        (supertype >= supertype).should be_true
+        (supertype >= type).should be_true
+        (supertype >= subtype).should be_true
+      end
+
+      it 'the < shortcut classifies correctly' do
+        (supertype < supertype).should be_false
+        (supertype < type).should be_false
+        (supertype < subtype).should be_false
+      end
+
+      it 'the <= shortcut classifies correctly' do
+        (supertype <= supertype).should be_true
+        (supertype <= type).should be_false
+        (supertype <= subtype).should be_false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, '.==' do
+
+    let(:type){ Tuple[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){ Tuple[name: String, status: Integer] }
+
+      it{ should be_true }
+    end
+
+    context 'with another, non equivalent' do
+      let(:other){ Tuple[name: String] }
+
+      it{ should be_false }
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, '.project' do
+
+    let(:type){ Tuple[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(Tuple::EMPTY.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(Tuple[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/tuple/factored-types/test_rename.rb

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

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, 'split' do
+
+    let(:type){ Tuple[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([ Tuple[{}], 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([ Tuple[name: String], Tuple[status: Integer] ])
+      end
+    end
+
+  end
+end