axiom-arango-adapter 0.0.1

data/spec/integration/arango/read_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'logger'
+
+describe Axiom::Adapter::Arango, 'read' do
+  let(:logger) do
+    Logger.new($stderr, :debug)
+  end
+
+  let(:projects) do
+    header = Axiom::Relation::Header.coerce(
+      [
+        [ :id, Integer ],
+        [ :name, String ]
+      ]
+    )
+
+    Axiom::Relation.new(header, 
+      [
+        [ 1, 'dm-mapper' ],
+        [ 2, 'axiom'   ],
+        [ 3, 'dm-session'],
+      ]
+    )
+  end
+
+  let(:people) do
+    header = Axiom::Relation::Header.coerce(
+      [
+        [ :id, Integer ],
+        [ :name, String ]
+      ]
+    )
+
+    Axiom::Relation.new(header, 
+      [
+        [ 1, 'Dan Kubb'          ],
+        [ 2, 'Piotr Solnica'     ],
+        [ 3, 'Martin Gamsjaeger' ],
+        [ 4, 'Markus Schirp'     ]
+      ]
+    )
+  end
+
+  let(:tasks) do
+    header = Axiom::Relation::Header.coerce(
+      [
+        [ :id, Integer ],
+        [ :name, String ],
+        [ :project_id, Integer ]
+      ]
+    )
+
+    Axiom::Relation::new(header, 
+      [
+        [ 1, 'Add full mutation coverage',    1],
+        [ 2, 'Finish dm-session integration', 1],
+        [ 3, 'Rename to axiom',               2],
+        [ 4, 'Add UoW Interface',             3]
+      ]
+    )
+  end
+
+  let(:relations) do
+    {
+      :tasks    => tasks,
+      :people   => people,
+      :projects => projects
+    }
+  end
+
+  let(:database) do
+    Ashikawa::Core::Database.new do |config|
+      config.url = 'http://localhost:8529'
+    end
+  end
+
+  let(:adapter) do
+    Axiom::Adapter::Arango::Adapter.new(database, logger)
+  end
+
+  before :all do
+    relations.each do |name, relation|
+      database[name].delete
+      collection = database[name]
+      relation.each do |tuple|
+        document = relation.header.each_with_object({}) do |attribute, document|
+          document[attribute.name.to_s]=tuple[attribute]
+        end
+        collection.create_document(document)
+      end
+    end
+  end
+
+  def assert_eql_tuples_order(example, expected)
+    expected.to_a.map(&:to_ary).should eql(example.to_a.map(&:to_ary))
+  end
+
+  def assert_eql_tuples(expected, example)
+    expected_tuples = expected.to_a.map(&:to_ary).to_set
+    example_tuples  = example.to_a.map(&:to_ary).to_set
+    example_tuples.should eql(expected_tuples)
+  end
+
+  def gateway(name)
+    adapter.gateway(Axiom::Relation::Base.new(name, relations.fetch(name).header))
+  end
+
+  specify 'projection' do
+    assert_eql_tuples(gateway(:tasks).project([:id, :name]), tasks.project([:id, :name]))
+  end
+
+  specify 'restriction' do
+    assert_eql_tuples(gateway(:tasks).restrict { |r| r.project_id.eq(1) }, tasks.restrict { |r| r.project_id.eq(1) })
+  end
+
+  specify 'join' do
+    expected = projects.rename(:id => :project_id).join(tasks)
+
+    assert_eql_tuples(
+      projects.rename(:id => :project_id, :name => :project_name).join(tasks),
+      gateway(:projects).rename(:id => :project_id, :name => :project_name).join(tasks)
+    )
+  end
+
+  specify 'nested joins' do
+    assert_eql_tuples(
+      projects.join(projects).join(projects),
+      gateway(:projects).join(gateway(:projects)).join(gateway(:projects))
+    )
+  end
+
+  specify 'sort' do
+    assert_eql_tuples_order(
+      projects.sort_by { |r| [r.id.asc, r.name.asc] },
+      gateway(:projects).sort_by { |r| [r.id.asc, r.name.asc] }
+    )
+  end
+
+  specify 'limit' do
+    assert_eql_tuples_order(
+      projects.sort_by { |r| [r.id.asc, r.name.asc] }.take(1),
+      gateway(:projects).sort_by { |r| [r.id.asc, r.name.asc] }.take(1)
+    )
+  end
+
+  specify 'offset' do
+    assert_eql_tuples_order(
+      projects.sort_by { |r| [r.id.asc, r.name.asc] }.drop(1),
+      gateway(:projects).sort_by { |r| [r.id.asc, r.name.asc] }.drop(1)
+    )
+  end
+
+  specify 'summarize' do
+    assert_eql_tuples(
+      tasks.summarize([:project_id]) { |r| r.add(:count, r.name.count) },
+      gateway(:tasks).summarize([:project_id]) { |r| [r.add(:count, r.name.count)] }
+    )
+  end
+
+  specify 'extend' do
+    assert_eql_tuples(
+      tasks.extend { |r| r.add(:extend, r.project_id % 2) },
+      gateway(:tasks).extend { |r| r.add(:extend, r.project_id % 2) }
+    )
+  end
+end

