guacamole 0.2.0 → 0.3.0

data/spec/support/guacamole.yml.erb

@@ -0,0 +1,5 @@
+development:
+  protocol: '<%= ENV['ARANGODB_PROTOCOL'] %>'
+  host: 'localhost'
+  port: 8529
+  database: '<%= ENV['ARANGODB_DATABASE'] %>'

data/spec/unit/callbacks_spec.rb

@@ -0,0 +1,139 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/callbacks'
+
+class FakeModel
+end
+
+class FakeCallback
+  include Guacamole::Callbacks
+end
+
+describe Guacamole::Callbacks do
+  describe 'registering callbacks' do
+    let(:model) { FakeModel.new }
+    let(:callback_class) { double('CallbackClass') }
+    let(:callback_instance) { double('CallbackInstance') }
+
+    before do
+      subject.register_callback model.class, callback_class
+    end
+
+    it 'should register a callback class to be used with a model class' do
+      expect(subject.registry[model.class]).to eq callback_class
+    end
+
+    it 'should retrieve the callback class for a given model class' do
+      allow(callback_class).to receive(:new).with(model).and_return(callback_instance)
+
+      expect(subject.callbacks_for(model).callbacks).to eq callback_instance
+    end
+
+    it 'should wrap the callback class in a proxy' do
+      allow(callback_class).to receive(:new).with(model).and_return(callback_instance)
+
+      expect(subject.callbacks_for(model)).to be_instance_of Guacamole::Callbacks::CallbackProxy
+    end
+
+    context 'no callback defined for model class' do
+      it 'should return the DefaultCallback' do
+        any_model = double('ModelWithoutCallbacks')
+        expect(subject.callbacks_for(any_model).callbacks).to be_instance_of Guacamole::Callbacks::DefaultCallback
+      end
+    end
+  end
+
+  describe 'time stamp related callbacks' do
+    let(:model) { double('Model') }
+    let(:now)   { double('Time') }
+    subject { FakeCallback.new model }
+
+    before do
+      allow(Time).to receive(:now).twice.and_return(now)
+    end
+
+    it 'should set created_at / updated_at before_create' do
+      expect(model).to receive(:created_at=).with(now)
+      expect(model).to receive(:updated_at=).with(now)
+
+      subject.run_callbacks :create
+    end
+
+    it 'should set updated_at before_update' do
+      expect(model).to_not receive(:created_at=)
+      expect(model).to receive(:updated_at=).with(now)
+
+      subject.run_callbacks :update
+    end
+  end
+
+  describe 'building callbacks' do
+    subject { FakeCallback }
+
+    it 'should include ActiveModel::Callbacks' do
+      expect(subject.ancestors).to include ActiveModel::Callbacks
+    end
+  end
+
+  describe 'callback instances' do
+    let(:model) { double('Model').as_null_object }
+    subject { FakeCallback.new model }
+
+    it 'should provide access to the concrete model instance' do
+      expect(subject.object).to eq model
+    end
+
+    it 'should run :validate callbacks' do
+      expect { subject.run_callbacks :validate }.not_to raise_error
+    end
+
+    it 'should run :save callbacks' do
+      expect { subject.run_callbacks :save }.not_to raise_error
+    end
+
+    it 'should run :create callbacks' do
+      expect { subject.run_callbacks :create }.not_to raise_error
+    end
+
+    it 'should run :update callbacks' do
+      expect { subject.run_callbacks :update }.not_to raise_error
+    end
+
+    it 'should run :delete callbacks' do
+      expect { subject.run_callbacks :delete }.not_to raise_error
+    end
+  end
+
+  describe Guacamole::Callbacks::DefaultCallback do
+    subject { Guacamole::Callbacks::DefaultCallback }
+
+    it 'should include Guacamole::Callbacks' do
+      expect(subject.ancestors).to include Guacamole::Callbacks
+    end
+  end
+
+  describe Guacamole::Callbacks::CallbackProxy do
+    let(:model) { double('Model').as_null_object }
+    let(:something) { double('Something') }
+    let(:callbacks) { FakeCallback.new(model) }
+    subject { Guacamole::Callbacks::CallbackProxy.new callbacks }
+
+    before do
+      allow(something).to receive(:do_it).once
+    end
+
+    it 'should proxy a single kind of callback to the underlying callback class' do
+      expect(callbacks).to receive(:run_callbacks).with(:update).and_yield
+
+      subject.run_callbacks(:update) { something.do_it }
+    end
+
+    it 'should execute multiple kinds of callbacks on the underlying callback class' do
+      expect(callbacks).to receive(:run_callbacks).with(:save).ordered.and_yield
+      expect(callbacks).to receive(:run_callbacks).with(:create).ordered.and_yield
+
+      subject.run_callbacks(:save, :create) { something.do_it }
+    end
+  end
+end

