alf-core 0.13.0

data/spec/unit/alf-engine/rank/test_cesure.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Rank::Cesure do
+
+      let(:input) {[
+        {:pid => 'P1', :weight => 12.0},
+        {:pid => 'P5', :weight => 12.0},
+        {:pid => 'P4', :weight => 14.0},
+        {:pid => 'P2', :weight => 17.0},
+        {:pid => 'P3', :weight => 17.0},
+        {:pid => 'P6', :weight => 19.0}
+      ]}
+
+      context "when a partial ordering is used" do
+        let(:expected) {[
+          {:pid => 'P1', :weight => 12.0, :rank => 0},
+          {:pid => 'P5', :weight => 12.0, :rank => 0},
+          {:pid => 'P4', :weight => 14.0, :rank => 2},
+          {:pid => 'P2', :weight => 17.0, :rank => 3},
+          {:pid => 'P3', :weight => 17.0, :rank => 3},
+          {:pid => 'P6', :weight => 19.0, :rank => 5}
+        ]}
+        it 'should rank as expected' do
+          op = Engine::Rank::Cesure.new(input, AttrList[:weight], :rank)
+          op.to_a.should eq(expected.to_a)
+        end
+      end
+
+      context "when a total ordering is used" do
+        let(:expected) {[
+          {:pid => 'P1', :weight => 12.0, :rank => 0},
+          {:pid => 'P5', :weight => 12.0, :rank => 1},
+          {:pid => 'P4', :weight => 14.0, :rank => 2},
+          {:pid => 'P2', :weight => 17.0, :rank => 3},
+          {:pid => 'P3', :weight => 17.0, :rank => 4},
+          {:pid => 'P6', :weight => 19.0, :rank => 5}
+        ]}
+        it 'should rank as expected' do
+          op = Engine::Rank::Cesure.new(input, AttrList[:weight, :pid], :rank)
+          op.to_a.should eq(expected.to_a)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-engine/semi/test_hash.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Semi::Hash do
+
+      let(:suppliers) {[
+        {:sid => 'S1', :city => 'London'},
+        {:sid => 'S2', :city => 'Paris'},
+        {:sid => 'S3', :city => 'Paris'}
+      ]}
+
+      let(:statuses) {[
+        {:sid => 'S1', :status => 20},
+        {:sid => 'S3', :status => 30}
+      ]}
+
+      context "when used in matching mode" do
+
+        it 'should filter not matching tuples' do
+          expected =  [
+            {:sid => 'S1', :city => 'London'},
+            {:sid => 'S3', :city => 'Paris'}
+          ]
+          Semi::Hash.new(suppliers, statuses, true).to_a.should eq(expected)
+        end
+
+        it 'should return whole operand against DEE' do
+          Semi::Hash.new(suppliers, [{}], true).to_a.should eq(suppliers)
+        end
+
+        it 'should return an empty operand against DUM' do
+          Semi::Hash.new(suppliers, [], true).to_a.should eq([])
+        end
+
+      end # matching mode
+
+      context "when used in non matching mode" do
+
+        it 'should filter matching tuples' do
+          expected =  [
+            {:sid => 'S2', :city => 'Paris'},
+          ]
+          Semi::Hash.new(suppliers, statuses, false).to_a.should eq(expected)
+        end
+
+        it 'should return whole operand against DUM' do
+          Semi::Hash.new(suppliers, [], false).to_a.should eq(suppliers)
+        end
+
+        it 'should return an empty operand against DEE' do
+          Semi::Hash.new(suppliers, [{}], false).to_a.should eq([])
+        end
+
+      end # non matching mode
+
+    end
+  end # module Engine
+end # module Alf

data/spec/unit/alf-engine/sort/test_in_memory.rb

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

data/spec/unit/alf-engine/summarize/test_cesure.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Summarize::Cesure do
+
+      let(:input) {Leaf.new [
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 2},
+        {:a => "via_reader", :time => 4},
+        {:a => "via_reader", :time => 2},
+      ]}
+
+      let(:expected) {[
+        {:a => "via_method", :time_sum => 4, :time_max => 2},
+        {:a => "via_reader", :time_sum => 6, :time_max => 4},
+      ]}
+
+      let(:aggs){Summarization.new(
+        :time_sum => Aggregator.sum{ time },
+        :time_max => Aggregator.max{ time }
+      )} 
+
+      it 'should summarize as expected' do
+        sum = Summarize::Cesure.new(input, AttrList[:a], aggs, false)
+        sum.to_a.should eq(expected)
+      end
+
+      it 'should support allbut summarization' do
+        sum = Summarize::Cesure.new(input, AttrList[:time], aggs, true)
+        sum.to_a.should eq(expected)
+      end
+
+    end 
+  end
+end