data/spec/setup/arangodb.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cd $DIR
+
+VERSION=1.2.0
+NAME=ArangoDB-$VERSION
+
+if [ ! -d "$DIR/$NAME" ]; then
+  # download ArangoDB
+  echo "wget http://www.arangodb.org/travisCI/$NAME.tar.gz"
+  wget http://www.arangodb.org/travisCI/$NAME.tar.gz
+  echo "tar zxf $NAME.tar.gz"
+  tar zvxf $NAME.tar.gz
+fi
+
+ARCH=$(arch)
+PID=$(echo $PPID)
+TMP_DIR="/tmp/arangodb.$PID"
+PID_FILE="/tmp/arangodb.$PID.pid"
+ARANGODB_DIR="$DIR/$NAME"
+
+ARANGOD="${ARANGODB_DIR}/bin/arangod"
+if [ "$ARCH" == "x86_64" ]; then
+  ARANGOD="${ARANGOD}_x86_64"
+fi
+
+# create database directory
+mkdir ${TMP_DIR}
+
+echo "Starting arangodb '${ARANGOD}'"
+
+${ARANGOD} \
+    --database.directory ${TMP_DIR}  \
+    --configuration none  \
+    --server.endpoint tcp://127.0.0.1:8529 \
+    --javascript.startup-directory ${ARANGODB_DIR}/js \
+    --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules \
+    --javascript.action-directory ${ARANGODB_DIR}/js/actions/system  \
+    --database.maximal-journal-size 1048576  \
+    --server.disable-admin-interface true \
+    --server.disable-authentication true &
+
+sleep 5
+
+echo "Check for arangod process"
+process=$(ps auxww | grep "bin/arangod" | grep -v grep)
+
+if [ "x$process" == "x" ]; then
+  echo "no 'arangod' process found"
+  echo "ARCH = $ARCH"
+  exit 1
+fi
+
+echo "Waiting until ArangoDB is ready on port 8529"
+while [[ -z `curl -s 'http://127.0.0.1:8529/_api/version' ` ]] ; do
+  echo -n "."
+  sleep 2s
+done
+
+echo "ArangoDB is up"

data/spec/setup/run.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Run arango under my archlinux machine
+
+PID=$(echo $PPID)
+TMP_DIR="/tmp/arangodb.$PID"
+PID_FILE="/tmp/arangodb.$PID.pid"
+ARANGODB_DIR="/usr/share/arangodb"
+
+# create database directory
+mkdir ${TMP_DIR}
+
+arangod \
+    --database.directory ${TMP_DIR}  \
+    --configuration none  \
+    --server.endpoint tcp://127.0.0.1:8529 \
+    --javascript.startup-directory ${ARANGODB_DIR}/js \
+    --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules \
+    --javascript.action-directory ${ARANGODB_DIR}/js/actions/system  \
+    --log debug \
+    --database.maximal-journal-size 1048576  \
+    --server.disable-admin-interface true \
+    --server.disable-authentication true \
+    --javascript.gc-interval 1

data/spec/shared/aql_behavior.rb

@@ -0,0 +1,7 @@
+shared_examples_for 'Node#aql' do
+  subject { object.aql }
+
+  it { should eql(expected_aql) }
+  its(:frozen?) { should be(true) }
+  it_should_behave_like 'an idempotent method'
+end

