alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-engine/test_filter.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Filter do
-
-      subject{ Filter.new(operand, predicate).to_a }
-
-      context 'on an empty operand' do
-        let(:operand)  { Leaf.new([])           }
-        let(:predicate){ Predicate.coerce(true) }
-
-        it{ should eq([]) }
-      end
-
-      context 'on a non-empty operand' do
-        let(:operand){
-          Leaf.new [
-            {:name => "Jones"},
-            {:name => "Smith"}
-          ]
-        }
-        let(:predicate){
-          Predicate.native(->(t){ t.name =~ /^J/ })
-        }
-        let(:expected){
-          [
-            {:name => "Jones"},
-          ]
-        }
-
-        it{ should eq(expected) }
-      end
-
-      context 'on a predicate of arity 1' do
-        let(:operand){
-          Leaf.new [
-            {:name => "Jones"},
-            {:name => "Smith"}
-          ]
-        }
-        let(:predicate){
-          Predicate.native(->(t){ t[:name] =~ /^J/})
-        }
-        let(:expected){
-          [
-            {:name => "Jones"},
-          ]
-        }
-
-        it{ should eq(expected) }
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_generator.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Generator do
-
-      it 'should generate tuples from 0' do
-        exp = [
-          {:id => 0},
-          {:id => 1}
-        ]
-        Generator.new(:id, 0, 1, 2).to_a.should eq(exp)
-      end
-
-      it 'should allow specifying an offset, step and count' do
-        exp = [
-          {:id => 10},
-          {:id => 15},
-          {:id => 20}
-        ]
-        Generator.new(:id, 10, 5, 3).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_hierarchize.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Hierarchize do
-
-      let(:type){
-        Relation.type(id: Fixnum, parent: Fixnum, name: String){|r| {subs: r} }
-      }
-
-      let(:operand){[
-        {id: 1, parent: 1, name: "USA"},
-        {id: 5, parent: 3, name: "Brussels"},
-        {id: 2, parent: 2, name: "Europe"},
-        {id: 3, parent: 2, name: "Belgium"},
-        {id: 4, parent: 2, name: "France"},
-      ]}
-
-      let(:expected){
-        type.new([
-          { id: 1, parent: 1, name: "USA",    subs: type.empty },
-          { id: 2, parent: 2, name: "Europe", subs: type.new([
-              { id: 3, parent: 2, name: "Belgium", subs: type.new([
-                  {id: 5, parent: 3, name: "Brussels", subs: type.empty } ].to_set) },
-              { id: 4, parent: 2, name: "France", subs: type.empty } ].to_set) }
-        ].to_set)
-      }
-
-      subject{
-        Hierarchize.new(operand, AttrList[:id], AttrList[:parent], :subs)
-      }
-
-      let(:resulting_relation){
-        subject.to_relation
-      }
-
-      def are_equal(x, y)
-        # same class
-        x.class.should eq(y.class)
-
-        # take tuples
-        got = x.to_a.sort{|t,u| t[:id] <=> u[:id] }
-        exp = y.to_a.sort{|t,u| t[:id] <=> u[:id] }
-        
-        # compare attributes
-        got.zip(exp) do |e,f|
-          [:id, :parent, :name].each do |a|
-            e[a].should eq(f[a])
-          end
-          are_equal(e[:subs], f[:subs])
-          e[:subs].to_set.should eq(f[:subs].to_set)
-          e[:subs].should eq(f[:subs])
-        end
-
-        true
-      end
-
-      it 'has expected result type' do
-        resulting_relation.class.should eq(type)
-      end
-
-      it 'has pair-wise equal tuples' do
-        are_equal(resulting_relation, expected).should be_true
-      end
-
-      it 'computes expected relation' do
-        resulting_relation.should eq(expected)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-engine/test_infer_heading.rb

