alf-core 0.13.0

data/spec/unit/alf-io/renderer/text/test_row.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  class Renderer::Text
+    describe Row do
+     
+      let(:row){ Row.new(values) }
+
+      describe "when single values are used only" do
+
+        let(:values){ [ 10/3.0, true ] }
+        specify "rendering_lines" do
+          row.rendering_lines.should == ["| 3.333 | true |"]
+          row.rendering_lines([10,5]).should == ["|      3.333 | true  |"]
+        end
+
+      end
+
+      describe "when multiple-line values are used" do
+
+        let(:values){ [ 10/3.0, [1, 2, 3] ] }
+
+        specify "rendering_lines" do
+          row.rendering_lines.should == ["| 3.333 | [1, 2, 3] |"]
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/alf-io/renderer/text/test_table.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+module Alf
+  class Renderer::Text
+    describe Table do
+     
+      let(:columns){ [ :method, :total ] }
+      let(:table){ Table.new(records, columns) }
+
+      describe "on an empty table" do
+
+        let(:records){ [ ] }
+
+        specify "to_s" do
+          table.to_s.should == "+---------+--------+\n" +
+                               "| :method | :total |\n" +
+                               "+---------+--------+\n" +
+                               "+---------+--------+\n"
+        end
+
+      end
+
+      describe "when single values are used only" do
+
+        let(:records){ [ [:by_x, 10.0], [:by_y, 2.0] ] }
+
+        specify "to_s" do
+          table.to_s.should == "+---------+--------+\n" +
+                               "| :method | :total |\n" +
+                               "+---------+--------+\n" +
+                               "| :by_x   | 10.000 |\n" +
+                               "| :by_y   |  2.000 |\n" +
+                               "+---------+--------+\n"
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/alf-io/shared_examples/a_reader_class.rb

@@ -0,0 +1,19 @@
+shared_examples_for "a Reader class" do
+
+  it 'should be a subclass of Reader' do
+    described_class.ancestors.should include(Alf::Reader)
+  end
+
+  it "has a default mime type" do
+    described_class.should respond_to(:mime_type)
+  end
+
+  describe "an instance" do
+    let(:reader){ described_class.new(StringIO.new("")) }
+
+    it 'returns a Enumerator with #each without block' do
+      reader.each.should be_a(Enumerator)
+    end
+  end
+
+end

data/spec/unit/alf-io/shared_examples/a_renderer_class.rb

@@ -0,0 +1,24 @@
+shared_examples_for "a Renderer class" do
+
+  it 'should be a subclass of Renderer' do
+    subject.ancestors.should include(Alf::Renderer)
+  end
+
+  it "has a default mime type" do
+    subject.should respond_to(:mime_type)
+  end
+
+  describe "an instance" do
+    let(:renderer){ subject.new([{id: 1}]) }
+
+    it 'renders and returns a buffer with #execute' do
+      buf = ""
+      renderer.execute(buf).should be(buf)
+    end
+
+    it 'returns a Enumerator with #each without block' do
+      renderer.each.should be_a(Enumerator)
+    end
+  end
+
+end

data/spec/unit/alf-io/support/test_proc_io.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  module Support
+    describe CSVUtils::ProcIO do
+      include CSVUtils
+
+      it 'works as expected' do
+        @seen = nil
+        proc_io = CSVUtils::ProcIO.new{|str| @seen = str}
+        with_csv(proc_io, row_sep: "\n") do |csv|
+          csv << ["Smith", 20, "London"]
+        end
+        @seen.should eq("Smith,20,London\n")
+      end
+
+    end
+  end
+end

data/spec/unit/alf-io/test_reader.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  describe Reader do
+
+    subject{ Reader }
+    it { should respond_to(:rash) }
+
+    describe "rash on a real IO" do
+      subject{ Reader.rash($stdin) }
+      it{ should be_a(Reader::Rash) }
+    end
+
+    describe "reader" do
+
+      specify "when associated" do
+        r = Reader.reader('suppliers.rash')
+        r.should be_a(Reader::Rash)
+      end
+
+      specify "when not associated" do
+        lambda{ Reader.reader('.noone') }.should raise_error
+      end
+
+      specify "when an IO" do
+        Reader.reader($stdin).should be_a(Reader::Rash)
+      end
+
+      specify "with options" do
+        r = Reader.reader('suppliers.rash', {:hello => "world"})
+        r.options.should == {:hello => "world"}
+      end
+
+    end
+
+  end
+end

