guacamole 0.0.1

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,119 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/configuration'
+
+describe 'Guacamole.configure' do
+  subject { Guacamole }
+
+  it 'should yield the Configuration class' do
+    subject.configure do |config|
+      expect(config).to eq Guacamole::Configuration
+    end
+  end
+end
+
+describe 'Guacamole.configuration' do
+  subject { Guacamole }
+
+  it 'should return the Configuration class' do
+    expect(Guacamole.configuration).to eq Guacamole::Configuration
+  end
+end
+
+describe Guacamole::Configuration do
+  subject { Guacamole::Configuration }
+
+  describe 'database' do
+    it 'should set the logger' do
+      database         = double('Database')
+      subject.database = database
+
+      expect(subject.database).to eq database
+    end
+  end
+
+  describe 'default_mapper' do
+    it 'should set the default mapper' do
+      default_mapper         = double('Mapper')
+      subject.default_mapper = default_mapper
+
+      expect(subject.default_mapper).to eq default_mapper
+    end
+
+    it 'should return Guacamole::DocumentModelMapper as default' do
+      subject.default_mapper = nil
+
+      expect(subject.default_mapper).to eq Guacamole::DocumentModelMapper
+    end
+  end
+
+  describe 'logger' do
+    before do
+      subject.logger = nil
+    end
+
+    it 'should set the logger' do
+      logger = double('Logger')
+      allow(logger).to receive(:level=)
+      subject.logger = logger
+
+      expect(subject.logger).to eq logger
+    end
+
+    it 'should default to Logger.new(STDOUT)' do
+      expect(subject.logger).to be_a Logger
+    end
+
+    it 'should set the log level to :info for the default logger' do
+      expect(subject.logger.level).to eq Logger::INFO
+    end
+  end
+
+  describe 'load' do
+    let(:config) { double('Config') }
+    let(:current_environment) { 'development' }
+
+    before do
+      allow(subject).to receive(:current_environment).and_return(current_environment)
+      allow(subject).to receive(:database=)
+      allow(subject).to receive(:create_database_connection_from)
+      allow(config).to  receive(:[]).with('development')
+      allow(YAML).to    receive(:load_file).with('config_file.yml').and_return(config)
+    end
+
+    it 'should parse a YAML configuration' do
+      expect(YAML).to receive(:load_file).with('config_file.yml').and_return(config)
+
+      subject.load 'config_file.yml'
+    end
+
+    it 'should load the part for the current environment from the config file' do
+      expect(config).to receive(:[]).with(current_environment)
+
+      subject.load 'config_file.yml'
+    end
+
+    it 'should create an Ashikawa::Core::Database instance based on configuration' do
+      arango_config = double('ArangoConfig')
+      expect(arango_config).to receive(:url=).with('http://localhost:8529/_db/test_db')
+      expect(arango_config).to receive(:username=).with('')
+      expect(arango_config).to receive(:password=).with('')
+      expect(arango_config).to receive(:logger=).with(subject.logger)
+
+      allow(Ashikawa::Core::Database).to receive(:new).and_yield(arango_config)
+
+      allow(config).to  receive(:[]).with('development').and_return(
+        'protocol' => 'http',
+        'host'     => 'localhost',
+        'port'     => 8529,
+        'username' => '',
+        'password' => '',
+        'database' => 'test_db'
+      )
+      allow(subject).to receive(:create_database_connection_from).and_call_original
+
+      subject.load 'config_file.yml'
+    end
+  end
+end

data/spec/unit/document_model_mapper_spec.rb

@@ -0,0 +1,120 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/document_model_mapper'
+
+class FancyModel
+end
+
+describe Guacamole::DocumentModelMapper do
+  subject { Guacamole::DocumentModelMapper }
+
+  it 'should be initialized with a model class' do
+    mapper = subject.new FancyModel
+    expect(mapper.model_class).to eq FancyModel
+  end
+
+  describe 'document_to_model' do
+    subject { Guacamole::DocumentModelMapper.new FancyModel }
+
+    let(:document)            { double('Ashikawa::Core::Document') }
+    let(:document_attributes) { double('Hash') }
+    let(:model_instance)      { double('ModelInstance').as_null_object }
+    let(:some_key)            { double('Key') }
+    let(:some_rev)            { double('Rev') }
+
+    before do
+      allow(subject.model_class).to receive(:new).and_return(model_instance)
+      allow(document).to receive(:hash).and_return(document_attributes)
+      allow(document).to receive(:key).and_return(some_key)
+      allow(document).to receive(:revision).and_return(some_rev)
+    end
+
+    it 'should create a new model instance from an Ashikawa::Core::Document' do
+      expect(subject.model_class).to receive(:new).with(document_attributes)
+
+      model = subject.document_to_model document
+      expect(model).to eq model_instance
+    end
+
+    it 'should set the rev and key on a new model instance' do
+      expect(model_instance).to receive(:key=).with(some_key)
+      expect(model_instance).to receive(:rev=).with(some_rev)
+
+      subject.document_to_model document
+    end
+
+    context 'with embedded ponies' do
+      # This is handled by Virtus, we just need to provide a hash
+      # and the coercing will be taken care of by Virtus
+    end
+  end
+
+  describe 'model_to_document' do
+    subject { Guacamole::DocumentModelMapper.new FancyModel }
+
+    let(:model)            { double('Model') }
+    let(:model_attributes) { double('Hash').as_null_object }
+
+    before do
+      allow(model).to receive(:attributes).and_return(model_attributes)
+      allow(model_attributes).to receive(:dup).and_return(model_attributes)
+    end
+
+    it 'should transform a model into a simple hash' do
+      expect(subject.model_to_document(model)).to eq model_attributes
+    end
+
+    it 'should return a copy of the model attributes hash' do
+      expect(model_attributes).to receive(:dup).and_return(model_attributes)
+
+      subject.model_to_document(model)
+    end
+
+    it 'should remove the key and rev attributes from the document' do
+      expect(model_attributes).to receive(:except).with(:key, :rev)
+
+      subject.model_to_document(model)
+    end
+
+    context 'with embedded ponies' do
+      let(:somepony) { double('Pony') }
+      let(:pony_array) { [somepony] }
+      let(:ponylicious_attributes) { double('Hash').as_null_object }
+
+      before do
+        subject.embeds :ponies
+
+        allow(model).to receive(:ponies)
+          .and_return pony_array
+
+        allow(somepony).to receive(:attributes)
+          .and_return ponylicious_attributes
+      end
+
+      it 'should convert all embedded ponies to pony hashes' do
+        expect(somepony).to receive(:attributes)
+          .and_return ponylicious_attributes
+
+        subject.model_to_document(model)
+      end
+
+      it 'should exclude key and rev on embedded ponies' do
+        expect(ponylicious_attributes).to receive(:except)
+          .with(:key, :rev)
+
+        subject.model_to_document(model)
+      end
+    end
+  end
+
+  describe 'embed' do
+    subject { Guacamole::DocumentModelMapper.new FancyModel }
+
+    it 'should remember which models to embed' do
+      subject.embeds :ponies
+
+      expect(subject.models_to_embed).to include :ponies
+    end
+  end
+end

data/spec/unit/example_spec.rb

@@ -0,0 +1,8 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe 'experiment' do
+  it 'should work' do
+    expect(5).to be 5
+  end
+end

data/spec/unit/model_spec.rb

@@ -0,0 +1,116 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/model'
+
+class TestModel
+  include Guacamole::Model
+end
+
+class OtherModel
+  include Guacamole::Model
+end
+
+describe Guacamole::Model do
+  subject { TestModel }
+  let(:current_time) { Time.now }
+
+  describe 'module inclusion' do
+    it 'should include Virtus.model' do
+      expect(subject.ancestors.any? do |ancestor|
+        ancestor.to_s.include? 'Virtus'
+      end).to be_true
+    end
+
+    it 'should include ActiveModel::Validation' do
+      expect(subject.ancestors).to include ActiveModel::Validations
+    end
+
+    it 'should include ActiveModel::Naming' do
+      expect(subject.ancestors).to include ActiveModel::Naming
+    end
+
+    it 'should include ActiveModel::Conversion' do
+      expect(subject.ancestors).to include ActiveModel::Conversion
+    end
+  end
+
+  describe 'default attributes' do
+    subject { TestModel.new }
+
+    it 'should add the key attribute' do
+      subject.key = '12345'
+      expect(subject.key).to eq '12345'
+    end
+
+    it 'should add the rev attribute' do
+      subject.rev = '98765'
+      expect(subject.rev).to eq '98765'
+    end
+
+    it 'should add the created_at attribute' do
+      subject.created_at = current_time
+      expect(subject.created_at).to be current_time
+    end
+
+    it 'should add the updated_at attribute' do
+      subject.updated_at = current_time
+      expect(subject.updated_at).to be current_time
+    end
+  end
+
+  describe 'persisted?' do
+    subject { TestModel.new }
+
+    it 'should be persisted if it has a key' do
+      subject.key = 'my_key'
+      expect(subject.persisted?).to be_true
+    end
+
+    it "should not be persisted if it doesn't have a key" do
+      subject.key = nil
+      expect(subject.persisted?).to be_false
+    end
+  end
+
+  describe 'id' do
+    subject { TestModel.new }
+
+    it 'should alias key to id for ActiveModel::Conversion compliance' do
+      subject.key = 'my_key'
+      expect(subject.id).to eq 'my_key'
+    end
+  end
+
+  describe '==' do
+    let(:key) { double('Key') }
+    let(:rev) { double('Rev') }
+    let(:updated_at) { Time.now }
+    let(:content) { double('String') }
+    let(:unixy_time) { 1_445_444_940 } # If you read this line and understand it, you get a beer
+    let(:timestamp_without_nsecs) { Time.at(unixy_time, 0) }
+    let(:timestamp_with_nsecs) { Time.at(unixy_time, 42) }
+
+    subject { TestModel.new(key: key, rev: rev, updated_at: updated_at, content: content) }
+    let(:comparison_object) { TestModel.new(subject.attributes) }
+
+    it 'should not be equal if it is a different class' do
+      expect(subject).to_not eq double
+    end
+
+    it 'should be equal if all attributes are equal' do
+      expect(subject).to eq comparison_object
+    end
+
+    it 'should be equal if the time is equal in string representation' do
+      subject.updated_at = timestamp_with_nsecs
+      comparison_object.updated_at = timestamp_without_nsecs
+
+      expect(subject).to eq comparison_object
+    end
+
+    it 'should alias `eql?` to `==`' do
+      expect(subject).to eql comparison_object
+    end
+  end
+end

data/spec/unit/query_spec.rb

@@ -0,0 +1,140 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/query'
+
+describe Guacamole::Query do
+  let(:connection) { double('Connection') }
+  let(:mapper) { double('Mapper') }
+
+  subject { Guacamole::Query.new(connection, mapper) }
+
+  its(:connection) { should be connection }
+  its(:mapper) { should be mapper }
+
+  it 'should be enumerable' do
+    expect(Guacamole::Query.ancestors).to include Enumerable
+  end
+
+  describe 'each' do
+    let(:result) { double }
+    let(:document) { double }
+    let(:model) { double }
+    let(:limit) { double }
+    let(:skip) { double }
+
+    before do
+      allow(result).to receive(:each)
+        .and_yield(document)
+
+      allow(mapper).to receive(:document_to_model)
+        .and_return(model)
+    end
+
+    context 'no example was provided' do
+      before do
+        allow(connection).to receive(:all)
+          .and_return(result)
+      end
+
+      it 'should get all documents' do
+        expect(connection).to receive(:all)
+          .with({})
+
+        subject.each { }
+      end
+
+      it 'should iterate over the resulting documents' do
+        expect(result).to receive(:each)
+
+        subject.each { }
+      end
+
+      it 'should yield the models to the caller' do
+        expect { |b| subject.each(&b) }.to yield_with_args(model)
+      end
+
+      it 'should return an enumerator when called without a block' do
+        expect(subject.each).to be_an Enumerator
+      end
+
+      it 'should accept a limit' do
+        expect(connection).to receive(:all)
+          .with(hash_including limit: limit)
+
+        subject.limit(limit).each { }
+      end
+
+       it 'should accept a skip' do
+         expect(connection).to receive(:all)
+           .with(hash_including skip: skip)
+
+         subject.skip(skip).each { }
+       end
+    end
+
+    context 'an example was provided' do
+      let(:example) { double }
+      before do
+        subject.example = example
+
+        allow(connection).to receive(:by_example)
+          .and_return(result)
+      end
+
+      it 'should query by the given example' do
+        expect(connection).to receive(:by_example)
+          .with(example, {})
+
+        subject.each { }
+      end
+
+      it 'should iterate over the resulting documents' do
+        expect(result).to receive(:each)
+
+        subject.each { }
+      end
+
+      it 'should yield the models to the caller' do
+        expect { |b| subject.each(&b) }.to yield_with_args(model)
+      end
+
+      it 'should return an enumerator when called without a block' do
+        expect(subject.each).to be_an Enumerator
+      end
+
+      it 'should accept a limit' do
+        expect(connection).to receive(:by_example)
+          .with(example, hash_including(limit: limit))
+
+        subject.limit(limit).each { }
+      end
+
+       it 'should accept a skip' do
+         expect(connection).to receive(:by_example)
+           .with(example, hash_including(skip: skip))
+
+         subject.skip(skip).each { }
+       end
+    end
+  end
+
+  describe 'first' do
+    context 'no example was provided' do
+      it 'should return the first result of the all query' do
+        first_result = double
+        first_result_as_model = double
+        results = [first_result]
+
+        allow(mapper).to receive(:document_to_model)
+          .with(first_result)
+          .and_return(first_result_as_model)
+
+        allow(connection).to receive(:all)
+          .and_return(results)
+
+        expect(subject.first).to be first_result_as_model
+      end
+    end
+  end
+end