axiom-arango-adapter 0.0.1

data/spec/unit/axiom/adapter/arango/gateway/summarize_spec.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Gateway, '#summarize' do
+  let(:summarization) { mock('Summarization', :kind_of? => true)      }
+  let(:adapter)       { mock('Adapter')                               }
+  let(:relation)      { mock('Relation', :summarize => summarization) }
+  let!(:object)       { described_class.new(adapter, relation)        }
+  let(:block)         { lambda { |context| }                          }
+
+  context 'with no arguments' do
+    subject { object.summarize(&block) }
+
+    let(:gateway) { mock('New Gateway') }
+
+    before do
+      described_class.stub!(:new).and_return(gateway)
+    end
+
+    it { should equal(gateway) }
+
+    it 'forwards the default summarize_with relation to relation#summarize' do
+      relation.should_receive(:summarize) do |other|
+        other.should equal(Axiom::TABLE_DEE)
+      end
+      subject
+    end
+
+    it 'forwards the block to relation#summarize' do
+      relation.stub!(:summarize) do |_summarize_with, &proc|
+        proc.should equal(block)
+      end
+      subject
+    end
+
+    it 'initializes the gateway with the adapter and summarization' do
+      described_class.should_receive(:new).with(adapter, summarization)
+      subject
+    end
+  end
+
+  context 'with a header' do
+    subject { object.summarize(header, &block) }
+
+    let(:gateway) { mock('New Gateway') }
+    let(:header)  { mock('Header')      }
+
+    before do
+      described_class.stub!(:new).and_return(gateway)
+    end
+
+    it { should equal(gateway) }
+
+    it 'forwards the header to relation#summarize' do
+      relation.should_receive(:summarize) do |other|
+        other.should equal(header)
+      end
+      subject
+    end
+
+    it 'forwards the block to relation#summarize' do
+      relation.stub!(:summarize) do |_summarize_with, &proc|
+        proc.should equal(block)
+      end
+      subject
+    end
+
+    it 'initializes the gateway with the adapter and summarization' do
+      described_class.should_receive(:new).with(adapter, summarization)
+      subject
+    end
+  end
+
+  context 'when summarize_with has the same adapter' do
+    subject { object.summarize(other, &block) }
+
+    let(:header)         { mock('Header')                               }
+    let(:other_relation) { mock('Other Relation', :header => header)    }
+    let!(:other)         { described_class.new(adapter, other_relation) }
+    let(:gateway)        { mock('New Gateway')                          }
+
+    before do
+      described_class.stub!(:new).and_return(gateway)
+    end
+
+    it { should equal(gateway) }
+
+    it 'forwards the other relation to relation#summarize' do
+      relation.should_receive(:summarize) do |other|
+        other.should equal(other_relation)
+      end
+      subject
+    end
+
+    it 'forwards the block to relation#summarize' do
+      relation.stub!(:summarize) do |_summarize_with, &proc|
+        proc.should equal(block)
+      end
+      subject
+    end
+
+    it 'initializes the gateway with the adapter and summarization' do
+      described_class.should_receive(:new).with(adapter, summarization)
+      subject
+    end
+  end
+
+  context 'with a relation' do
+    subject { object.summarize(summarize_with, &block) }
+
+    let(:context_header)   { mock('Context Header')                              }
+    let(:header)           { mock('Header', :- => context_header)                }
+    let(:summarize_header) { mock('Summarize With Header')                       }
+    let(:summarize_with)   { mock('Other Relation', :header => summarize_header) }
+    let(:functions)        { mock('Functions')                                   }
+    let(:context)          { mock('Context', :functions => functions)            }
+
+    before do
+      relation.stub!(:header).and_return(header)
+      Axiom::Algebra::Summarization.stub!(:new).and_return(summarization)
+      Axiom::Evaluator::Context.stub!(:new).with(context_header, &block).and_return(context)
+    end
+
+    it { should equal(summarization) }
+
+    it 'gets the context header' do
+      header.should_receive(:-).with(summarize_header)
+      subject
+    end
+
+    it 'passes the context header into the context' do
+      Axiom::Evaluator::Context.should_receive(:new).with(context_header)
+      subject
+    end
+
+    it 'forwards the block to the context' do
+      Axiom::Evaluator::Context.should_receive(:new) do |_header, &proc| 
+        proc.should equal(block) 
+        context
+      end
+      subject
+    end
+
+    it 'initializes the summarization with the gateway, the relation and the functions' do
+      Axiom::Algebra::Summarization.should_receive(:new).with(object, summarize_with, functions)
+      subject
+    end
+  end
+end