@@ -1,58 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe InferHeading do
-
-      subject{ InferHeading.new(input).first }
-
-      context 'on empty input' do
-        let(:input){ [] }
-
-        it { should eq({}) }
-      end
-
-      context 'with simple tuples' do
-        let(:input){
-          [
-            {tested: 1,    other: "b"},
-            {tested: 10.0, other: "a"}
-          ]
-        }
-        let(:expected){
-          {tested: Numeric, other: String}
-        }
-
-        it{ should eq(expected) }
-      end
-
-      context 'with RVAs' do
-        let(:input){
-          [
-            { sid: "S1", supplies: Relation(pid: 10.0) },
-            { sid: "S5", supplies: Relation(pid: 12.0) }
-          ]
-        }
-        let(:expected){
-          {sid: String, supplies: Relation[pid: Float]}
-        }
-
-        it{ should eq(expected) }
-      end
-
-      context 'with incompatible RVAs' do
-        let(:input){
-          [
-            { sid: "S1", supplies: Relation(foo: "Bar") },
-            { sid: "S5", supplies: Relation(pid: 12.0) }
-          ]
-        }
-        let(:expected){
-          {sid: String, supplies: Relation}
-        }
-
-        it{ should eq(expected) }
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_rename.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Rename do
-
-      it 'should work on an empty operand' do
-        Rename.new([], Renaming[{}]).to_a.should eq([])
-      end
-
-      it 'should work on a non empty operand' do
-        rel = [
-          {:name => "Jones", :city => "London"},
-          {:name => "Smith", :city => "Paris"}
-        ]
-        exp = [
-          {:last_name => "Jones", :city => "London"},
-          {:last_name => "Smith", :city => "Paris"}
-        ]
-        Rename.new(rel, Renaming[:name => :last_name]).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_set_attr.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe SetAttr do
-
-      it 'should work on an empty operand' do
-        SetAttr.new(Leaf.new([]), TupleComputation[{}]).to_a.should eq([])
-      end
-
-      it 'should allow implementing UPDATE' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "JONES"},
-          {:name => "SMITH"}
-        ]
-        comp = TupleComputation[:name => lambda{ name.upcase }]
-        SetAttr.new(rel, comp).to_a.should eq(exp)
-      end
-
-      it 'should allow implementing EXTEND' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones", :up => "JONES"},
-          {:name => "Smith", :up => "SMITH"}
-        ]
-        comp = TupleComputation[:up => lambda{ name.upcase }]
-        SetAttr.new(rel, comp).to_a.should eq(exp)
-      end
-
-      it 'should support lambda of arity 1' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones", :up => "JONES"},
-          {:name => "Smith", :up => "SMITH"}
-        ]
-        comp = TupleComputation[:up => lambda{|t| t.name.upcase }]
-        SetAttr.new(rel, comp).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_sort.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Sort do
-
-      it 'should work on an empty operand' do
-        Sort.new([], Ordering[[]]).to_a.should eq([])
-      end
-
-      it 'should work with ascending' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Sort.new(rel, Ordering[[:name, :asc]]).to_a.should eq(rel)
-      end
-
-      it 'should work with descending' do
-        rel = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Smith"},
-          {:name => "Jones"}
-        ]
-        Sort.new(rel, Ordering[[:name, :desc]]).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_take.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Take do
-
-      it 'should work on an empty operand' do
-        Take.new(Leaf.new([]), 1, 1).to_a.should eq([])
-      end
-
-      it 'should filter according to the offset' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Smith"}
-        ]
-        Take.new(rel, 1, 10).to_a.should eq(exp)
-      end
-
-      it 'should filter according to the limit (1/2)' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        Take.new(rel, 0, 2).to_a.should eq(exp)
-      end
-
-      it 'should filter according to the limit (2/2)' do
-        rel = Leaf.new [
-          {:name => "Jones"},
-          {:name => "Smith"}
-        ]
-        exp = [
-          {:name => "Jones"},
-        ]
-        Take.new(rel, 0, 1).to_a.should eq(exp)
-      end
-
-    end
-  end # module Engine
-end # module Alf

data/spec/unit/alf-engine/test_to_array.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe ToArray do
-
-      subject{ ToArray.new(rel, ordering).to_a }
-
-      context 'when ordering is nil' do
-        let(:rel){[
-          {name: "Jones", parts: Relation::DEE},
-          {name: "Smith", parts: Relation::DUM}
-        ]}
-        let(:ordering){ nil }
-        let(:expected){[
-          {name: "Jones", parts: [{}]},
-          {name: "Smith", parts: []}
-        ]}
-
-        it{ should eq(expected) }
-      end
-
-      context 'when both empty' do
-        let(:rel)     { [] }
-        let(:ordering){ Ordering::EMPTY }
-
-        it{ should eq(rel) }
-      end
-
-      context 'when ascending on single attribute' do
-        let(:rel){[
-          {name: "Jones"},
-          {name: "Smith"}
-        ]}
-        let(:ordering){ Ordering.new([[:name, :asc]]) }
-
-        it{ should eq(rel) }
-      end
-
-      context 'when descending on single attribute' do
-        let(:rel){[
-          {name: "Jones"},
-          {name: "Smith"}
-        ]}
-        let(:ordering){ Ordering.new([[:name, :desc]]) }
-
-        it{ should eq(rel.reverse) }
-      end
-
-      context 'when TVAs are involved' do
-        let(:rel){[
-          {name: "Jones", hobby: { score: 10 }},
-          {name: "Jones", hobby: { score: 12 }}
-        ]}
-        let(:ordering){ Ordering.new([[:name, :asc], [[:hobby, :score], :desc]]) }
-
-        it{ should eq(rel.reverse) }
-      end
-
-      context 'when RVAs are involved' do
-        let(:rel){[
-          {name: "Smith", rva: Relation(id: [8, 7]) },
-          {name: "Jones", rva: Relation(id: [1, 3]) }
-        ]}
-        let(:expected){[
-          {name: "Jones", rva: [{id: 1}, {id: 3}] },
-          {name: "Smith", rva: [{id: 7}, {id: 8}] }
-        ]}
-        let(:ordering){ Ordering.new([[:name, :asc], [[:rva, :id], :asc]]) }
-
-        it{ should eq(expected) }
-      end
-
-    end # describe ToArray
-  end # module Engine
-end # module Alf