alf-core 0.13.1 → 0.14.0

data/spec/unit/alf-types/ordering/test_to_attr_list.rb

@@ -2,12 +2,24 @@ require 'spec_helper'
 module Alf
   describe Ordering, "to_attr_list" do
 
-    it 'should work on an empty ordering' do
-      Ordering.new([]).to_attr_list.should eq(AttrList.new [])
+    subject{ ordering.to_attr_list }
+
+    context 'on an empty ordering' do
+      let(:ordering){ Ordering::EMPTY }
+
+      it{ should eq(AttrList::EMPTY) }
+    end
+
+    context 'on an ordering with single names' do
+      let(:ordering){ Ordering.new([[:a, :asc], [:b, :desc]]) }
+
+      it{ should eq(AttrList[:a, :b]) }
     end
 
-    it 'should return the correct list of attribute names' do
-      Ordering.new([[:a, :asc], [:b, :desc]]).to_attr_list.should eq(AttrList[:a, :b])
+    context 'on an ordering with hirarchical names' do
+      let(:ordering){ Ordering.new([[[:x, :a], :asc], [:b, :desc]]) }
+
+      it{ should eq(AttrList[:x, :b]) }
     end
 
   end # Ordering

data/spec/unit/alf-types/ordering/test_total.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "total" do
+
+    subject{ ordering.total(keys) }
+
+    context 'when the ordering already covers a key' do
+      let(:ordering){ Ordering[[:city, :name]] }
+      let(:keys)    { Keys[[:name]]   }
+
+      it{ should eq(ordering) }
+    end
+
+    context 'when the ordering supercovers a key' do
+      let(:ordering){ Ordering[[:name, :city]] }
+      let(:keys)    { Keys[[:name]]   }
+
+      it{ should eq(ordering) }
+    end
+
+    context 'when the ordering covers no key (no overlap)' do
+      let(:ordering){ Ordering[[:name, :city]] }
+      let(:keys)    { Keys[[:id]]   }
+
+      it{ should eq(Ordering[[:name, :city, :id]]) }
+    end
+
+    context 'when the ordering covers no key (with overlap)' do
+      let(:ordering){ Ordering[[:name, :asc, :city, :desc]] }
+      let(:keys)    { Keys[[:id, :city]]   }
+
+      it{ should eq(Ordering[[:name, :asc, :city, :desc, :id, :asc]]) }
+    end
+
+    context 'when the keys are empty and a block' do
+      let(:ordering){ Ordering[[:name, :asc, :city, :desc]] }
+      let(:keys)    { Keys[]   }
+
+      subject{ ordering.total(keys){ AttrList[:name, :city, :status] } }
+
+      it{ should eq(Ordering[[:name, :asc, :city, :desc, :status, :asc]]) }
+    end
+
+    context 'when the keys are empty and no block' do
+      let(:ordering){ Ordering[[:name, :city]] }
+      let(:keys)    { Keys[]   }
+
+      it 'should raise an error' do
+        lambda{
+          subject
+        }.should raise_error(NotSupportedError)
+      end
+    end
+
+  end
+end

data/spec/unit/alf-types/selection/test_coerce.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  describe Selection, ".coerce" do
+
+    subject{ Selection.coerce(arg) }
+
+    before do
+      subject.should be_a(Selection)
+    end
+
+    let(:expected){
+      Selection.new([ Selector.new(:name), Selector.new(:city) ])
+    }
+
+    context 'on an array of strings' do
+      let(:arg){ ["name", "city"] }
+
+      it { should eq(expected) }
+    end
+
+    context 'on an array of strings with composite selections' do
+      let(:arg){ ["name", "city.name"] }
+
+      let(:expected){
+        Selection.new([ Selector.new(:name), Selector.new([:city, :name]) ])
+      }
+
+      it { should eq(expected) }
+    end
+
+    context 'on an array of symbols' do
+      let(:arg){ [:name, :city] }
+
+      it { should eq(expected) }
+    end
+
+  end
+end