data/spec/unit/axiom/adapter/arango/gateway/take_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Gateway, '#take' do
+  subject { object.take(args) }
+
+  let(:adapter)  { mock('Adapter')                         }
+  let(:relation) { mock('Relation', :take => response)     }
+  let(:response) { mock('New Relation', :kind_of? => true) }
+  let!(:object)  { described_class.new(adapter, relation)  }
+  let(:args)     { stub                                    }
+
+  it_should_behave_like 'a unary relation method'
+
+  it 'forwards the arguments to relation#take' do
+    relation.should_receive(:take).with(args)
+    subject
+  end
+end

data/spec/unit/axiom/adapter/arango/gateway/unhandled_message_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Gateway, '#unhandled_message' do
+  subject { object.unhandled_message }
+
+  let(:adapter)  { mock('Adapter')                         }
+  let(:relation) { mock('Relation', :drop => response)     }
+  let(:response) { mock('New Relation', :kind_of? => true) }
+  let(:object)   { described_class.new(adapter, relation)  }
+  let(:args)     { stub                                    }
+
+  it 'raises no method error' do
+    expect { subject }.to raise_error(NoMethodError)
+  end
+end

data/spec/unit/axiom/adapter/arango/gateway/union_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Gateway, '#union' do
+  subject { object.union(other) }
+
+  let(:adapter)         { mock('Adapter')                        }
+  let(:relation)        { mock('Relation')                       }
+  let(:object)          { described_class.new(adapter, relation) }
+  let(:operation)       { :union                                 }
+  let(:factory)         { Axiom::Algebra::Union                }
+  let(:binary_relation) { mock(factory)                          }
+
+  it_should_behave_like 'a binary relation method'
+end

