alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-aggregator/test_count.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Aggregator
-    describe Count do
-
-      it 'should work when used standalone' do
-        Count.new.aggregate([]).should eq(0)
-        Count.new.aggregate([{}]).should eq(1)
-      end
-
-      it 'should install factory methods' do
-        Aggregator.count.should be_a(Count)
-      end
-
-    end
-  end
-end 

data/spec/unit/alf-aggregator/test_max.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Aggregator
-    describe Max do
-
-      let(:rel){[
-        {:qty => 10}, 
-        {:qty => 0}
-      ]}
-
-      it 'should work when used standalone' do
-        Max.new{ qty }.aggregate([]).should eq(nil)
-        Max.new{ qty }.aggregate(rel).should eq(10)
-      end
-
-      it 'should install factory methods' do
-        Aggregator.max{ qty }.should be_a(Max)
-        Aggregator.max{ qty }.aggregate(rel).should eq(10)
-      end
-
-    end
-  end
-end 

data/spec/unit/alf-aggregator/test_min.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Aggregator
-    describe Min do
-
-      let(:rel){[
-        {:qty => 10}, 
-        {:qty => 0}
-      ]}
-
-      it 'should work when used standalone' do
-        Min.new{ qty }.aggregate([]).should eq(nil)
-        Min.new{ qty }.aggregate(rel).should eq(0)
-      end
-
-      it 'should install factory methods' do
-        Aggregator.min{ qty }.should be_a(Min)
-        Aggregator.min{ qty }.aggregate(rel).should eq(0)
-      end
-
-    end
-  end
-end 

data/spec/unit/alf-aggregator/test_stddev.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Aggregator
-    describe Stddev do
-
-      let(:rel){[
-        {:qty => 10}, 
-        {:qty => 20},
-        {:qty => 30},
-        {:qty => 40}
-      ]}
-      let(:expected) {
-        Math.sqrt(Variance.new{qty}.aggregate(rel))
-      }
-
-      it 'should work when used standalone' do
-        Stddev.new{ qty }.aggregate(rel).should eq(expected)
-      end
-
-      it 'should install factory methods' do
-        Aggregator.stddev{ qty }.should be_a(Stddev)
-        Aggregator.stddev{ qty }.aggregate(rel).should eq(expected)
-      end
-
-    end
-  end
-end 

data/spec/unit/alf-aggregator/test_sum.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Aggregator
-    describe Sum do
-
-      let(:rel){[
-        {:qty => 10}, 
-        {:qty => 20}
-      ]}
-
-      it 'should work when used standalone' do
-        Sum.new{ qty }.aggregate([]).should eq(0)
-        Sum.new{ qty }.aggregate(rel).should eq(30)
-      end
-
-      it 'should install factory methods' do
-        Aggregator.sum{ qty }.should be_a(Sum)
-        Aggregator.sum{ qty }.aggregate(rel).should eq(30)
-      end
-
-    end
-  end
-end 

data/spec/unit/alf-aggregator/test_variance.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  class Aggregator
-    describe Variance do
-
-      let(:rel){[
-        {:qty => 10}, 
-        {:qty => 20},
-        {:qty => 30},
-        {:qty => 40}
-      ]}
-      let(:expected) {
-        vals = rel.map{|t| t[:qty]}
-        mean = vals.inject(:+) / vals.size.to_f
-        vals.collect{|v| (v - mean)**2 }.inject(:+) / vals.size.to_f
-      }
-
-      it 'should work when used standalone' do
-        Variance.new{ qty }.aggregate(rel).should eq(expected)
-      end
-
-      it 'should install factory methods' do
-        Aggregator.variance{ qty }.should be_a(Variance)
-        Aggregator.variance{ qty }.aggregate(rel).should eq(expected)
-      end
-
-    end
-  end
-end 