data/spec/unit/alf-types/selection/test_select.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  describe Selection, "select" do
+
+    subject{ selection.select(tuple) }
+
+    let(:tuple){ {name: "foo", city: {name: "bar"}} }
+
+    context 'on a selection of name' do
+      let(:selection){ Selection.coerce(["name"]) }
+
+      it{ should eq(["foo"]) }
+    end
+
+    context 'on a selection of city' do
+      let(:selection){ Selection.coerce(["city"]) }
+
+      it{ should eq([{name: "bar"}]) }
+    end
+
+    context 'on a selection of city.name' do
+      let(:selection){ Selection.coerce(["city.name"]) }
+
+      it{ should eq(["bar"]) }
+    end
+
+    context 'on a selection of name and city.name' do
+      let(:selection){ Selection.coerce(["name", "city.name"]) }
+
+      it{ should eq(["foo","bar"]) }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_coerce.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  describe Selector, ".coerce" do
+
+    subject{ Selector.coerce(arg) }
+
+    before do
+      subject.should be_a(Selector)
+    end
+
+    context 'on a Symbol' do
+      let(:arg){ :name }
+
+      it { should eq(Selector.new(:name)) }
+    end
+
+    context 'on a single string' do
+      let(:arg){ "name" }
+
+      it { should eq(Selector.new(:name)) }
+    end
+
+    context 'on a composite string' do
+      let(:arg){ "a.name" }
+
+      it { should eq(Selector.new([:a, :name])) }
+    end
+
+    context 'on an array of strings' do
+      let(:arg){ ["a", "name"] }
+
+      it { should eq(Selector.new([:a, :name])) }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_composite_q.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "composite?" do
+
+    subject{ selector.composite? }
+
+    context 'on a single' do
+      let(:selector){ Selector.coerce(:name) }
+
+      it { should be_false }
+    end
+
+    context 'on a composite' do
+      let(:selector){ Selector.coerce([:a, :name]) }
+
+      it { should be_true }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_dive.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "dive" do
+
+    subject{ selector.dive(:a) }
+
+    context 'on a single, not the same' do
+      let(:selector){ Selector.coerce(:name) }
+
+      it { should be_nil }
+    end
+
+    context 'on a single, same' do
+      let(:selector){ Selector.coerce(:a) }
+
+      it { should be_nil }
+    end
+
+    context 'on a composite, starting with' do
+      let(:selector){ Selector.coerce([:a, :b, :c]) }
+
+      it { should eq(Selector.coerce([:b, :c])) }
+    end
+
+    context 'on a composite, not starting with' do
+      let(:selector){ Selector.coerce([:b, :a]) }
+
+      it { should be_nil }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_select.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "select" do
+
+    subject{ selector.select(tuple) }
+
+    let(:tuple){ {name: "foo", city: {name: "bar"}} }
+
+    context 'on name' do
+      let(:selector){ Selector.coerce("name") }
+
+      it{ should eq("foo") }
+    end
+
+    context 'on city' do
+      let(:selector){ Selector.coerce("city") }
+
+      it{ should eq(name: "bar") }
+    end
+
+    context 'on unexisting' do
+      let(:selector){ Selector.coerce("unexisting") }
+
+      it{ should be_nil }
+    end
+
+    context 'on unexisting composite' do
+      let(:selector){ Selector.coerce("city.unexisting") }
+
+      it{ should be_nil }
+    end
+
+    context 'on unexisting composite II' do
+      let(:selector){ Selector.coerce("cities.unexisting") }
+
+      it{ should be_nil }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_simple_q.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "simple?" do
+
+    subject{ selector.simple? }
+
+    context 'on a single' do
+      let(:selector){ Selector.coerce(:name) }
+
+      it { should be_true }
+    end
+
+    context 'on a composite' do
+      let(:selector){ Selector.coerce([:a, :name]) }
+
+      it { should be_false }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_to_a.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "to_a" do
+
+    subject{ selector.to_a }
+
+    context 'on a single' do
+      let(:selector){ Selector.coerce(:name) }
+
+      it { should eq([:name]) }
+    end
+
+    context 'on a composite' do
+      let(:selector){ Selector.coerce([:a, :name]) }
+
+      it { should eq([:a, :name]) }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_to_lispy.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "to_lispy" do
+
+    subject{ selector.to_lispy }
+
+    context 'on a single' do
+      let(:selector){ Selector.coerce(:name) }
+
+      it { should eq(':name') }
+    end
+
+    context 'on a composite' do
+      let(:selector){ Selector.coerce([:a, :name]) }
+
+      it { should eq('[:a, :name]') }
+    end
+
+  end
+end

data/spec/unit/alf-types/selector/test_to_ruby_literal.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Selector, "to_ruby_literal" do
+
+    subject{ selector.to_ruby_literal }
+
+    context 'on a single' do
+      let(:selector){ Selector.coerce(:name) }
+
+      it { should eq('Alf::Selector[:name]') }
+    end
+
+    context 'on a composite' do
+      let(:selector){ Selector.coerce([:a, :name]) }
+
+      it { should eq('Alf::Selector[[:a, :name]]') }
+    end
+
+  end
+end

data/spec/unit/alf-types/tuple_expression/test_evaluate.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  describe TupleExpression, 'evaluate' do
+
+    subject{ exp.evaluate(scope) }
+
+    let(:tuple){ Tuple(name: "Jones") }
+
+    let(:scope){ Support::TupleScope.new(tuple) }
+
+    context 'when the proc is of arity 0' do
+      let(:exp){ TupleExpression[->(){ name.upcase }] }
+
+      it{ should eq("JONES") }
+    end
+
+    context 'when the proc is of arity 1' do
+      let(:exp){ TupleExpression[->(t){ t.name.upcase }] }
+
+      it{ should eq("JONES") }
+    end
+
+    context 'when the proc returns a bound expression' do
+      let(:exp){ TupleExpression[->(t){ Algebra::Operand::Named.new(:suppliers, examples_database) }] }
+
+      it{ should be_a(Relation) }
+    end
+
+    context 'when the proc returns a unbound, yet boundable expression' do
+      let(:exp){ TupleExpression[->(t){ Algebra::Operand::Named.new(:suppliers) }] }
+
+      subject{ exp.evaluate(scope, examples_database) }
+
+      it{ should be_a(Relation) }
+    end
+
+  end # TupleExpression
+end # Alf

data/spec/unit/alf-viewpoint/metadata/test_add_members.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Viewpoint
+    describe Metadata, "#add_members" do
+
+      context 'on empty expectations' do
+        let(:metadata){ Metadata.new }
+
+        subject{ metadata.add_members([1, 2]) }
+
+        it 'sets members' do
+          subject.members.should eq([1, 2])
+        end
+      end
+
+      context 'on disjoint members' do
+        let(:metadata){ Metadata.new([], {}, [1, 2]) }
+
+        subject{ metadata.add_members([3, 4]) }
+
+        it 'sets members' do
+          subject.members.should eq([1, 2, 3, 4])
+        end
+      end
+
+      context 'on overlapping members' do
+        let(:metadata){ Metadata.new([], {}, [1, 2]) }
+
+        subject{ metadata.add_members([1, 4]) }
+
+        it 'sets members' do
+          subject.members.should eq([1, 2, 4])
+        end
+      end
+
+    end
+  end
+end