data/spec/unit/axiom/adapter/arango/reader/each_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Reader, '#each' do
+  let(:object)     { described_class.new(adapter, relation)                                 }
+  let(:adapter)    { mock('Adapter', :database => database, :logger => logger)              }
+  let(:aql_node)   { mock('AQL Node', :aql => aql)                                          }
+  let(:aql)        { mock('AQL')                                                            }
+  let(:logger)     { mock('Logger')                                                         }
+  let(:header)     { Axiom::Relation::Header.coerce([[:id, Integer], [:name, String]])    }
+  let(:relation)   { mock('Relation', :header => header)                                    }
+  let(:database)   { mock('Database', :query => query)                                      }
+  let(:query)      { mock('Query')                                                          }
+  let(:yields)     { []                                                                     }
+  let(:cursor)     { [document_a, document_b]                                               }
+  let(:document_a) { mock('Document A', :to_hash => hash_a)                                 }
+  let(:document_b) { mock('Document B', :to_hash => hash_b)                                 }
+  let(:hash_a)     { { 'id' => 1, 'name' => 'Markus Schirp' }                               }
+  let(:hash_b)     { { 'id' => 2, 'name' => 'John Doe' }                                    }
+  let(:tuple_a)    { Axiom::Tuple.new(header, document_a.to_hash.values_at('id', 'name')) }
+  let(:tuple_b)    { Axiom::Tuple.new(header, document_b.to_hash.values_at('id', 'name')) }
+
+  subject { object.each { |item| yields << item } }
+
+  before do
+    logger.stub(:debug)
+    Axiom::Adapter::Arango::Visitor.stub(:run).with(relation).and_return(aql_node) 
+    query.stub(:execute).with(aql).and_return(cursor)
+  end
+
+  it_should_behave_like 'an #each method'
+
+  it 'should yield expected tuples' do
+    expect { subject }.to change { yields }.from([]).to([tuple_a, tuple_b])
+  end
+
+  it 'should log aql' do
+    logger.should_receive(:debug) do |&block|
+      block.call.should eql("AQL: #{aql}")
+    end
+    subject
+  end
+
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/count/root_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Count, '#root' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:bar]) { |r| r.add(:count, r.foo.count) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    LENGTH((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/count_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Count, '#root' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:bar]) { |r| r.add(:count, r.foo.count) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    LENGTH((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/maximum/root_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Maximum, '#root' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:bar]) { |r| r.add(:max, r.foo.max) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    MAX((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/maximum_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Maximum, '#root' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:bar]) { |r| r.add(:max, r.foo.max) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    MAX((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/minimum/root_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Minimum, '#root' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:bar]) { |r| r.add(:min, r.foo.min) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    MIN((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/minimum_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Minimum, '#root' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:bar]) { |r| r.add(:min, r.foo.min) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    MIN((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`foo` != null) RETURN `aggregate`.`summarization`.`foo`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/sum/root_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Sum, '#sum' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:foo]) { |r| r.add(:count, r.bar.sum) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    SUM((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`bar` != null) RETURN `aggregate`.`summarization`.`bar`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/aggregate/sum_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Aggregate::Sum, '#sum' do
+
+  let(:object)  { described_class.new(relation, context) }
+  let(:context) { AQL.name_node('collect') }
+
+  subject { object.root }
+
+  let(:relation) { base.summarize([:foo]) { |r| r.add(:count, r.bar.sum) }.summarizers.values.first }
+
+  expect_aql <<-AQL
+    SUM((FOR `aggregate` IN `collect` FILTER (`aggregate`.`summarization`.`bar` != null) RETURN `aggregate`.`summarization`.`bar`))
+  AQL
+end

data/spec/unit/axiom/adapter/arango/visitor/attribute/root_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Attribute, '#root' do
+  let(:relation) { base.header[:foo] }
+  let(:context)  { mock('Visitor Context', :local_name => AQL::Node::Name.new('local_name')) }
+
+  subject { object.root }
+
+  it_should_behave_like 'an idempotent method'
+
+  expect_aql('`local_name`.`foo`')
+end

data/spec/unit/axiom/adapter/arango/visitor/binary/root_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor::Binary, '#root' do
+
+  let(:relation) { base.restrict { |r| r.foo.eq('bar') }.predicate }
+  let(:context)  { mock('Visitor Context', :local_name => AQL::Node::Name.new('local_name')) }
+
+  subject { object.root }
+
+  expect_aql <<-AQL
+    (`local_name`.`foo` == "bar")
+  AQL
+
+end
+

data/spec/unit/axiom/adapter/arango/visitor/class_methods/build_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Visitor, '.build' do
+  let(:object) { described_class }
+
+  let(:relation) { mock('Axiom Node')               }
+  let(:aql_node) { mock('AQL Node')                   }
+  let(:context)  { mock('Context')                    }
+  let(:build)    { mock('Visitor', :root => aql_node) }
+
+  class Dummy
+  end
+
+  let(:dummy) { Dummy.new }
+
+  let!(:test_visitor) do
+    aql_node = self.aql_node
+    Class.new(described_class) do
+      handle(Dummy)
+      define_method :root do
+        aql_node
+      end
+    end
+  end
+
+  context 'with explicit context' do
+    subject { object.build(dummy, context) }
+
+    it { should eql(test_visitor.new(dummy, context)) }
+  end
+
+  context 'with implicit context' do
+    subject { object.build(dummy) }
+
+    it { should eql(test_visitor.new(dummy, nil)) }
+  end
+end