data/spec/unit/collection_spec.rb

@@ -11,8 +11,19 @@ class TestCollection
 end
 
 describe Guacamole::Collection do
+  let(:callbacks) { double('Callback') }
+  let(:callbacks_module) { double('CallbacksModule') }
+
   subject { TestCollection }
 
+  before do
+    allow(callbacks_module).to receive(:callbacks_for).and_return(callbacks)
+    allow(callbacks).to receive(:run_callbacks).with(:save, :create).and_yield
+    allow(callbacks).to receive(:run_callbacks).with(:save, :update).and_yield
+    allow(callbacks).to receive(:run_callbacks).with(:delete).and_yield
+    stub_const('Guacamole::Callbacks', callbacks_module)
+  end
+
   describe 'Configuration' do
     it 'should set the connection to the ArangoDB collection' do
       mock_collection_connection = double('ConnectionToCollection')
@@ -131,32 +142,21 @@ describe Guacamole::Collection do
 
       before do
         allow(model).to receive(:valid?).and_return(true)
+        allow(connection).to receive(:create_document).with(document).and_return(document)
+        allow(model).to receive(:persisted?).and_return(false)
       end
 
-      context 'which is not persisted' do
+      it 'should run the save callbacks for the given model' do
+        expect(subject).to receive(:callbacks).with(model).and_return(callbacks)
 
-        before do
-          allow(connection).to receive(:create_document).with(document).and_return(document)
-          allow(model).to receive(:persisted?).and_return(false)
-        end
+        subject.save model
+      end
 
+      context 'which is not persisted' do
         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)
 
@@ -180,16 +180,7 @@ describe Guacamole::Collection do
 
         let(:model)    { double('Model', key: key).as_null_object }
 
-        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.save model
-        end
-
-        it 'should replace the document by key via the connection' do
+        it 'should update the document by key via the connection' do
           expect(connection).to receive(:replace).with(key, document)
 
           subject.save model
@@ -234,8 +225,6 @@ describe Guacamole::Collection do
         end
 
         it 'should not be changed' do
-          expect(model).not_to receive(:created_at=)
-          expect(model).not_to receive(:updated_at=)
           expect(model).not_to receive(:key=)
           expect(model).not_to receive(:rev=)
 
@@ -256,7 +245,7 @@ describe Guacamole::Collection do
 
         let(:model)    { double('Model', key: key).as_null_object }
 
-        it 'should not be used to replace the document' do
+        it 'should not be used to update the document' do
           expect(connection).not_to receive(:replace)
 
           subject.save model
