alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-types/heading/class/test_coerce.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "coerce" do
-
-    subject{ Heading.coerce(arg) }
-
-    context 'with a Heading' do
-      let(:arg){ Heading.new :foo => String }
-
-      it{ should be(arg) }
-    end
-
-    context 'with a Hash' do
-      let(:arg){ {:foo => String} }
-
-      it{ should eq(Heading.new :foo => String) }
-    end
-
-    context 'with an empty Array' do
-      let(:arg){ [] }
-
-      it{ should eq(Heading::EMPTY) }
-    end
-
-    context 'with a non-empty Array' do
-      let(:arg){ ["name", "String"] }
-
-      it{ should eq(Heading.new :name => String) }
-    end
-
-    context 'with something unrecognized' do
-      let(:arg){ true }
-
-      specify{
-        lambda{ subject }.should raise_error(TypeError, /Can't convert `true` into (.*?)Heading/)
-      }
-    end
-
-  end 
-end

data/spec/unit/alf-types/heading/class/test_infer.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "infer" do
-
-    subject{ Heading.infer(arg) }
-
-    context 'with a Heading' do
-      let(:arg){ Heading.new foo: String }
-
-      it{ should be(arg) }
-    end
-
-    context 'with a Hash' do
-      let(:arg){ {:foo => 20} }
-
-      it{ should eq(Heading.new foo: Fixnum) }
-    end
-
-    context 'with an array of hashes' do
-      let(:arg){ [ {foo: 20}, {foo: 12.5} ] }
-
-      it{ should eq(Heading.new foo: Numeric) }
-    end
-
-  end 
-end

data/spec/unit/alf-types/heading/test_allbut.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "allbut" do
-
-    let(:heading){ Heading[id: Integer, name: String] }
-
-    subject{ heading.allbut([:id]) }
-
-    it { should eq(Heading[name: String]) }
-
-  end
-end

data/spec/unit/alf-types/heading/test_cardinality.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "cardinality" do
-
-    subject{ heading.cardinality }
-
-    after do
-      subject.should eq(heading.count)
-      subject.should eq(heading.size)
-    end
-
-    context 'on an empty heading' do
-      let(:heading){ Heading.new({}) }
-
-      it{ should eq(0) }
-    end
-
-    context 'on a non-empty heading' do
-      let(:heading){ Heading.new({:foo => :bar}) }
-
-      it{ should eq(1) }
-    end
-
-  end 
-end

data/spec/unit/alf-types/heading/test_coerce.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Types
-    describe Heading, "coerce" do
-
-      let(:heading){ Heading.new(name: String, status: Integer) }
-
-      subject{ heading.coerce(arg) }
-
-      context 'when applied to a Hash' do
-        let(:arg){ {name: "Smith", status: "20"} }
-
-        it{ should be_a(Hash) }
-        it{ should eq(name: "Smith", status: 20) }
-      end
-
-      context 'when applied to a Hash with String keys' do
-        let(:arg){ {'name' => "Smith", 'status' => "20"} }
-
-        it{ should be_a(Hash) }
-        it{ should eq(name: "Smith", status: 20) }
-      end
-
-      context 'when applied to a Tuple' do
-        let(:arg){ Tuple(name: "Smith", status: "20") }
-
-        it{ should be_a(Hash) }
-        it{ should eq(name: "Smith", status: 20) }
-      end
-
-      context 'when applied to an Enumerable' do
-        let(:arg){ [{name: "Smith", status: "20"}] }
-
-        it 'should map on it' do
-          subject.should eq([{name: "Smith", status: 20}])
-        end
-      end
-
-      context 'when attributes are missing' do
-        let(:arg){ {name: "Smith"} }
-
-        it 'should not create them' do
-          subject.should eq(name: "Smith")
-        end
-      end
-
-      context 'when attributes are added' do
-        let(:arg){ {name: "Smith", status: "12", foo: "bar"} }
-
-        it 'should not touch them' do
-          subject.should eq(name: "Smith", status: 12, foo: "bar")
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-types/heading/test_comparison.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "<=>" do
-
-    let(:heading){ Heading.new(name: String, status: Integer, active: Boolean) }
-
-    subject{ heading <=> other }
-
-    context 'with itself' do
-      let(:other){ heading }
-
-      before{ heading.should eq(other) }
-
-      it{ should eq(0) }
-    end
-
-    context 'with less attributes' do
-      let(:other){ Heading.new(name: String) }
-
-      it{ should be_nil }
-    end
-
-    context 'with more attributes' do
-      let(:other){ Heading.new(name: String, status: Integer, active: Boolean, foo: Date) }
-
-      it{ should be_nil }
-    end
-
-    context 'with different attributes' do
-      let(:other){ Heading.new(name: String, foo: Date) }
-
-      it{ should be_nil }
-    end
-
-    context 'with the same heading' do
-      let(:other){ Heading.new(name: String, status: Integer, active: Boolean) }
-
-      before{ heading.should eq(other) }
-
-      it{ should eq(0) }
-    end
-
-    context 'with a partial sub heading' do
-      let(:other){ Heading.new(name: String, status: Fixnum, active: Boolean) }
-
-      it{ should eq(1) }
-    end
-
-    context 'with a full sub heading' do
-      let(:other){ Heading.new(name: String, status: Fixnum, active: TrueClass) }
-
-      it{ should eq(1) }
-    end
-
-    context 'with a partial super heading' do
-      let(:other){ Heading.new(name: String, status: Numeric, active: Boolean) }
-
-      it{ should eq(-1) }
-    end
-
-    context 'with a full super heading' do
-      let(:other){ Heading.new(name: Object, status: Numeric, active: Object) }
-
-      it{ should eq(-1) }
-    end
-
-    context 'with a mixed heading' do
-      let(:other){ Heading.new(name: Object, status: Fixnum, active: Boolean) }
-
-      it{ should be_nil }
-    end
-
-    context 'when RVAs are present' do
-      let(:heading){ Heading.new(prices: Relation[price: Numeric]) }
-
-      context 'with a sub-heading' do
-        let(:other){ Heading.new(prices: Relation[price: Float]) }
-
-        it{ should eq(1) }
-      end
-
-      context 'with a super-heading' do
-        let(:other){ Heading.new(prices: Relation[price: Object]) }
-
-        it{ should eq(-1) }
-      end
-
-      context 'with a master heading' do
-        let(:other){ Heading.new(prices: Relation) }
-
-        it{ should eq(-1) }
-      end
-    end
-
-  end
-end

data/spec/unit/alf-types/heading/test_intersection.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "intersection" do
-
-    subject{ left & right }
-
-    context 'with disjoint headings' do
-      let(:left) { Heading[:name => String] }
-      let(:right){ Heading[:city => String] }
-
-      it{ should eq(Heading[{}]) }
-    end
-
-    context 'with non disjoint headings' do
-      let(:left) { Heading[:id => Integer, :name => String] }
-      let(:right){ Heading[:id => Integer, :status => Integer] }
-
-      it { should eq(Heading[:id => Integer]) }
-    end
-
-    context 'with non disjoint headings and sub types' do
-      let(:left) { Heading[:id => Fixnum,  :name => String] }
-      let(:right){ Heading[:id => Integer, :status => Integer] }
-
-      it { should eq(Heading[:id => Integer]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/heading/test_merge.rb

@@ -1,25 +0,0 @@
-module Alf
-  describe Heading, "merge" do
-
-    subject{ left.merge(right) }
-
-    context 'with disjoint headings' do
-      let(:left) { Heading[:name => String] }
-      let(:right){ Heading[:city => String] }
-
-      it "computes the union" do
-        subject.should eq(Heading[:name => String, :city => String])
-      end
-    end
-
-    context 'with non disjoint headings' do
-      let(:left) { Heading[:id => Integer, :name => String] }
-      let(:right){ Heading[:id => Integer, :name => Integer] }
-
-      it "computes uses right on commons" do
-        subject.should eq(Heading[:id => Integer, :name => Integer])
-      end
-    end
-
-  end
-end

data/spec/unit/alf-types/heading/test_project.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "project" do
-
-    let(:heading){ Heading[:id => Integer, :name => String] }
-
-    context 'without allbut' do
-      subject{ heading.project([:id]) }
-
-      it { should eq(Heading[:id => Integer]) }
-    end
-
-    context 'with allbut' do
-      subject{ heading.project([:id], true) }
-
-      it { should eq(Heading[:name => String]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/heading/test_split.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "split" do
-
-    let(:heading){ Heading[id: Integer, name: String] }
-
-    context 'without allbut' do
-      subject{ heading.split([:id]) }
-
-      it { should eq([Heading[id: Integer], Heading[name: String]]) }
-    end
-
-    context 'without allbut' do
-      subject{ heading.split([:id], true) }
-
-      it { should eq([Heading[name: String], Heading[id: Integer]]) }
-    end
-
-  end
-end

data/spec/unit/alf-types/heading/test_to_h.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "to_h" do
-
-    subject{ heading.to_h }
-
-    after do
-      subject.should eq(heading.to_hash)
-    end
-
-    context 'on an empty heading' do
-      let(:heading){ Heading.new({}) }
-
-      it{ should eq({}) }
-    end
-
-    context 'on a non-empty heading' do
-      let(:heading){ Heading.new({:foo => :bar}) }
-
-      it{ should eq({:foo => :bar}) }
-    end
-
-  end 
-end

data/spec/unit/alf-types/heading/test_triple_equal.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "===" do
-
-    let(:h){ Heading[name: String, status: Integer] }
-
-    subject{ h===tuple }
-
-    context 'on a conforming Hash' do
-      let(:tuple){ {name: "Smith", status: 20} }
-
-      it{ should be_true }
-    end
-
-    context 'on a conforming Tuple' do
-      let(:tuple){ Tuple(name: "Smith", status: 20) }
-
-      it{ should be_true }
-    end
-
-    context 'on a non conforming Hash (missing attributes)' do
-      let(:tuple){ {name: "Smith"} }
-
-      it{ should be_false }
-    end
-
-    context 'on a non conforming Hash (too many attributes)' do
-      let(:tuple){ {name: "Smith", status: 20, city: "London"} }
-
-      it{ should be_false }
-    end
-
-    context 'on a non conforming Hash (type mismatch)' do
-      let(:tuple){ {name: "Smith", status: "20"} }
-
-      it{ should be_false }
-    end
-
-  end 
-end

data/spec/unit/alf-types/heading/test_union.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading, "union" do
-
-    let(:h_name){ Heading[:name => String] }
-    let(:h_city){ Heading[:city => String] }
-
-    it "should work on empty headings" do
-      Heading::EMPTY.union(Heading::EMPTY).should eq(Heading::EMPTY)
-    end
-
-    it "should work with disjoint headings" do
-      h_name.union(h_city).should eq(Heading[:name => String, :city => String])
-    end
-
-    it "should be aliased as +" do
-      (h_name + h_city).should eq(Heading[:name => String, :city => String])
-    end
-
-    it "should work compute supertype on non-disjoint headings" do
-      h1 = Heading[:age => Fixnum, :name => String]
-      h2 = Heading[:age => Integer]
-      (h1 + h2).should eq(Heading[:age => Integer, :name => String])
-    end
-
-    it "should be aliased as join" do
-      h1 = Heading[:age => Fixnum, :name => String]
-      h2 = Heading[:age => Integer]
-      h1.join(h2).should eq(Heading[:age => Integer, :name => String])
-    end
-
-  end 
-end