alf-core 0.15.0 → 0.16.0

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

@@ -1,42 +0,0 @@
-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/class/test_type.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, '.type' do
-
-    let(:heading){ {name: String, status: Integer} }
-    subject{ Relation.type(heading) }
-
-    it 'returns a subclass' do
-      subject.should be_a(Class)
-      subject.superclass.should be(Alf::Relation)
-    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 'supports a tuple type' do
-      Relation[Tuple[heading]].should eq(Relation[heading])
-    end
-
-    it 'is aliased as []' do
-      Relation[heading].should be_a(Class)
-      Relation[heading].should eq(subject)
-    end
-
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, '.allbut' do
-
-    let(:type){ Relation[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(Relation[status: Integer])
-      end
-    end
-
-    context 'with a full attribute list' do
-      let(:attr_list){ AttrList.new([:name, :status]) }
-
-      it 'reuses the type of DUM' do
-        subject.should be(Relation::DUM.class)
-      end
-    end
-
-  end
-end

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

@@ -1,45 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, '.coerce' do
-
-    subject{ type.coerce(tuples) }
-
-    context 'on single attributes' do
-      let(:type)    { Relation[name: String,  status: Fixnum]  }
-      let(:expected){ Relation(name: "Smith", status: 20)      }
-      let(:tuples){
-        [ {'name' => "Smith", 'status' => "20"} ]
-      }
-
-
-      it 'coerces attributes' do
-        subject.should eq(expected)
-      end
-    end
-
-    context 'with a relation-valued attribute' do
-      let(:type)    { Relation[name: String,  prices: Relation[price: Float]]  }
-      let(:expected){ Relation(name: "Smith", prices: Relation(price: [12.0, 14.0])) }
-      let(:tuples){
-        [{'name' => "Smith", 'prices' => [{'price' => "12.0"}, {'price' => "14.0"}]}]
-      }
-
-      it 'coerces the RVA as well' do
-        subject.should eq(expected)
-      end
-    end
-
-    context 'with a subclass of tuple' do
-      let(:tuple_type){ Class.new(Tuple[price: Integer]) }
-      let(:type){ Relation[tuple_type] }
-      let(:tuples){
-        [{'price' => '12'}]
-      }
-
-      it 'coerces the tuples as correct instances' do
-        subject.all?{|t| t.is_a?(tuple_type) }.should be_true
-      end
-    end
-
-  end
-end

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

@@ -1,69 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Relation, '<=>' do
-
-    let(:type)     { Relation[name: String, status: Integer] }
-    let(:supertype){ Relation[name: String, status: Numeric] }
-    let(:subtype)  { Relation[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){ Relation[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/relation/factored-types/test_equality.rb

@@ -1,28 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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 above' 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
-
-      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
-
-      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