@@ -306,27 +295,27 @@ describe Guacamole::Collection do
         expect(subject.create(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)
+      it 'should add key to model' do
+        expect(model).to receive(:key=).with(key)
 
-        expect(model).to receive(:created_at=).with(now).ordered
-        expect(model).to receive(:updated_at=).with(now).ordered
+        subject.create model
+      end
 
-        allow(connection).to receive(:create_document).with(document).and_return(document).ordered
+      it 'should add rev to model' do
+        expect(model).to receive(:rev=).with(rev)
 
         subject.create model
       end
 
-      it 'should add key to model' do
-        expect(model).to receive(:key=).with(key)
+      it 'should run the create callbacks for the given model' do
+        expect(callbacks).to receive(:run_callbacks).with(:save, :create).and_yield
 
         subject.create model
       end
 
-      it 'should add rev to model' do
-        expect(model).to receive(:rev=).with(rev)
+      it 'should run first the validation and then the create callbacks' do
+        expect(model).to receive(:valid?).ordered.and_return(true)
+        expect(callbacks).to receive(:run_callbacks).ordered.with(:save, :create).and_yield
 
         subject.create model
       end
@@ -427,8 +416,6 @@ describe Guacamole::Collection do
       end
 
       it 'should not be changed' do
-        expect(model).not_to receive(:created_at=)
-        expect(model).not_to receive(:updated_at=)
         expect(model).not_to receive(:key=)
         expect(model).not_to receive(:rev=)
 
@@ -448,10 +435,21 @@ describe Guacamole::Collection do
 
     before do
       allow(connection).to receive(:fetch).with(key).and_return(document)
+      allow(subject).to receive(:by_key)
       allow(document).to receive(:delete)
     end
 
     context 'a key was provided' do
+      before do
+        allow(mapper).to receive(:document_to_model).with(document).and_return(model)
+      end
+
+      it 'should load the document and instantiate the model' do
+        expect(mapper).to receive(:document_to_model).with(document).and_return(model)
+
+        subject.delete key
+      end
+
       it 'should delete the according document' do
         expect(document).to receive(:delete)
 
@@ -461,6 +459,13 @@ describe Guacamole::Collection do
       it 'should return the according key' do
         expect(subject.delete(key)).to eq key
       end
+
+      it 'should run the delete callbacks for the given model' do
+        expect(subject).to receive(:callbacks).with(model).and_return(callbacks)
+        expect(callbacks).to receive(:run_callbacks).with(:delete).and_yield
+
+        subject.delete model
+      end
     end
 
     context 'a model was provided' do
@@ -473,10 +478,17 @@ describe Guacamole::Collection do
       it 'should return the according key' do
         expect(subject.delete(model)).to eq key
       end
+
+      it 'should run the delete callbacks for the given model' do
+        expect(subject).to receive(:callbacks).with(model).and_return(callbacks)
+        expect(callbacks).to receive(:run_callbacks).with(:delete).and_yield
+
+        subject.delete model
+      end
     end
   end
 
-  describe 'replace' do
+  describe 'update' do
     let(:key)      { double('Key') }
     let(:rev)      { double('Rev') }
     let(:model)    { double('Model', key: key).as_null_object }
@@ -494,36 +506,34 @@ describe Guacamole::Collection 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
+      it 'should update the document by key via the connection' do
         expect(connection).to receive(:replace).with(key, document)
 
-        subject.replace model
+        subject.update 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
+        subject.update model
       end
 
       it 'should return the model' do
-        expect(subject.replace(model)).to eq model
+        expect(subject.update(model)).to eq model
       end
 
-      it 'should not update created_at' do
-        expect(model).not_to receive(:created_at=)
+      it 'should run the update callbacks for the given model' do
+        expect(callbacks).to receive(:run_callbacks).with(:save, :update).and_yield
 
-        subject.replace model
+        subject.update model
+      end
+
+      it 'should run first the validation and then the update callbacks' do
+        expect(model).to receive(:valid?).ordered.and_return(true)
+        expect(callbacks).to receive(:run_callbacks).ordered.with(:save, :update).and_yield
+
+        subject.update model
       end
     end
 
@@ -532,21 +542,20 @@ describe Guacamole::Collection do
         allow(model).to receive(:valid?).and_return(false)
       end
 
-      it 'should not be used to replace the document' do
+      it 'should not be used to update the document' do
         expect(connection).not_to receive(:replace)
 
-        subject.replace model
+        subject.update model
       end
 
       it 'should not be changed' do
         expect(model).not_to receive(:rev=)
-        expect(model).not_to receive(:updated_at=)
 
-        subject.replace model
+        subject.update model
       end
 
       it 'should return false' do
-        expect(subject.replace(model)).to be false
+        expect(subject.update(model)).to be false
       end
     end
   end
@@ -624,4 +633,14 @@ describe Guacamole::Collection do
       end
     end
   end
+
+  describe 'callbacks' do
+    let(:model) { double('Model') }
+
+    it 'should get the callback instance for the given model' do
+      expect(callbacks_module).to receive(:callbacks_for).with(model)
+
+      subject.callbacks model
+    end
+  end
 end

data/spec/unit/configuration_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'guacamole/configuration'
+require 'tempfile'
 
 describe 'Guacamole.configure' do
   subject { Guacamole }
@@ -80,20 +81,109 @@ describe Guacamole::Configuration do
     end
   end
 
+  describe 'build_config' do
+    context 'from a hash' do
+      let(:config_hash) do
+        {
+          'protocol' => 'http',
+          'host'     => 'localhost',
+          'port'     => 8529,
+          'username' => 'username',
+          'password' => 'password',
+          'database' => 'awesome_db'
+        }
+      end
+      let(:config_struct) { subject.build_config(config_hash) }
+
+      it 'should create a struct with a database URL' do
+        expect(config_struct.url).to eq 'http://localhost:8529'
+      end
+
+      it 'should create a struct with a username' do
+        expect(config_struct.username).to eq 'username'
+      end
+
+      it 'should create a struct with password' do
+        expect(config_struct.password).to eq 'password'
+      end
+
+      it 'should create a struct with database' do
+        expect(config_struct.database).to eq 'awesome_db'
+      end
+    end
+
+    context 'from a URL' do
+      let(:database_url) { 'http://username:password@localhost:8529/_db/awesome_db' }
+      let(:config_struct) { subject.build_config(database_url) }
+
+      it 'should create a struct with a database URL' do
+        expect(config_struct.url).to eq 'http://localhost:8529'
+      end
+
+      it 'should create a struct with a username' do
+        expect(config_struct.username).to eq 'username'
+      end
+
+      it 'should create a struct with password' do
+        expect(config_struct.password).to eq 'password'
+      end
+
+      it 'should create a struct with database' do
+        expect(config_struct.database).to eq 'awesome_db'
+      end
+    end
+  end
+
+  describe 'create_database_connection' do
+    let(:config_struct)    { double('ConfigStruct', url: 'http://localhost', username: 'user', password: 'pass', database: 'pony_db') }
+    let(:arango_config)    { double('ArangoConfig').as_null_object }
+    let(:database)         { double('Ashikawa::Core::Database') }
+    let(:guacamole_logger) { double('logger') }
+
+    before do
+      allow(Ashikawa::Core::Database).to receive(:new).and_yield(arango_config).and_return(database)
+      allow(subject).to receive(:logger).and_return(guacamole_logger)
+    end
+
+    it 'should create the actual Ashikawa::Core::Database instance' do
+      expect(arango_config).to receive(:url=).with('http://localhost')
+      expect(arango_config).to receive(:username=).with('user')
+      expect(arango_config).to receive(:password=).with('pass')
+
+      subject.create_database_connection config_struct
+    end
+
+    it 'should pass the Guacamole logger to the Ashikawa::Core::Database connection' do
+      expect(arango_config).to receive(:logger=).with(guacamole_logger)
+
+      subject.create_database_connection config_struct
+    end
+
+    it 'should assign the database connection to the configuration instance' do
+      subject.create_database_connection config_struct
+
+      expect(subject.database).to eq database
+    end
+  end
+
   describe 'load' do
     let(:config) { double('Config') }
+    let(:env_config) { double('ConfigForEnv') }
+    let(:config_struct) { double('ConfigStruct') }
     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)
