guacamole 0.0.1

data/lib/guacamole/railtie.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'guacamole'
+require 'guacamole/configuration'
+
+require 'rails'
+
+module Guacamole
+  # Class to hook into Rails configuration and initializer
+  # @api private
+  class Railtie < Rails::Railtie
+
+    rake_tasks do
+      load 'guacamole/railtie/database.rake'
+    end
+
+    config.guacamole = ::Guacamole::Configuration
+
+    initializer 'guacamole.load-config' do
+      config_file = Rails.root.join('config', 'guacamole.yml')
+      if config_file.file?
+        Guacamole::Configuration.load config_file
+      end
+    end
+
+  end
+end

data/lib/guacamole/railtie/database.rake

@@ -0,0 +1,5 @@
+namespace :db do
+  # TODO: Add all the Rails-tasks.
+  #       If we cannot do something meaningful provide a noop.
+  #       Foremost the creation of databases should be provided.
+end

data/lib/guacamole/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding : utf-8 -*-
+module Guacamole
+  # Current version of the gem
+  VERSION = '0.0.1'
+end

data/spec/acceptance/basic_spec.rb

@@ -0,0 +1,112 @@
+# -*- encoding : utf-8 -*-
+require 'guacamole'
+require 'acceptance/spec_helper'
+
+class Comment
+  include Guacamole::Model
+
+  attribute :text, String
+end
+
+class Article
+  include Guacamole::Model
+
+  attribute :title, String
+  attribute :comments, Array[Comment]
+
+  validates :title, presence: true
+end
+
+class ArticlesCollection
+  include Guacamole::Collection
+
+  map do
+    embeds :comments
+  end
+end
+
+describe 'ModelBasics' do
+
+  describe Article do
+    it 'should allow setting its title' do
+      subject.title = 'This is my fancy article'
+
+      expect(subject.title).to eq('This is my fancy article')
+    end
+
+    it 'should have key and rev attributes' do
+      expect(subject.key).to be_nil
+      expect(subject.rev).to be_nil
+    end
+
+    it 'should have timestamp attributes which are empty' do
+      expect(subject.created_at).to be_nil
+      expect(subject.updated_at).to be_nil
+    end
+
+    it 'should validate its attributes' do
+      expect(subject.valid?).to be_false
+      subject.title = 'The Legend of Zelda'
+      expect(subject.valid?).to be_true
+    end
+
+    it 'should know its model name' do
+      # This test passes when you only require ActiveModel::Validations
+      expect(subject.class.model_name).to eq 'Article'
+    end
+
+    it 'should convert itself to params' do
+      subject.key = 'random_number'
+      expect(subject.to_param).to eq 'random_number'
+    end
+  end
+
+end
+
+describe 'CollectionBasics' do
+
+  describe ArticlesCollection do
+    subject { ArticlesCollection }
+
+    let(:some_article) { Fabricate(:article) }
+
+    it 'should provide a method to find documents by key and return the appropriate model' do
+      found_model = subject.by_key some_article.key
+      expect(found_model).to eq some_article
+    end
+
+    it 'should save models to the database' do
+      new_article = Fabricate.build(:article)
+      subject.save new_article
+
+      expect(subject.by_key(new_article.key)).to eq new_article
+    end
+
+    it 'should update models in the database' do
+      some_article.title = 'Has been updated'
+      subject.replace some_article
+
+      updated_article = subject.by_key(some_article.key)
+
+      expect(updated_article.title).to eq 'Has been updated'
+    end
+
+    it 'should receive all documents by title' do
+      subject.save Fabricate.build(:article, title: 'Disturbed')
+      subject.save Fabricate.build(:article, title: 'Not so Disturbed')
+
+      result = subject.by_example(title: 'Disturbed').first
+
+      expect(result.title).to eq 'Disturbed'
+    end
+
+    it 'should allow to nest models' do
+      article_with_comments = Fabricate(:article_with_two_comments)
+      found_article = subject.by_key(article_with_comments.key)
+
+      expect(found_article.comments.first).to be_a Comment
+      expect(found_article.comments).to eq article_with_comments.comments
+    end
+  end
+
+end

data/spec/acceptance/config/guacamole.yml

@@ -0,0 +1,11 @@
+# FIXME: This is copied from Ashikawa::Core for now but is not recommended. This
+# setup uses the default database instead of a custom DB. Due to this we're deleting
+# all collections in the default database each time we run the specs.
+# => This is not good!
+test:
+  protocol: 'http'
+  host: 'localhost'
+  port: 8529
+  password: ''
+  username: ''
+  database: '_system'

data/spec/acceptance/spec_helper.rb

@@ -0,0 +1,61 @@
+# -*- encoding : utf-8 -*-
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'fabrication'
+require 'logging'
+require 'ashikawa-core'
+
+begin
+  require 'debugger'
+rescue LoadError
+  puts "Debugger is not available. Maybe you're Travis."
+end
+
+class Fabrication::Generator::Guacamole < Fabrication::Generator::Base
+
+  def self.supports?(klass)
+    defined?(Guacamole) && klass.ancestors.include?(Guacamole::Model)
+  end
+
+  def persist
+    collection = [_instance.class.name.pluralize, 'Collection'].join.constantize
+    collection.save _instance
+  end
+
+  def validate_instance
+    _instance.valid?
+  end
+
+end
+
+Fabrication::Schematic::Definition::GENERATORS.unshift Fabrication::Generator::Guacamole
+
+ENV['GUACAMOLE_ENV'] = 'test'
+
+Guacamole.configure do |config|
+  logger = Logging.logger['guacamole_logger']
+  logger.add_appenders(
+      Logging.appenders.file('log/acceptance.log')
+  )
+  logger.level = :info
+
+  config.logger = logger
+
+  config.load File.join(File.dirname(__FILE__), 'config', 'guacamole.yml')
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before(:each) do
+    Guacamole.configuration.database.collections.each { |collection| collection.truncate! }
+  end
+end

data/spec/fabricators/article_fabricator.rb

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+
+Fabricator(:article) do
+  title 'And then there was silence'
+end
+
+Fabricator(:article_with_two_comments, from: Article) do
+  title 'I have two comments'
+  comments(count: 2) { |attrs, i| Fabricate.build(:comment, text: "I'm comment number #{i}") }
+end

data/spec/fabricators/comment_fabricator.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+Fabricator(:comment) do
+  text 'This article is super awesome'
+end

data/spec/setup/arangodb.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+cd $DIR
+
+# VERSION=1.4.devel
+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 \
+  --server.admin-directory ${ARANGODB_DIR}/html/admin \
+  --javascript.modules-path ${ARANGODB_DIR}/js/server/modules:${ARANGODB_DIR}/js/common/modules:${ARANGODB_DIR}/js/node \
+  --javascript.package-path ${ARANGODB_DIR}/js/npm:${ARANGODB_DIR}/js/common/test-data/modules \
+  --javascript.action-directory ${ARANGODB_DIR}/js/actions  \
+  --javascript.app-path ${ARANGODB_DIR}/js/apps  \
+  --database.maximal-journal-size 1048576  \
+  --server.disable-admin-interface ${ARANGODB_DISABLE_AUTHENTIFICATION} \
+  --server.disable-authentication true \
+  --javascript.gc-interval 1 &
+
+sleep 2
+
+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/spec_helper.rb

@@ -0,0 +1,19 @@
+# -*- encoding : utf-8 -*-
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+begin
+  require 'debugger'
+rescue LoadError
+  puts "Debugger is not available. Maybe you're Travis."
+end
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/unit/collection_spec.rb

@@ -0,0 +1,380 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/collection'
+
+class Test
+end
+
+class TestCollection
+  include Guacamole::Collection
+end
+
+describe Guacamole::Collection do
+  subject { TestCollection }
+
+  describe 'Configuration' do
+    it 'should set the connection to the ArangoDB collection' do
+      mock_collection_connection = double('ConnectionToCollection')
+      subject.connection         = mock_collection_connection
+
+      expect(subject.connection).to eq mock_collection_connection
+    end
+
+    it 'should set the Mapper instance to map documents to models and vice versa' do
+      mock_mapper    = double('Mapper')
+      subject.mapper = mock_mapper
+
+      expect(subject.mapper).to eq mock_mapper
+    end
+
+    it 'should set the connection to ArangoDB' do
+      mock_db          = double('Ashikawa::Core::Database')
+      subject.database = mock_db
+
+      expect(subject.database).to eq mock_db
+    end
+
+    it 'should know the name of the collection in ArangoDB' do
+      expect(subject.collection_name).to eq 'test'
+    end
+
+    it 'should know the class of the model to manage' do
+      expect(subject.model_class).to eq Test
+    end
+  end
+
+  describe 'database' do
+    before do
+      subject.database = nil
+    end
+
+    it 'should default to Guacamole.configuration.database' do
+      default_database = double('Database')
+      configuration    = double('Configuration', database: default_database)
+      allow(Guacamole).to receive(:configuration).and_return(configuration)
+
+      expect(subject.database).to eq default_database
+    end
+  end
+
+  describe 'connection' do
+    before do
+      subject.connection = nil
+    end
+
+    it 'should default to the collection "collection_name" in the database' do
+      database = double('Database')
+      allow(subject).to receive(:database).and_return(database)
+
+      expect(database).to receive(:[]).with(subject.collection_name)
+
+      subject.connection
+    end
+  end
+
+  describe 'mapper' do
+    before do
+      subject.mapper = nil
+    end
+
+    it 'should default to Guacamole.configuration.default_mapper' do
+      default_mapper  = double('Mapper')
+      mapper_instance = double('MapperInstance')
+      configuration   = double('Configuration', default_mapper: default_mapper)
+      allow(Guacamole).to receive(:configuration).and_return(configuration)
+      allow(default_mapper).to receive(:new).with(subject.model_class).and_return(mapper_instance)
+
+      expect(subject.mapper).to eq mapper_instance
+    end
+  end
+
+  let(:connection) { double('Connection') }
+  let(:mapper)     { double('Mapper') }
+
+  before do
+    subject.connection = connection
+    subject.mapper     = mapper
+  end
+
+  describe 'by_key' do
+    it 'should get mapped documents by key from the database' do
+      document           = { data: 'foo' }
+      model              = double('Model')
+
+      expect(connection).to receive(:fetch).with('some_key').and_return(document)
+      expect(mapper).to receive(:document_to_model).with(document).and_return(model)
+
+      expect(subject.by_key('some_key')).to eq model
+    end
+
+    it 'should raise a Ashikawa::Core::DocumentNotFoundException exception for nil' do
+      expect { subject.by_key(nil) }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
+    end
+  end
+
+  describe 'save' do
+
+    before do
+      allow(connection).to receive(:create_document).with(document).and_return(document)
+      allow(mapper).to receive(:model_to_document).with(model).and_return(document)
+    end
+
+    let(:key)       { double('Key') }
+    let(:rev)       { double('Rev') }
+    let(:document)  { double('Document', key: key, revision: rev).as_null_object }
+    let(:model)     { double('Model').as_null_object }
+
+    context 'a valid model' do
+      before do
+        allow(model).to receive(:valid?).and_return(true)
+      end
+
+      it 'should create a document' do
+        expect(connection).to receive(:create_document).with(document).and_return(document)
+        expect(mapper).to receive(:model_to_document).with(model).and_return(document)
+
+        subject.save model
+      end
+
+      it 'should return the model after calling save' do
+        expect(subject.save(model)).to eq model
+      end
+
+      it 'should set timestamps before creating the document' do
+        now = double('Time.now')
+
+        allow(Time).to receive(:now).once.and_return(now)
+
+        expect(model).to receive(:created_at=).with(now).ordered
+        expect(model).to receive(:updated_at=).with(now).ordered
+
+        allow(connection).to receive(:create_document).with(document).and_return(document).ordered
+
+        subject.save model
+      end
+
+      it 'should add key to model' do
+        expect(model).to receive(:key=).with(key)
+
+        subject.save model
+      end
+
+      it 'should add rev to model' do
+        expect(model).to receive(:rev=).with(rev)
+
+        subject.save model
+      end
+    end
+
+    context 'an invalid model' do
+
+      before do
+        expect(model).to receive(:valid?).and_return(false)
+      end
+
+      it 'should not be used to create the document' do
+        expect(connection).to receive(:create_document).never
+
+        subject.save model
+      end
+
+      it 'should not be changed' do
+        expect(model).to receive(:created_at=).never
+        expect(model).to receive(:updated_at=).never
+        expect(model).to receive(:key=).never
+        expect(model).to receive(:rev=).never
+
+        subject.save model
+      end
+
+      it 'should return false' do
+        expect(subject.save(model)).to be false
+      end
+    end
+  end
+
+  describe 'delete' do
+    let(:document) { double('Document') }
+    let(:key)      { double('Key') }
+    let(:model)    { double('Model', key: key) }
+
+    before do
+      allow(connection).to receive(:fetch).with(key).and_return(document)
+      allow(document).to receive(:delete)
+    end
+
+    context 'a key was provided' do
+      it 'should delete the according document' do
+        expect(document).to receive(:delete)
+
+        subject.delete key
+      end
+
+      it 'should return the according key' do
+        expect(subject.delete(key)).to eq key
+      end
+    end
+
+    context 'a model was provided' do
+      it 'should delete the according document' do
+        expect(document).to receive(:delete)
+
+        subject.delete model
+      end
+
+      it 'should return the according key' do
+        expect(subject.delete(model)).to eq key
+      end
+    end
+  end
+
+  describe 'replace' do
+    let(:key)      { double('Key') }
+    let(:rev)      { double('Rev') }
+    let(:model)    { double('Model', key: key).as_null_object }
+    let(:document) { double('Document').as_null_object }
+    let(:response) { double('Hash') }
+
+    before do
+      allow(mapper).to receive(:model_to_document).with(model).and_return(document)
+      allow(connection).to receive(:replace).and_return(response)
+      allow(response).to receive(:[]).with('_rev').and_return(rev)
+    end
+
+    context 'a valid model' do
+      before do
+        allow(model).to receive(:valid?).and_return(true)
+      end
+
+      it 'should set the updated_at timestamp before replacing the document' do
+        now = double('Time.now')
+
+        allow(Time).to receive(:now).once.and_return(now)
+        expect(model).to receive(:updated_at=).with(now)
+
+        subject.replace model
+      end
+
+      it 'should replace the document by key via the connection' do
+        expect(connection).to receive(:replace).with(key, document)
+
+        subject.replace model
+      end
+
+      it 'should update the revision after replacing the document' do
+        allow(connection).to receive(:replace).and_return(response).ordered
+        expect(model).to receive(:rev=).with(rev).ordered
+
+        subject.replace model
+      end
+
+      it 'should return the model' do
+        expect(subject.replace(model)).to eq model
+      end
+
+      it 'should not update created_at' do
+        expect(model).to receive(:created_at=).never
+
+        subject.replace model
+      end
+    end
+
+    context 'an invalid model' do
+      before do
+        allow(model).to receive(:valid?).and_return(false)
+      end
+
+      it 'should not be used to replace the document' do
+        expect(connection).to receive(:replace).never
+
+        subject.replace model
+      end
+
+      it 'should not be changed' do
+        expect(model).to receive(:rev=).never
+        expect(model).to receive(:updated_at=).never
+
+        subject.replace model
+      end
+
+      it 'should return false' do
+        expect(subject.replace(model)).to be false
+      end
+    end
+  end
+
+  describe 'by_example' do
+    let(:example) { double }
+    let(:query_connection) { double }
+    let(:query) { double }
+
+    before do
+      allow(connection).to receive(:query)
+        .and_return(query_connection)
+
+      allow(Guacamole::Query).to receive(:new)
+        .and_return(query)
+
+      allow(query).to receive(:example=)
+    end
+
+    it 'should create a new query with the query connection and mapper' do
+      expect(Guacamole::Query).to receive(:new)
+        .with(query_connection, mapper)
+
+      subject.by_example(example)
+    end
+
+    it 'should set the example for the query' do
+      expect(query).to receive(:example=)
+        .with(example)
+
+      subject.by_example(example)
+    end
+
+    it 'should return the query' do
+      expect(subject.by_example(example)).to be query
+    end
+  end
+
+  describe 'all' do
+    let(:query_connection) { double }
+    let(:query) { double }
+
+    before do
+      allow(connection).to receive(:query)
+        .and_return(query_connection)
+
+      allow(Guacamole::Query).to receive(:new)
+        .and_return(query)
+    end
+
+    it 'should create a new query with the query connection and mapper' do
+      expect(Guacamole::Query).to receive(:new)
+        .with(query_connection, mapper)
+
+      subject.all
+    end
+
+    it 'should return the query' do
+      expect(subject.all).to be query
+    end
+  end
+
+  describe 'map' do
+    let(:mapper) { double('Mapper') }
+
+    before do
+      subject.mapper = mapper
+    end
+
+    it 'should evaluate the block on the mapper instance' do
+      expect(mapper).to receive(:method_to_call_on_mapper)
+
+      subject.map do
+        method_to_call_on_mapper
+      end
+    end
+  end
+end