alf-core 0.13.0

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, 'to_ruby_literal' do
+
+    let(:type){ Tuple[name: String, status: Integer] }
+
+    subject{ type.to_ruby_literal }
+
+    it 'should be human friendly' do
+      subject.should eq("Alf::Tuple[{: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/tuple/factored-types/test_triple_equal.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, '===' do
+
+    let(:type){ Tuple[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 Tuple' do
+        let(:value){ Tuple.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 Tuple' do
+        let(:value){ Tuple.coerce(name: "Smith", status: 20) }
+
+        it{ should be_true }
+      end
+    end
+
+    context 'with a DUM RVA' do
+      let(:heading){ {sid: String, supplies: Relation[{}]} }
+      let(:value){ Tuple.coerce(sid: "S5", supplies: Alf::Relation([])) }
+
+      it{ should be_true }
+    end
+
+    context 'with a DUM RVA and a master Relation type' do
+      let(:heading){ {sid: String, supplies: Relation} }
+      let(:value){ Tuple.coerce(sid: "S5", supplies: Alf::Relation([])) }
+
+      it{ should be_true }
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "allbut" do
+
+      let(:tuple){ Tuple(:id => 1, :name => "Alf") }
+
+      subject{ tuple.allbut([:name]) }
+
+      it { should eq(Tuple(:id => 1)) }
+
+    end
+  end
+end

data/spec/unit/alf-relation/tuple/test_attribute_accessors.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "attribute accessors" do
+
+      context 'when no conflict' do
+        let(:tuple){ Tuple(:id => 1, :name => "Alf") }
+
+        it 'has expected accessors' do
+          tuple.id.should eq(1)
+          tuple.name.should eq("Alf")
+        end
+
+        it 'does not confuse accessors and methods' do
+          lambda{
+            tuple.id("hello")
+          }.should raise_error(NoMethodError)
+        end
+      end
+
+      context 'when a conflict' do
+        let(:tuple){ Tuple(:size => 23, :map => "Alf") }
+
+        it 'gives priority to attributes' do
+          tuple.size.should eq(23)
+          tuple.map.should eq("Alf")
+        end
+
+        it 'does not confuse accessors and methods' do
+          tuple.map{|x| "a value" }.should eq(["a value", "a value"])
+        end
+      end
+
+    end
+  end
+end

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

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

data/spec/unit/alf-relation/tuple/test_extend.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "extend" do
+
+      let(:tuple){
+        Tuple(id: 1, name: "Alf")
+      }
+
+      context 'without name clash' do
+        subject{ tuple.extend(up: lambda{ name.upcase }) }
+
+        it { should eq(Tuple(id: 1, name: "Alf", up: "ALF")) }
+      end
+
+      context 'with name clash' do
+        subject{ tuple.extend(name: lambda{ name.upcase }) }
+
+        it { should eq(Tuple(id: 1, name: "ALF")) }
+      end
+
+      context 'with type clash' do
+        subject{ tuple.extend(name: lambda{ name.length }) }
+
+        it { should eq(Tuple(id: 1, name: 3)) }
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, "heading" do
+
+    subject{ tuple.heading }
+
+    describe 'on a tuple factored through an explicit type' do
+      let(:tuple){ Tuple[status: Integer].new(status: 12) }
+
+      it{ should eq(Heading.new(status: Integer)) }
+    end
+
+    describe 'on a tuple factored through coercion' do
+      let(:tuple){ Tuple.coerce(status: 12) }
+
+      it{ should eq(Heading.new(status: Fixnum)) }
+    end
+
+  end
+end

data/spec/unit/alf-relation/tuple/test_merge.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "merge" do
+
+      let(:tuple){ Tuple(id: 10, name: "Smith") }
+
+      subject{ tuple.merge(other) }
+
+      context 'without name clash' do
+        let(:other){ Tuple(status: 30) }
+
+        it{ should eq(Tuple(id: 10, name: "Smith", status: 30)) }
+      end
+
+      context 'with clash' do
+        let(:other){ Tuple(id: 20, status: 30) }
+
+        it{ should eq(Tuple(id: 20, name: "Smith", status: 30)) }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "project" do
+
+      let(:tuple){ Tuple(:id => 1, :name => "Alf") }
+
+      subject{ tuple.project([:name]) }
+
+      it { should eq(Tuple(:name => "Alf")) }
+
+      it 'does not create nil for missing entries' do
+        tuple.project([:none]).should eq(Tuple::EMPTY)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-relation/tuple/test_remap.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "remap" do
+
+      let(:tuple){ Tuple(id: 10, name: "Alf") }
+
+      subject{ tuple.remap{|k,v| v.to_s.length} }
+
+      it { should eq(Tuple(id: 2, name: 3)) }
+
+    end
+  end
+end

data/spec/unit/alf-relation/tuple/test_rename.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Tuple, "rename" do
+
+      let(:tuple){ Tuple(:id => 1, :name => "Alf") }
+
+      subject{ tuple.rename(:name => :first_name) }
+
+      it { should eq(Tuple(:id => 1, :first_name => "Alf")) }
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, "split" do 
+
+    let(:tuple){ Tuple(a: 1, b: 2, c: 3) }
+
+    subject{ tuple.split(list) }
+
+    context 'with the whole list' do
+      let(:list){ [:a, :b, :c] }
+
+      it{ should eq([ tuple, Tuple::EMPTY ]) }
+    end
+
+    context 'with a sublist' do
+      let(:list){ [:a, :c] }
+
+      it{ should eq([ Tuple(a: 1, c: 3), Tuple(b: 2) ]) }
+    end
+
+    context 'with an empty list' do
+      let(:list){ [] }
+
+      it{ should eq([ Tuple::EMPTY, tuple ]) }
+    end
+
+  end
+end

data/spec/unit/alf-relation/tuple/test_to_attr_list.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, "to_attr_list" do
+
+    subject{ tuple.to_attr_list }
+
+    let(:tuple){ Tuple.coerce(name: "Smith", status: 12) }
+
+    it{ should eq(AttrList[:name, :status]) }
+
+  end
+end

data/spec/unit/alf-relation/tuple/test_triple_equal.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  describe Tuple, "===" do
+
+    let(:type){ Tuple[price: Float] }
+
+    subject{ type === tuple }
+
+    context 'when applied to a most specific tuple than declared' do
+      let(:tuple){ Tuple[price: Numeric].new(price: 12.0) }
+
+      it{
+        pending("most-specific types not implemented"){ should be_true }
+      }
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Relvar
+    describe Base, "connection" do
+
+      let(:rv){ Base.new(:name, :connection) }
+
+      subject{ rv.connection }
+
+      it{ should eq(:connection) }
+
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Alf
+  module Relvar
+    describe Base, "delete" do
+
+      let(:rv)        { Base.new(:suppliers, connection) }
+      let(:connection){ self                             }
+
+      def delete(*args)
+        @seen = args
+      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 predicate' do
+          subject
+          @seen.should eq([:suppliers, Predicate.tautology])
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+module Alf
+  module Relvar
+    describe Base, "heading" do
+
+      let(:rv)        { Base.new(:suppliers, connection) }
+      let(:connection){ self                             }
+
+      def heading(*args)
+        @seen = args
+      end
+
+      subject{ rv.heading }
+
+      it 'delegates to the connection' do
+        subject
+        @seen.should eq([:suppliers])
+      end
+
+    end
+  end
+end