+      allow(subject).to receive(:warn_if_database_was_not_yet_created)
+      allow(subject).to receive(:create_database_connection)
+      allow(subject).to receive(:process_file_with_erb).with('config_file.yml')
+      allow(subject).to receive(:build_config).and_return(config_struct)
+      allow(config).to  receive(:[]).with('development').and_return(env_config)
+      allow(YAML).to    receive(:load).and_return(config)
     end
 
     it 'should parse a YAML configuration' do
-      expect(YAML).to receive(:load_file).with('config_file.yml').and_return(config)
+      expect(YAML).to receive(:load).and_return(config)
 
       subject.load 'config_file.yml'
     end
@@ -104,27 +194,81 @@ describe Guacamole::Configuration do
       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)
+    it 'should create a database config struct from config file' do
+      expect(subject).to receive(:build_config).with(env_config).and_return(config_struct)
 
-      allow(Ashikawa::Core::Database).to receive(:new).and_yield(arango_config)
+      subject.load 'config_file.yml'
+    end
 
-      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
+    it 'should create the database connection with a config struct' do
+      expect(subject).to receive(:create_database_connection).with(config_struct)
 
       subject.load 'config_file.yml'
     end
+
+    it 'should warn if the database was not found' do
+      allow(subject).to receive(:database).and_return(double('Database'))
+      allow(subject.database).to receive(:name)
+      expect(subject.database).to receive(:send_request).with('version').and_raise(Ashikawa::Core::ResourceNotFound)
+      expect(subject).to receive(:warn_if_database_was_not_yet_created).and_call_original
+
+      logger = double('logger')
+      expect(logger).to receive(:warn)
+      expect(subject).to receive(:warn)
+      allow(subject).to receive(:logger).and_return(logger)
+
+      subject.load 'config_file.yml'
+    end
+
+    context 'erb support' do
+      let(:config_file) { File.open 'spec/support/guacamole.yml.erb' }
+      let(:protocol_via_erb) { ENV['ARANGODB_PROTOCOL'] = 'https' }
+      let(:database_via_erb) { ENV['ARANGODB_DATABASE'] = 'my_playground' }
+
+      before do
+        allow(subject).to receive(:process_file_with_erb).and_call_original
+      end
+
+      after do
+        ENV.delete 'ARANGODB_PROTOCOL'
+        ENV.delete 'ARANGODB_DATABASE'
+      end
+
+      it 'should process the YAML file with ERB' do
+        processed_yaml = <<-YAML
+development:
+  protocol: '#{protocol_via_erb}'
+  host: 'localhost'
+  port: 8529
+  database: '#{database_via_erb}'
+        YAML
+        expect(YAML).to receive(:load).with(processed_yaml)
+
+        subject.load config_file.path
+      end
+    end
+  end
+
+  describe 'configure with a connection URI' do
+    let(:config_struct) { double('ConfigStruct') }
+    let(:connection_uri) { 'http://username:password@locahost:8529/_db/awesome_db' }
+
+    before do
+      allow(subject).to receive(:create_database_connection)
+      allow(subject).to receive(:build_config).and_return(config_struct)
+    end
+
+    it 'should build a config_struct from the connection URI' do
+      expect(subject).to receive(:build_config).with(connection_uri)
+
+      subject.configure_with_uri(connection_uri)
+    end
+
+    it 'should use the config_struct to create the database connection' do
+      expect(subject).to receive(:create_database_connection).with(config_struct)
+
+      subject.configure_with_uri(connection_uri)
+    end
   end
 
   describe 'experimental_features' do