data/spec/unit/alf-io/test_renderer.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+module Alf
+  describe Renderer do
+
+    subject{ Renderer }
+
+    let(:input){ [{:a => 1}] }
+
+    it { should respond_to(:rash) }
+    it { should respond_to(:text) }
+    it { should respond_to(:csv)  }
+    it { should respond_to(:yaml) }
+
+    describe 'renderer' do
+      subject{ Renderer.renderer(:rash, []) }
+
+      it{ should be_a(Renderer) }
+    end
+
+    describe 'rash' do
+      subject{ Renderer.rash(input) }
+
+      it{ should be_a(Renderer::Rash) }
+    end
+
+    describe 'rash --pretty' do
+      subject{ Renderer.rash(input, {pretty: true}) }
+
+      it{ should be_a(Renderer::Rash) }
+
+      it 'should have correct options' do
+        subject.options.should eq(pretty: true)
+      end
+    end
+
+    describe 'text' do
+      subject{ Renderer.text(input) }
+
+      it{ should be_a(Renderer::Text) }
+    end
+
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe "Aggregation methods" do
+      include Functional
+
+      let(:input){[
+        {:tested => 1,  :other => "b"},
+        {:tested => 30, :other => "a"},
+      ]}
+
+      let(:expected){[
+        {:tested => 30, :other => "a", :upcase => "A"},
+      ]}
+
+      it "should have sum" do
+        sum{ qty }.should be_a(Aggregator::Sum)
+      end
+
+      it "should have stddev aggregator" do
+        stddev{ qty }.should be_a(Aggregator::Stddev)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe "Relation(...) literal" do
+      include Functional
+
+      describe 'on a single tuple' do
+        subject{ Relation(name: "Jones") }
+
+        it{ should eq(Alf::Relation.coerce([{name: "Jones"}])) }
+      end
+
+      describe 'on an array of tuples' do
+        subject{ Relation([{name: "Jones"}, {name: "Smith"}])}
+
+        it{ should eq(Alf::Relation.coerce([{name: "Jones"}, {name: "Smith"}])) }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe "Tuple(...) literal" do
+      include Functional
+
+      subject{ Tuple(h) }
+
+      describe 'on an empty tuple' do
+        let(:h){ {} }
+        it{ should eq(Tuple::EMPTY) }
+      end
+
+      describe 'on an valid tuple' do
+        let(:h){ {:name => "Alf"} }
+        it{ should eq(Tuple(name: "Alf")) }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    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

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    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)
+          p.connection!.should eq(12)
+          p.operand.connection!.should eq(12)
+        end
+      end
+
+    end
+  end
+end

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

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

data/spec/unit/alf-lang/object_oriented/test_rendering_methods.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe ObjectOriented do
+      include ObjectOriented.new(supplier_names_relation)
+
+      Renderer.each do |name,_,clazz|
+
+        describe "#to_#{name}" do
+          subject{ :"to_#{name}" }
+          it 'should exist' do
+            meths = ObjectOriented.instance_methods.map(&:to_sym)
+            meths.should include(subject)
+          end
+
+          it 'returns a string by default' do
+            send(subject).should be_a(String)
+          end
+
+          it 'renders the values at first glance' do
+            send(subject).should =~ /Adams/
+          end
+
+          it 'returns the passed IO if any' do
+            io = StringIO.new
+            send(subject, io).should eq(io)
+          end
+
+          it 'supports options' do
+            io = StringIO.new
+            send(subject, {:sort => [:name]}, io).should eq(io)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-lang/object_oriented/test_to_array.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Alf
+  module Lang
+    describe ObjectOriented, 'to_array' do
+      include ObjectOriented.new(supplier_names_relation)
+
+      let(:ordering){ Ordering.coerce([[:name, :desc]]) }
+
+      context 'with a block' do
+        it 'yields the block with a ToArray' do
+          seen = nil
+          to_array{|x| seen = x}
+          seen.should be_a(Engine::ToArray)
+        end
+
+        it 'returns the block result' do
+          to_array{|x| 12}.should eq(12)
+        end
+
+        it 'sets the ordering correctly' do
+          to_array(:sort => ordering){|x|
+            x.ordering.should eq(ordering)
+          }
+        end
+      end
+
+      context 'without a block' do
+        it 'returns an array' do
+          to_array.should be_a(Array)
+        end
+
+        it 'respect the specified ordering' do
+          expected = supplier_names.sort.reverse
+          got      = to_array(:sort => ordering).map{|t| t[:name]}
+          got.should eq(expected)
+
+          expected = supplier_names.sort
+          got      = to_array(:sort => [:name]).map{|t| t[:name]}
+          got.should eq(expected)
+        end
+      end
+
+    end
+  end # module Lang
+end # module Alf