data/spec/shared/binary_relation_method_behaviour.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+shared_examples_for 'a binary relation method' do
+  describe 'when other has the same adapter' do
+    let(:other_relation) { mock('Other Relation')                       }
+    let(:other)          { described_class.new(adapter, other_relation) }
+    let(:gateway)        { mock('Other Gateway')                        }
+
+    before do
+      relation.stub(operation).and_return(gateway)
+    end
+
+    it { should be(gateway) }
+
+    it 'passes the other relation to the binary operation' do
+      relation.should_receive(operation) do |argument|
+        argument.should be(other_relation)
+      end
+      subject
+    end
+  end
+
+  describe 'when other has a different adapter' do
+    let(:other_adapter) { mock('Other Adapter')                    }
+    let(:other)         { described_class.new(other_adapter, stub) }
+
+    before do
+      factory.stub!(:new).and_return(binary_relation)
+    end
+
+    it { should equal(binary_relation) }
+
+    it 'initializes the binary operation with the gateways' do
+      factory.should_receive(:new).with(object, other)
+      subject
+    end
+  end
+
+  describe 'when other has no adapter' do
+    let(:other) { mock('Other Relation') }
+
+    before do
+      factory.stub!(:new).and_return(binary_relation)
+    end
+
+    it { should equal(binary_relation) }
+
+    it 'initializes the binary operation with the gateway and other relation' do
+      factory.should_receive(:new).with(object, other)
+      subject
+    end
+  end
+end

data/spec/shared/unary_relation_method_behaviour.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+shared_examples_for 'a unary relation method' do
+  let(:gateway) { mock('New Gateway') }
+
+  before do
+    described_class.stub!(:new).and_return(gateway)
+  end
+
+  it { should equal(gateway) }
+
+  it 'tests the response is a relation' do
+    response.should_receive(:kind_of?).with(Axiom::Relation)
+    subject
+  end
+
+  it 'initializes the new gateway with the adapter and response' do
+    described_class.should_receive(:new).with(adapter, response)
+    subject
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'axiom-arango-adapter'
+require 'timeout'
+require 'devtools'
+Devtools.init_spec_helper
+
+module InstanceMethodHelper
+  def instance_method_defined?(name)
+    instance_methods.map(&:to_sym).include?(name)
+  end
+end
+
+module AQLHelper
+  def compress_aql(string)
+    string.gsub(/^[ ]*/, '').split("\n").join(' ')
+  end
+
+  def expect_aql(string)
+    let(:header)  { Axiom::Relation::Header.coerce([[:foo, String], [:bar, Integer]]) }
+    let(:base)    { Axiom::Relation::Base.new(:name, header) }
+    let(:object)  { described_class.new(relation, context) }
+
+    # Disjunct header for projection
+    let(:header_b) { Axiom::Relation::Header.coerce([[:baz, String]]) }
+    let(:base_b)   { Axiom::Relation::Base.new(:name_b, header_b) }
+
+    # Overlapping header for join
+    let(:header_c) { Axiom::Relation::Header.coerce([[:baz, String], [:bar, Integer]]) }
+    let(:base_c)   { Axiom::Relation::Base.new(:name_c, header_c) }
+
+    unless instance_method_defined?(:context)
+      let(:context) { nil }
+    end
+
+    expected_aql = compress_aql(string)
+    it_should_behave_like 'an idempotent method'
+    its(:aql) { should eql(expected_aql) }
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Axiom)
+  config.extend(AQLHelper)
+  config.extend(InstanceMethodHelper)
+  config.around do |example|
+    Timeout.timeout(1) do
+      example.run
+    end
+  end
+end

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,6 @@
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/unit/axiom/adapter/arango/adapter/class_methods/new_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Adapter, '.new' do
+  subject { object.new(*arguments) }
+
+  let(:object) { described_class }
+
+  let(:database) { mock('Database') }
+  let(:logger)   { mock('Logger')   }
+
+  context 'with single argument' do
+    let(:arguments) { [database] }
+
+    its(:database) { should be(database) }
+    its(:logger)   { should be(NullLogger.instance) }
+  end
+
+  context 'with two arguments' do
+    let(:arguments) { [database, logger] }
+
+    its(:database) { should be(database) }
+    its(:logger)   { should be(logger)   }
+  end
+end

data/spec/unit/axiom/adapter/arango/adapter/gateway_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Adapter, '#gateway' do
+  subject { object.gateway(relation) }
+
+  let(:object) { described_class.new(database) }
+  let(:relation) { mock('Relation') }
+  let(:database) { mock('Database') }
+
+  it { should eql(Axiom::Adapter::Arango::Gateway.new(object, relation)) }
+end

data/spec/unit/axiom/adapter/arango/adapter/reader_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Axiom::Adapter::Arango::Adapter, '#reader' do
+
+  let(:object)   { described_class.new(database) }
+  let(:database) { mock('Database')              }
+  let(:relation) { mock('Relation')              }
+
+  subject { object.reader(relation)  }
+
+  it { should eql(Axiom::Adapter::Arango::Reader.new(object, relation)) }
+end