data/spec/unit/alf-algebra/operand/named/test_hash_and_equal.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Named, "hash and ==" do
-
-        let(:op1){
-          Named.new(:foo)
-        }
-
-        context '==' do
-
-          it 'recognizes same operands' do
-            op1.should eq(op1)
-            op1.should eq(Named.new(:foo))
-          end
-
-          it 'distinguises other operands' do
-            op1.should_not eq(nil)
-            op1.should_not eq(Named.new(:foo, :bar))
-          end
-        end
-
-        context 'hash' do
-
-          it 'it the same on same operands' do
-            op1.hash.should eq(Named.new(:foo).hash)
-          end
-        end
-
-        context 'using named operands as hash keys' do
-
-          let(:h){
-            { op1 => 1,
-              Named.new(:bar) => 2,
-              Named.new(:foo, :bar) => 3 }
-          }
-
-          it 'should lead to expected hash' do
-            h.size.should eq(3)
-          end
-
-          it 'should behave as expected' do
-            h[op1].should eq(1)
-            h[Named.new(:foo)].should eq(1)
-            h[Named.new(:foo, :bar)].should eq(3)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/named/test_keys.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Named, "keys" do
-
-        let(:operand){ Named.new(:foo, self) }
-
-        subject{ operand.keys }
-
-        def keys(name)
-          [name]
-        end
-
-        it 'delegates to the underlying connection when bound' do
-          subject.should eq([:foo])
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/named/test_to_ascii_tree.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Named, "to_ascii_tree" do
-
-        subject{ operand.to_ascii_tree }
-
-        let(:operand){ Named.new(:foo, self) }
-
-        it 'returns the heading' do
-          subject.should eq("foo\n")
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/named/test_to_cog.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Named, "to_cog" do
-
-        let(:operand){ Named.new(:foo, self) }
-
-        subject{ operand.to_cog(12) }
-
-        def cog(plan, expr)
-          plan.should eq(12)
-          expr.should be(operand)
-          [:a_cog, expr.name]
-        end
-
-        it 'delegates to the underlying connection when bound' do
-          subject.should eq([:a_cog, :foo])
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/named/test_to_relvar.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Named, "to_relvar" do
-
-        let(:operand){ Named.new(:foo, self) }
-
-        subject{ operand.to_relvar }
-
-        it 'returns a base relvar' do
-          subject.should be_a(Relvar::Base)
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/named/test_type_check.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Named, "type_check" do
-
-        subject{ operand.type_check }
-
-        def knows?(name)
-          name == :foo
-        end
-
-        def heading(name)
-          :"#{name}_heading"
-        end
-
-        context 'when known' do
-          let(:operand){ Named.new(:foo, self) }
-
-          it 'returns the heading' do
-            subject.should eq(:foo_heading)
-          end
-        end
-
-        context 'when unknown' do
-          let(:operand){ Named.new(:bar, self) }
-
-          it 'raises a TypeCheckError' do
-            lambda{
-              subject
-            }.should raise_error(TypeCheckError, /No such relvar `bar`/)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/proxy/test_to_cog.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Proxy, "to_cog" do
-
-        subject{
-          proxy.to_cog
-        }
-
-        let(:proxy){
-          Proxy.new(proxied)
-        }
-
-        context 'when delegable' do
-          let(:proxied){
-            Struct.new(:to_cog).new(:compiled)
-          }
-
-          before do
-            proxied.should respond_to(:to_cog)
-          end
-
-          it{ should eq(:compiled) }
-        end
-
-        context 'when non delegable' do
-          let(:proxied){
-            [{a: 1}]
-          }
-
-          it{ should be_a(Engine::Leaf) }
-
-          it 'should be the correct proxy' do
-            subject.operand.should be(proxied)
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/test_coerce.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Operand, '.coerce' do
-
-      subject{ Operand.coerce(arg) }
-
-      context "on a Symbol" do
-        let(:arg){ :suppliers }
-
-        it 'coerces it as a named operand' do
-          subject.should be_a(Operand::Named)
-          subject.name.should eq(:suppliers)
-        end
-      end
-
-      context "on a Hash" do
-        let(:arg){ {name: "Jones"} }
-
-        it 'coerces it as a proxy operand on an array' do
-          subject.should be_a(Operand::Proxy)
-          subject.subject.should eq([ arg ])
-        end
-      end
-
-      context "on a Tuple" do
-        let(:arg){ Tuple(name: "Jones") }
-
-        it 'coerces it as a proxy operand on an array' do
-          subject.should be_a(Operand::Proxy)
-          subject.subject.should eq([ arg ])
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operand/test_proxy.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    module Operand
-      describe Proxy do
-
-        DELEGATED = [ :heading, :keys ]
-
-        subject{
-          Proxy.new(victim).send(method)
-        }
-
-        DELEGATED.each do |method|
-          context "with #{method} with knowing victim" do
-            let(:method){
-              method
-            }
-            let(:victim){
-              Struct.new(method).new("foo")
-            }
-
-            before do
-              victim.should respond_to(method)
-            end
-
-            it "should delegate it" do
-              subject.should eq("foo")
-            end
-          end
-
-          context "with #{method} with unknowing victim" do
-            let(:method){
-              method
-            }
-            let(:victim){
-              Object.new
-            }
-
-            before do
-              victim.should_not respond_to(method)
-            end
-
-            it "should raise a NotSupportedError" do
-              lambda{
-                subject
-              }.should raise_error(NotSupportedError)
-            end
-          end
-        end
-
-      end
-    end
-  end
-end