alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-compiler/default/test_hierarchize.rb

@@ -0,0 +1,40 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Compiler, 'on_hierarchize' do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:operand){
+        an_operand.with_heading(id: Fixnum, parent: Integer).with_keys([:id])
+      }
+
+      let(:expr){
+        a_lispy.hierarchize(an_operand(leaf), :id, :parent, :as)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it{ should be_a(Engine::Hierarchize) }
+
+      it 'should have correct id list' do
+        subject.id.should eq(AttrList[:id])
+      end
+
+      it 'should have correct parent list' do
+        subject.parent.should eq(AttrList[:parent])
+      end
+
+      it 'should have correct children name' do
+        subject.children.should eq(:as)
+      end
+
+      it 'has the correct sub-cog' do
+        subject.operand.should be(leaf)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_intersect.rb

@@ -0,0 +1,34 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "intersect" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:right){
+        compact(an_operand(leaf))
+      }
+
+      let(:expr){
+        intersect(an_operand(leaf), right)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Join::Hash cog' do
+        subject.should be_a(Engine::Join::Hash)
+      end
+
+      it 'has the correct left sub-cog' do
+        subject.left.should be(leaf)
+      end
+
+      it 'has the correct right sub-cog' do
+        subject.right.should be_a(Engine::Compact)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_join.rb

@@ -0,0 +1,34 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "join" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:right){
+        compact(an_operand)
+      }
+
+      let(:expr){
+        join(an_operand(leaf), right)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'is a Join::Hash cog' do
+        subject.should be_a(Engine::Join::Hash)
+      end
+
+      it 'has the correct left sub-cog' do
+        subject.left.should be(leaf)
+      end
+
+      it 'has the correct right sub-cog' do
+        subject.right.should be_a(Engine::Compact)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_matching.rb

@@ -0,0 +1,38 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "matching" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:right){
+        compact(an_operand(leaf))
+      }
+
+      let(:expr){
+        matching(an_operand(leaf), right)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Join::Hash cog' do
+        subject.should be_a(Engine::Semi::Hash)
+      end
+
+      it 'has the correct left sub-cog' do
+        subject.left.should be(leaf)
+      end
+
+      it 'has the correct right sub-cog' do
+        subject.right.should be_a(Engine::Compact)
+      end
+
+      it 'has the correct predicate' do
+        subject.predicate.should be_true
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_minus.rb

@@ -0,0 +1,38 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "minus" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:right){
+        compact(an_operand(leaf))
+      }
+
+      let(:expr){
+        minus(an_operand(leaf), right)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Join::Hash cog' do
+        subject.should be_a(Engine::Semi::Hash)
+      end
+
+      it 'has the correct left sub-cog' do
+        subject.left.should be(leaf)
+      end
+
+      it 'has the correct right sub-cog' do
+        subject.right.should be_a(Engine::Compact)
+      end
+
+      it 'has the correct predicate' do
+        subject.predicate.should be_false
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_not_matching.rb

@@ -0,0 +1,38 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "not_matching" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:right){
+        compact(an_operand(leaf))
+      }
+
+      let(:expr){
+        not_matching(an_operand(leaf), right)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Join::Hash cog' do
+        subject.should be_a(Engine::Semi::Hash)
+      end
+
+      it 'has the correct left sub-cog' do
+        subject.left.should be(leaf)
+      end
+
+      it 'has the correct right sub-cog' do
+        subject.right.should be_a(Engine::Compact)
+      end
+
+      it 'has the correct predicate' do
+        subject.predicate.should be_false
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_page.rb

@@ -0,0 +1,91 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "page" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:ordering){
+        Ordering.new([[:a, :asc]])
+      }
+
+      shared_examples_for "the expected Take" do
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Take cog' do
+          subject.should be_a(Engine::Take)
+        end
+
+        it 'has the correct take attributes' do
+          subject.offset.should eq(40)
+          subject.limit.should eq(20)
+        end
+      end
+
+      context 'when positive page (no inference possible)' do
+        let(:expr){
+          page(an_operand(leaf), ordering, 3, page_size: 20)
+        }
+
+        it_should_behave_like "the expected Take"
+        it_should_behave_like "a compiled based on an added sub Sort"
+
+        it "should have the expected Sort" do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(ordering)
+        end
+      end
+
+      context 'when positive page (inference possible)' do
+        let(:expr){
+          op = an_operand(leaf).with_heading(a: String, b: String)
+                               .with_keys([:b])
+          page(op, ordering, 3, page_size: 20)
+        }
+
+        let(:total_ordering){
+          Ordering.new([[:a, :asc], [:b, :asc]])
+        }
+
+        it_should_behave_like "the expected Take"
+        it_should_behave_like "a compiled based on an added sub Sort with total ordering"
+      end
+
+      context 'when a negative page' do
+        let(:expr){
+          page(an_operand(leaf), ordering, -3, page_size: 20)
+        }
+
+        it_should_behave_like "the expected Take"
+        it_should_behave_like "a compiled based on an added reversed Sort"
+      end
+
+      context 'when already sorted' do
+        let(:expr){
+          page(sort(an_operand(leaf), subordering), ordering, 3, page_size: 20)
+        }
+
+        context 'in a compatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :asc], [:b, :desc]])
+          }
+
+          it_should_behave_like "the expected Take"
+          it_should_behave_like "a compiled reusing a sub Sort"
+        end
+
+        context 'in incompatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :desc]])
+          }
+
+          it_should_behave_like "the expected Take"
+          it_should_behave_like "a compiled not reusing a sub Sort"
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_project.rb

@@ -0,0 +1,76 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "project" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      shared_examples_for "a compacted compilation result" do
+
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Compact cog' do
+          subject.should be_a(Engine::Compact)
+        end
+
+        it 'has a Clip sub-cog' do
+          subject.operand.should be_a(Engine::Clip)
+          subject.operand.attributes.should eq(AttrList[:a])
+          subject.operand.allbut.should eq(allbut)
+        end
+
+        it 'has the corect sub-sub cog' do
+          subject.operand.operand.should be(leaf)
+        end
+      end
+
+      let(:allbut){ false }
+
+      context 'when keys not available' do
+        let(:expr){
+          project(an_operand(leaf), [:a])
+        }
+
+        it_should_behave_like "a compacted compilation result"
+      end
+
+      context 'when keys not available (allbut)' do
+        let(:expr){
+          project(an_operand(leaf), [:a], allbut: true)
+        }
+        let(:allbut){ true }
+
+        it_should_behave_like "a compacted compilation result"
+      end
+
+      context 'when keys are available and not preserving' do
+        let(:expr){
+          project(an_operand(leaf).with_keys([:b]), [:a])
+        }
+
+        it_should_behave_like "a compacted compilation result"
+      end
+
+      context 'when keys are available and preserving' do
+        let(:expr){
+          project(an_operand(leaf).with_keys([:a]), [:a])
+        }
+
+        it_should_behave_like "a traceable cog"
+
+        it 'has a Clip cog' do
+          subject.should be_a(Engine::Clip)
+          subject.attributes.should eq(AttrList[:a])
+          subject.allbut.should be_false
+        end
+
+        it 'has the correct sub cog' do
+          subject.operand.should be(leaf)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-compiler/default/test_quota.rb

@@ -0,0 +1,88 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "quota" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:summarization){
+        Summarization[{ max: Aggregator.max{ qty } }]
+      }
+
+      let(:ordering){
+        Ordering.new([[:b, :asc]])
+      }
+
+      shared_examples_for "the expected Quota::Cesure" do
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Quota::Cesure cog' do
+          subject.should be_a(Engine::Quota::Cesure)
+        end
+
+        it 'has the correct parameters' do
+          subject.by.should eq(AttrList[:a])
+          subject.summarization.should be(summarization)
+        end
+      end
+
+      context 'when not sorted' do
+        let(:expr){
+          quota(an_operand(leaf), [:a], ordering, summarization)
+        }
+
+        it_should_behave_like "the expected Quota::Cesure"
+
+        it 'has a Sort as sub-cog' do
+          subject.operand.should be_a(Engine::Sort)
+          subject.operand.ordering.should eq(Ordering.new([[:a, :asc], [:b, :asc]]))
+        end
+
+        it 'has the leaf has sub-sub cog' do
+          subject.operand.operand.should be(leaf)
+        end
+      end
+
+      context 'when already sorted' do
+        let(:expr){
+          quota(sort(an_operand(leaf), subordering), [:a], ordering, summarization)
+        }
+
+        context 'in a compatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :asc], [:b, :asc]])
+          }
+
+          it_should_behave_like "the expected Quota::Cesure"
+          it_should_behave_like "a compiled reusing a sub Sort"
+        end
+
+        context 'in an incompatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :desc], [:b, :asc]])
+          }
+
+          it_should_behave_like "the expected Quota::Cesure"
+
+          it 'has a Sort as sub-cog' do
+            subject.operand.should be_a(Engine::Sort)
+            subject.operand.ordering.should eq(Ordering.new([[:a, :asc], [:b, :asc]]))
+          end
+
+          it 'has a Sort as sub-sub-cog' do
+            subject.operand.operand.should be_a(Engine::Sort)
+            subject.operand.operand.ordering.should be(subordering)
+          end
+
+          it 'has the leaf has sub-sub-sub cog' do
+            subject.operand.operand.operand.should be(leaf)
+          end
+        end
+
+      end
+
+    end
+  end
+end