alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-database/options/test_parser.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Alf
+  class Database
+    describe Options, "parser" do
+
+      subject{ opts.parser }
+
+      let(:opts){ Options.new }
+
+      context 'by default' do
+
+        it { should be(Lang::Parser::Lispy) }
+      end
+
+      context 'when explicitely set' do
+        before{ opts.parser = Lang::Parser::Safer }
+
+        it{ should be(Lang::Parser::Safer) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-engine/cog/test_to_ascii_tree.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Cog, "to_cog" do
+
+      let(:cog){ Clip.new([], AttrList[:name], true) }
+
+      subject{ cog.to_ascii_tree }
+
+      it { should eq("Clip ..., [:name], {:allbut => true}\n+-- []\n") }
+
+    end
+  end
+end

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

@@ -12,8 +12,8 @@ module Alf
           {:name => "Jones", :price => 12.0, :id => 1},
           {:name => "Smith", :price => 10.0, :id => 2}
         ]
-        agg = Summarization[:size  => "count", 
-                            :total => "sum{ price }"]
+        agg = Summarization[:size  => Aggregator.count,
+                            :total => Aggregator.sum{|t| t.price }]
         exp = [
           {:size => 2, :total => 22.0}
         ]

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

@@ -20,7 +20,7 @@ module Alf
           ]
         }
         let(:predicate){
-          Predicate.parse("name =~ /^J/")
+          Predicate.native(->(t){ t.name =~ /^J/ })
         }
         let(:expected){
           [

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

@@ -5,6 +5,20 @@ module Alf
 
       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 }
@@ -48,8 +62,8 @@ module Alf
           {name: "Jones", rva: Relation(id: [1, 3]) }
         ]}
         let(:expected){[
-          {name: "Jones", rva: [Tuple(id: 1), Tuple(id: 3)] },
-          {name: "Smith", rva: [Tuple(id: 7), Tuple(id: 8)] }
+          {name: "Jones", rva: [{id: 1}, {id: 3}] },
+          {name: "Smith", rva: [{id: 7}, {id: 8}] }
         ]}
         let(:ordering){ Ordering.new([[:name, :asc], [[:rva, :id], :asc]]) }
 

data/spec/unit/alf-io/reader/test_yaml.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'json'
+module Alf
+  describe Reader::YAML do
+    it_should_behave_like "a Reader class"
+
+    let(:str)   { input.to_yaml        }
+    let(:io)    { StringIO.new(str)    }
+    let(:reader){ Reader::YAML.new(io) }
+
+    subject{ reader.to_a }
+
+    describe "when called on a Array" do
+      let(:input){ [{:id => 1},{:id => 2}] }
+
+      it "read the lines as expected" do
+        subject.should eq(input)
+      end
+    end
+
+    describe "when called on a Hash" do
+      let(:input){ {:id => 1} }
+
+      it "should yield the single Hash" do
+        subject.should eq([input])
+      end
+    end
+
+  end
+end

data/spec/unit/alf-io/renderer/test_yaml.rb

@@ -17,6 +17,17 @@ module Alf
         end
       end
 
+      describe "when relation-valued attributes" do
+        subject{ YAML.new(input).execute("") }
+
+        let(:input){ Relation(sid: "S1", parts: Relation(pid: ["P1", "P2"])) }
+
+        it 'converts to arrays and hashes' do
+          subject.should_not =~ /Relation/
+          subject.should_not =~ /Tuple/
+        end
+      end
+
     end
   end
 end

data/spec/unit/alf-lang/functional/test_aggregation.rb

@@ -13,12 +13,26 @@ module Alf
         {:tested => 30, :other => "a", :upcase => "A"},
       ]}
 
-      it "should have sum" do
-        sum{ qty }.should be_a(Aggregator::Sum)
+      context 'on sum' do
+        it "should have sum with immediate block" do
+          sum{|t| t.qty }.should be_a(Aggregator::Sum)
+        end
+
+        it "should have sum with a Proc" do
+          sum(->(t){ qty }).should be_a(Aggregator::Sum)
+        end
       end
 
-      it "should have stddev aggregator" do
-        stddev{ qty }.should be_a(Aggregator::Stddev)
+      context 'on concat' do
+        it "should have concat with immediate block" do
+          concat{|t| t.name }.should be_a(Aggregator::Concat)
+        end
+
+        it "should have sum with a Proc" do
+          agg = concat(->(t){ t.name }, between: ', ')
+          agg.should be_a(Aggregator::Concat)
+          agg.options[:between].should eq(', ')
+        end
       end
 
     end

data/spec/unit/alf-lang/parser/lispy/test_connection_bang.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    module Parser
+      describe Lispy, 'connection!' do
+
+        context 'when bound' do
+          let(:lispy){ Lispy.new([], 12) }
+
+          it 'allows obtaining its connection' do
+            lispy.connection!.should eq(12)
+          end
+        end
+
+        context 'when unbound' do
+          let(:lispy){ Lispy.new }
+
+          it 'raises when connection is used without being bound' do
+            lambda{
+              lispy.connection!
+            }.should raise_error(UnboundError)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-lang/parser/lispy/test_parse.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    module Parser
+      describe Lispy do
+
+        context 'when unbound' do
+          let(:lispy){ Lispy.new }
+
+          it 'allows parsing predicate expressions' do
+            p = lispy.parse{ eq(:x, 1) & neq(:y, 2) }
+            p.should be_a(Alf::Predicate)
+          end
+
+          it 'allows parsing relational expressions' do
+            p = lispy.parse{ project(:suppliers, [:sid]) }
+            p.should be_a(Algebra::Project)
+          end
+        end
+
+        context 'when bound' do
+          let(:lispy){ Lispy.new([], 12) }
+
+          it 'allows parsing predicate expressions' do
+            p = lispy.parse{ eq(:x, 1) & neq(:y, 2) }
+            p.should be_a(Alf::Predicate)
+          end
+
+          it 'deeply binds parsed relational expressions' do
+            p = lispy.parse{ project(:suppliers, [:sid]) }
+            p.should be_a(Algebra::Project)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-lang/parser/lispy/test_to_s.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    module Parser
+      describe Lispy, 'to_s' do
+
+        let(:lispy){ Lispy.new }
+
+        subject{ lispy.to_s }
+
+        it{ should eq("Lispy()") }
+
+      end
+    end
+  end
+end

data/spec/unit/alf-lang/parser/safer/safe.txt

@@ -0,0 +1,5 @@
+project(:suppliers, [:sid])
+Tuple(sid: 1)
+Relation(sid: 1)
+DEE
+DUM

data/spec/unit/alf-lang/parser/safer/test_parse.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    module Parser
+      describe Safer, "test_parse" do
+
+        let(:viewpoint) do
+          Module.new{
+            def suppliers
+              Algebra::Operand::Named.new(:suppliers)
+            end
+          }
+        end
+
+        let(:parser){ Safer.new([viewpoint]) }
+
+        context 'with a ruby block' do
+          subject{ parser.parse{} }
+
+          it 'raises a SecurityError' do
+            lambda{
+              subject
+            }.should raise_error(SecurityError, /Parsing of ruby blocks forbidden/)
+          end
+        end
+
+        context 'with a symbol' do
+          let(:op){ Algebra::Operand::Named.new(:suppliers) }
+          subject{ parser.parse(:suppliers) }
+
+          it 'passes and returns the operand' do
+            subject.should eq(op)
+          end
+        end
+
+        context 'with an operand' do
+          let(:op){ Algebra::Operand::Named.new(:suppliers) }
+          subject{ parser.parse(op) }
+
+          it 'returns it immediately' do
+            subject.should be(op)
+          end
+        end
+
+        context 'with an attempt attack based on a symbol' do
+          subject{ parser.parse(:"send(:suppliers)") }
+
+          it 'fails with a security error' do
+            lambda{
+              subject
+            }.should raise_error(SecurityError, /Forbidden/)
+          end
+        end
+
+        (Path.dir/'safe.txt').each_line do |line|
+          context "on '#{line.strip}'" do
+            subject{ parser.parse(line.strip) }
+
+            it 'succeeds' do
+              lambda{
+                subject
+              }.should_not raise_error
+            end
+          end
+        end
+
+        (Path.dir/'unsafe.txt').each_line do |line|
+          context "on '#{line.strip}'" do
+            subject{ parser.parse(line.strip) }
+
+            it 'raises a SecurityError' do
+              lambda{
+                subject
+              }.should raise_error(SecurityError, /Forbidden/)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-lang/parser/safer/unsafe.txt

@@ -0,0 +1,14 @@
+`ls -lA`
+::Kernel
+exit
+require "blah"
+load "blah"
+gem 'unsecure'
+suppliers.to_relvar
+suppliers.insert
+suppliers.delete
+suppliers.update
+Alf::Adapter::Connection
+Alf.connect
+Relation.new
+Tuple.new

data/spec/unit/alf-optimizer/restrict/test_on_autonum.rb

@@ -10,7 +10,7 @@ module Alf
 
       context 'when the restriction does not apply to auto at all' do
         let(:predicate){ comp(:x => 12) }
-        let(:expected) { autonum(restrict(inside, predicate)) }
+        let(:expected) { autonum(restrict(inside, predicate), :auto) }
       
         it{ should eq(expected) }
       end

data/spec/unit/alf-optimizer/test_quota.rb

@@ -3,7 +3,7 @@ module Alf
   describe "quota" do
 
     let(:summarization){
-      Summarization.coerce(:total => "sum{ qty }")
+      Summarization.coerce(:total => Aggregator.sum{ qty })
     }
 
     subject{ quota(an_operand, [:id], [[:x, :asc]], summarization) }

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

@@ -15,5 +15,12 @@ module Alf
       it_behaves_like "a pass-through expression for restrict"
     end
 
+    context 'on a native predicate' do
+      let(:predicate){ Predicate.native(->(t){ t.x == 2 }) }
+      let(:renaming) { {:x => :y} }
+
+      it_behaves_like "an unoptimizable expression for restrict"
+    end
+
   end
 end

data/spec/unit/alf-optimizer/test_summarize.rb

@@ -3,7 +3,7 @@ module Alf
   describe "summarize" do
 
     let(:summarization){
-      Summarization.coerce(:total => "sum{ qty }")
+      Summarization.coerce(:total => Aggregator.sum{ qty })
     }
     subject{ summarize(an_operand, [:id], summarization) }
 

data/spec/unit/alf-predicate/expr/test_to_proc.rb

@@ -7,13 +7,11 @@ module Alf
 
       subject{ expr.to_proc }
 
-      before do
-        subject.should be_a(Proc)
-      end
+      it{ should be_a(Proc) }
 
-      specify{
-        subject.to_ruby_literal.should eq("lambda{ x <= 2 }")
-      }
+      it 'has arity 1' do
+        subject.arity.should eq(1)
+      end
 
     end
   end

data/spec/unit/alf-predicate/expr/test_to_ruby_code.rb

@@ -10,7 +10,7 @@ module Alf
       after do
         unless expr.is_a?(Native)
           lambda{
-            eval "lambda{ #{subject} }"
+            eval(subject)
           }.should_not raise_error
         end
       end
@@ -18,103 +18,103 @@ module Alf
       context 'tautology' do
         let(:expr){ f.tautology }
 
-        it{ should eq("true") }
+        it{ should eq("->(t){ true }") }
       end
 
       context 'contradiction' do
         let(:expr){ f.contradiction }
 
-        it{ should eq("false") }
+        it{ should eq("->(t){ false }") }
       end
 
-      describe "var_ref" do
-        let(:expr){ f.var_ref(:name) }
+      describe "identifier" do
+        let(:expr){ f.identifier(:name) }
 
-        it{ should eq("name") }
+        it{ should eq("->(t){ t.name }") }
       end
 
       describe "and" do
         let(:expr){ f.and(f.contradiction, f.contradiction) }
 
-        it{ should eq("false && false") }
+        it{ should eq("->(t){ false && false }") }
       end
 
       describe "or" do
         let(:expr){ f.or(f.contradiction, f.contradiction) }
 
-        it{ should eq("false || false") }
+        it{ should eq("->(t){ false || false }") }
       end
 
       describe "not" do
         let(:expr){ f.not(f.contradiction) }
 
-        it{ should eq("!false") }
+        it{ should eq("->(t){ !false }") }
       end
 
       describe "comp" do
         let(:expr){ f.comp(:lt, {:x => 2}) }
 
-        it{ should eq("x < 2") }
+        it{ should eq("->(t){ t.x < 2 }") }
       end
 
       describe "eq" do
         let(:expr){ f.eq(:x, 2) }
 
-        it{ should eq("x == 2") }
+        it{ should eq("->(t){ t.x == 2 }") }
       end
 
       describe "eq (parentheses required)" do
         let(:expr){ f.eq(f.eq(:y, 2), true) }
 
-        it{ should eq("(y == 2) == true") }
+        it{ should eq("->(t){ (t.y == 2) == true }") }
       end
 
       describe "comp (multiple)" do
         let(:expr){ f.comp(:eq, :x => 2, :y => 3) }
 
-        it{ should eq("(x == 2) && (y == 3)") }
+        it{ should eq("->(t){ (t.x == 2) && (t.y == 3) }") }
       end
 
       describe "in" do
         let(:expr){ f.in(:x, [2, 3]) }
 
-        it{ should eq("[2, 3].include?(x)") }
+        it{ should eq("->(t){ [2, 3].include?(t.x) }") }
       end
 
       describe "neq" do
         let(:expr){ f.neq(:x, 2) }
 
-        it{ should eq("x != 2") }
+        it{ should eq("->(t){ t.x != 2 }") }
       end
 
       describe "gt" do
         let(:expr){ f.gt(:x, 2) }
 
-        it{ should eq("x > 2") }
+        it{ should eq("->(t){ t.x > 2 }") }
       end
 
       describe "gte" do
         let(:expr){ f.gte(:x, 2) }
 
-        it{ should eq("x >= 2") }
+        it{ should eq("->(t){ t.x >= 2 }") }
       end
 
       describe "lt" do
         let(:expr){ f.lt(:x, 2) }
 
-        it{ should eq("x < 2") }
+        it{ should eq("->(t){ t.x < 2 }") }
       end
 
       describe "lte" do
         let(:expr){ f.lte(:x, 2) }
 
-        it{ should eq("x <= 2") }
+        it{ should eq("->(t){ t.x <= 2 }") }
       end
 
       describe "literal" do
         let(:expr){ f.literal(12) }
 
-        it{ should eq("12") }
+        it{ should eq("->(t){ 12 }") }
       end
 
       describe "native" do
@@ -130,7 +130,7 @@ module Alf
           f.and(f.eq(:x, 2), f.eq(:y, 3))
         }
 
-        it{ should eq("(x == 2) && (y == 3)") }
+        it{ should eq("->(t){ (t.x == 2) && (t.y == 3) }") }
       end
 
       describe "conjunction of two comps" do
@@ -138,7 +138,7 @@ module Alf
           f.and(f.comp(:eq, :x => 2), f.comp(:eq, :y => 3))
         }
 
-        it{ should eq("(x == 2) && (y == 3)") }
+        it{ should eq("->(t){ (t.x == 2) && (t.y == 3) }") }
       end
 
       describe "or and and" do
@@ -146,7 +146,7 @@ module Alf
           f.and(f.eq(:x, 2), f.or(true, false))
         }
 
-        it{ should eq("(x == 2) && (true || false)") }
+        it{ should eq("->(t){ (t.x == 2) && (true || false) }") }
       end
 
     end