data/spec/unit/alf-engine/summarize/test_hash.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Summarize::Cesure do
+
+      let(:input) {[
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 2},
+        {:a => "via_reader", :time => 4},
+        {:a => "via_reader", :time => 2},
+      ]}
+
+      let(:expected) {[
+        {:a => "via_method", :time_sum => 4, :time_max => 2},
+        {:a => "via_reader", :time_sum => 6, :time_max => 4},
+      ].to_set}
+
+      let(:aggs){Summarization.new(
+        :time_sum => Aggregator.sum{ time },
+        :time_max => Aggregator.max{ time }
+      )} 
+
+      it 'should summarize as expected' do
+        sum = Summarize::Hash.new(input, AttrList[:a], aggs, false)
+        sum.to_set.should eq(expected)
+      end
+
+      it 'should support allbut summarization' do
+        sum = Summarize::Hash.new(input, AttrList[:time], aggs, true)
+        sum.to_set.should eq(expected)
+      end
+
+    end 
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Aggregate do
+
+      it 'should work on an empty operand' do
+        Autonum.new(Leaf.new([]), Summarization[{}]).to_a.should eq([])
+      end
+
+      it 'should work on a non empty operand' do
+        rel = Leaf.new [
+          {:name => "Jones", :price => 12.0, :id => 1},
+          {:name => "Smith", :price => 10.0, :id => 2}
+        ]
+        agg = Summarization[:size  => "count", 
+                            :total => "sum{ price }"]
+        exp = [
+          {:size => 2, :total => 22.0}
+        ]
+        Aggregate.new(rel, agg).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf    
+

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

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

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Clip do
+
+      it 'should work on an empty operand' do
+        Clip.new([], AttrList[:name], true).to_a.should eq([])
+        Clip.new([], AttrList[:name], false).to_a.should eq([])
+      end
+
+      let(:operand){[
+          {:name => "Jones", :city => "London"},
+          {:name => "Smith", :city => "Paris"}
+      ]}
+
+      it 'should work on a non empty operand' do
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Clip.new(operand, AttrList[:name], false).to_a.should eq(exp)
+      end
+
+      it 'should allow allbut clipping' do
+        exp = [
+          {:city => "London"},
+          {:city => "Paris"}
+        ]
+        Clip.new(operand, AttrList[:name], true).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Coerce do
+
+      it 'should work on an empty operand' do
+        Coerce.new([], Heading[:price => Float]).to_a.should eq([])
+      end
+
+      let(:operand){[
+          {:name => "Jones", :price => "12.0"},
+          {:name => "Smith", :price => "-10.0"}
+      ]}
+
+      it 'should work on a non empty operand' do
+        exp = [
+          {:name => "Jones", :price => 12.0},
+          {:name => "Smith", :price => -10.0}
+        ]
+        heading = Heading[:name => String, :price => Float]
+        Coerce.new(operand, heading).to_a.should eq(exp)
+      end
+
+      it 'should not project on the heading' do
+        exp = [
+          {:name => "Jones", :price => 12.0},
+          {:name => "Smith", :price => -10.0}
+        ]
+        heading = Heading[:price => Float]
+        Coerce.new(operand, heading).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compact do
+
+      it 'should work on an empty operand' do
+        Compact.new([]).to_a.should eq([])
+      end
+
+      it 'should work when no duplicate is present' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Compact.new(rel).to_set.should eq(rel.to_set)
+      end
+
+      it 'should work when duplicates are present' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"},
+          {:name => "Jones"},
+        ]
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Compact.new(rel).to_set.should eq(exp.to_set)
+      end
+
+    end
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Concat do
+
+      it 'should work on no operand at all' do
+        Concat.new([]).to_a.should eq([])
+      end
+
+      it 'should work with only one operand' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Concat.new([rel]).to_a.should eq(rel)
+      end
+
+      it 'should work with multiple operands' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        rel2 = [
+          {:name => "Jones"},
+          {:name => "Clark"}
+        ]
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"},
+          {:name => "Jones"},
+          {:name => "Clark"}
+        ]
+        Concat.new([rel, rel2]).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Defaults do
+
+      it 'should work on an empty operand' do
+        Defaults.new(Leaf.new([]), TupleComputation[:id => 1]).to_a.should eq([])
+      end
+
+      it 'should replace nil by the default value' do
+        rel = Leaf.new [
+          {:name => "Jones"},
+          {:name => nil}
+        ]
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Defaults.new(rel, TupleComputation[:name => "Smith"]).to_a.should eq(exp)
+      end
+
+      it 'should add missing attributes and allow computations' do
+        rel = Leaf.new [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        exp = [
+          {:name => "Jones", :up => "JONES"},
+          {:name => "Smith", :up => "SMITH"}
+        ]
+        defs = TupleComputation[:up => lambda{ name.upcase }]
+        Defaults.new(rel, defs).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf