guacamole 0.0.1 → 0.1.0

data/spec/unit/configuration_spec.rb

@@ -21,11 +21,21 @@ describe 'Guacamole.configuration' do
   end
 end
 
+describe 'Guacamole.logger' do
+  subject { Guacamole }
+
+  it 'should just forward to Configuration#logger' do
+    expect(Guacamole.configuration).to receive(:logger)
+
+    subject.logger
+  end
+end
+
 describe Guacamole::Configuration do
   subject { Guacamole::Configuration }
 
   describe 'database' do
-    it 'should set the logger' do
+    it 'should set the database' do
       database         = double('Database')
       subject.database = database
 

data/spec/unit/document_model_mapper_spec.rb

@@ -6,16 +6,24 @@ require 'guacamole/document_model_mapper'
 class FancyModel
 end
 
+class FakeIdentityMap
+  class << self
+    def retrieve_or_store(*args, &block)
+      block.call
+    end
+  end
+end
+
 describe Guacamole::DocumentModelMapper do
   subject { Guacamole::DocumentModelMapper }
 
   it 'should be initialized with a model class' do
-    mapper = subject.new FancyModel
+    mapper = subject.new FancyModel, FakeIdentityMap
     expect(mapper.model_class).to eq FancyModel
   end
 
   describe 'document_to_model' do
-    subject { Guacamole::DocumentModelMapper.new FancyModel }
+    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
 
     let(:document)            { double('Ashikawa::Core::Document') }
     let(:document_attributes) { double('Hash') }
@@ -25,7 +33,7 @@ describe Guacamole::DocumentModelMapper do
 
     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(:to_h).and_return(document_attributes)
       allow(document).to receive(:key).and_return(some_key)
       allow(document).to receive(:revision).and_return(some_rev)
     end
@@ -44,6 +52,62 @@ describe Guacamole::DocumentModelMapper do
       subject.document_to_model document
     end
 
+    context 'with referenced_by models' do
+      let(:referenced_by_model_name)   { :cupcakes }
+      let(:referenced_by_models)       { [referenced_by_model_name] }
+      let(:association_proxy)          { Guacamole::Proxies::ReferencedBy }
+      let(:association_proxy_instance) { double('AssociationProxy') }
+
+      before do
+        allow(subject).to receive(:referenced_by_models).and_return referenced_by_models
+        allow(association_proxy).to receive(:new)
+          .with(referenced_by_model_name, model_instance)
+          .and_return(association_proxy_instance)
+      end
+
+      it 'should initialize the association proxy with referenced_by model and its name' do
+        expect(association_proxy).to receive(:new)
+          .with(referenced_by_model_name, model_instance)
+          .and_return(association_proxy_instance)
+
+        subject.document_to_model document
+      end
+
+      it 'should set an association proxy' do
+        expect(model_instance).to receive("#{referenced_by_model_name}=").with(association_proxy_instance)
+
+        subject.document_to_model document
+      end
+    end
+
+    context 'with referenced models' do
+      let(:referenced_model_name)      { :pony }
+      let(:referenced_models)          { [referenced_model_name] }
+      let(:association_proxy)          { Guacamole::Proxies::References }
+      let(:association_proxy_instance) { double('AssociationProxy') }
+
+      before do
+        allow(subject).to receive(:referenced_models).and_return referenced_models
+        allow(association_proxy).to receive(:new)
+          .with(referenced_model_name, document)
+          .and_return(association_proxy_instance)
+      end
+
+      it 'should initialize the association proxy with the document and the referenced model name' do
+        expect(association_proxy).to receive(:new)
+          .with(referenced_model_name, document)
+          .and_return(association_proxy_instance)
+
+        subject.document_to_model document
+      end
+
+      it 'should set an association proxy' do
+        expect(model_instance).to receive("#{referenced_model_name}=").with(association_proxy_instance)
+
+        subject.document_to_model document
+      end
+    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
@@ -51,7 +115,7 @@ describe Guacamole::DocumentModelMapper do
   end
 
   describe 'model_to_document' do
-    subject { Guacamole::DocumentModelMapper.new FancyModel }
+    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
 
     let(:model)            { double('Model') }
     let(:model_attributes) { double('Hash').as_null_object }
@@ -106,10 +170,48 @@ describe Guacamole::DocumentModelMapper do
         subject.model_to_document(model)
       end
     end
+
+    context 'with referenced_by models' do
+      let(:referenced_by_model_name) { :cupcakes }
+      let(:referenced_by_models)     { [referenced_by_model_name] }
+
+      before do
+        allow(subject).to receive(:referenced_by_models).and_return referenced_by_models
+      end
+
+      it 'should remove the referenced_by attribute from the document' do
+        expect(model_attributes).to receive(:delete).with(referenced_by_model_name)
+
+        subject.model_to_document(model)
+      end
+    end
+
+    context 'with referenced models' do
+      let(:referenced_model)       { double('ReferencedModel', key: 23) }
+      let(:referenced_model_name)  { :pony }
+      let(:referenced_models)      { [referenced_model_name] }
+
+      before do
+        allow(subject).to receive(:referenced_models).and_return referenced_models
+        allow(model).to receive(:send).with(referenced_model_name).and_return referenced_model
+      end
+
+      it 'should remove the referenced attribute from the document' do
+        expect(model_attributes).to receive(:delete).with(referenced_model_name)
+
+        subject.model_to_document(model)
+      end
+
+      it 'should add the key of the referenced model to the document' do
+        expect(model_attributes).to receive(:[]=).with(:"#{referenced_model_name}_id", referenced_model.key)
+
+        subject.model_to_document(model)
+      end
+    end
   end
 
   describe 'embed' do
-    subject { Guacamole::DocumentModelMapper.new FancyModel }
+    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
 
     it 'should remember which models to embed' do
       subject.embeds :ponies
@@ -117,4 +219,24 @@ describe Guacamole::DocumentModelMapper do
       expect(subject.models_to_embed).to include :ponies
     end
   end
+
+  describe 'referenced_by' do
+    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
+
+    it 'should remember which models holding references' do
+      subject.referenced_by :ponies
+
+      expect(subject.referenced_by_models).to include :ponies
+    end
+  end
+
+  describe 'references' do
+    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
+
+    it 'should remember which models are referenced' do
+      subject.references :pony
+
+      expect(subject.referenced_models).to include :pony
+    end
+  end
 end

data/spec/unit/identiy_map_spec.rb

@@ -0,0 +1,140 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/identity_map'
+
+describe Guacamole::IdentityMap::Session do
+  context 'initialization' do
+    subject { Guacamole::IdentityMap::Session }
+
+    let(:an_app) { double('TheApp') }
+
+    it 'should require an app object' do
+      middleware = subject.new an_app
+
+      expect(middleware.instance_variable_get('@app')).to eq an_app
+    end
+  end
+
+  context 'resetting the IdentityMap' do
+    let(:some_app) { double('TheApp').as_null_object }
+    let(:rack_env) { double('RackEnv') }
+    let(:logger)   { double('Logger').as_null_object }
+
+    subject { Guacamole::IdentityMap::Session.new some_app }
+
+    before do
+      allow(Guacamole).to receive(:logger).and_return(logger)
+    end
+
+    it 'should reset the IdentityMap upon `call` and bypass to the @app' do
+      expect(Guacamole::IdentityMap).to receive(:reset)
+
+      subject.call rack_env
+    end
+
+    it 'should pass the request to the @app instance' do
+      expect(some_app).to receive(:call).with(rack_env)
+
+      subject.call rack_env
+    end
+
+    it 'should log the reset action as debug' do
+      expect(logger).to receive(:debug).with('[SESSION] Resetting the IdentityMap')
+
+      subject.call rack_env
+    end
+  end
+
+end
+
+describe Guacamole::IdentityMap do
+  subject { Guacamole::IdentityMap }
+
+  before do
+    subject.reset
+  end
+
+  describe 'Management' do
+    it 'should always return an identity_map_instance' do
+      expect(subject.identity_map_instance).not_to be_nil
+    end
+
+    it 'should reset the current map' do
+      expect(Hamster).to receive(:hash)
+
+      subject.reset
+      subject.identity_map_instance
+    end
+
+    context 'construct the storage key' do
+      it 'should use the object' do
+        some_object = double('SomeObject', key: '1337')
+
+        expect(subject.key_for(some_object)).to eq [some_object.class, some_object.key]
+      end
+
+      it 'should construct the map key based on the class and the key' do
+        some_class = double(:SomeClass)
+        some_key   = '1337'
+
+        expect(subject.key_for(some_class.class, some_key)).to eq [some_class.class, some_key]
+      end
+    end
+  end
+
+  describe 'Store objects' do
+    let(:cupcake) { double('Cupcake', key: '42') }
+
+    before do
+      subject.reset
+    end
+
+    it 'should use the `key_for` method to construct the map key' do
+      expect(subject).to receive(:key_for).with(cupcake).and_return(:the_key)
+
+      subject.store cupcake
+    end
+
+    it 'should store the object in the map' do
+      subject.store cupcake
+
+      expect(subject.include?(cupcake)).to be_true
+    end
+
+    it 'should use an immutable storage' do
+      old_map = subject.identity_map_instance
+      subject.store cupcake
+
+      expect(old_map.key?(subject.key_for(cupcake))).to be_false
+    end
+
+    it 'should return the stored object' do
+      expect(subject.store(cupcake)).to eq cupcake
+    end
+  end
+
+  describe 'Retrieve objects' do
+    let(:pony) { double('Pony', key: '23') }
+
+    before do
+      subject.store pony
+    end
+
+    it 'should load the corresponding object from the map' do
+      expect(subject.retrieve(pony.class, pony.key)).to eq pony
+    end
+  end
+
+  describe 'Retrieve or store objects' do
+    let(:rainbow) { double('Rainbow', key: 'all-the-colors') }
+
+    it 'should store and retrieve an object in one step' do
+      result = subject.retrieve_or_store(rainbow.class, rainbow.key) do
+        rainbow
+      end
+
+      expect(subject.retrieve(rainbow.class, rainbow.key)).to eq result
+    end
+  end
+end

data/spec/unit/query_spec.rb

@@ -41,13 +41,13 @@ describe Guacamole::Query do
         expect(connection).to receive(:all)
           .with({})
 
-        subject.each { }
+        subject.each {}
       end
 
       it 'should iterate over the resulting documents' do
         expect(result).to receive(:each)
 
-        subject.each { }
+        subject.each {}
       end
 
       it 'should yield the models to the caller' do
@@ -62,15 +62,15 @@ describe Guacamole::Query do
         expect(connection).to receive(:all)
           .with(hash_including limit: limit)
 
-        subject.limit(limit).each { }
+        subject.limit(limit).each {}
       end
 
-       it 'should accept a skip' do
-         expect(connection).to receive(:all)
-           .with(hash_including skip: skip)
+      it 'should accept a skip' do
+        expect(connection).to receive(:all)
+          .with(hash_including skip: skip)
 
-         subject.skip(skip).each { }
-       end
+        subject.skip(skip).each {}
+      end
     end
 
     context 'an example was provided' do
@@ -86,13 +86,13 @@ describe Guacamole::Query do
         expect(connection).to receive(:by_example)
           .with(example, {})
 
-        subject.each { }
+        subject.each {}
       end
 
       it 'should iterate over the resulting documents' do
         expect(result).to receive(:each)
 
-        subject.each { }
+        subject.each {}
       end
 
       it 'should yield the models to the caller' do
@@ -107,15 +107,15 @@ describe Guacamole::Query do
         expect(connection).to receive(:by_example)
           .with(example, hash_including(limit: limit))
 
-        subject.limit(limit).each { }
+        subject.limit(limit).each {}
       end
 
-       it 'should accept a skip' do
-         expect(connection).to receive(:by_example)
-           .with(example, hash_including(skip: skip))
+      it 'should accept a skip' do
+        expect(connection).to receive(:by_example)
+          .with(example, hash_including(skip: skip))
 
-         subject.skip(skip).each { }
-       end
+        subject.skip(skip).each {}
+      end
     end
   end
 
@@ -137,4 +137,25 @@ describe Guacamole::Query do
       end
     end
   end
+
+  describe '==' do
+    subject { Guacamole::Query }
+
+    let(:one_query)     { subject.new(double('Connection'), double('Mapper')) }
+    let(:another_query) { subject.new(double('Connection'), double('Mapper')) }
+
+    it 'should be equal if the example it equal' do
+      one_query.example = { this: 23 }
+      another_query.example = { this: 23 }
+
+      expect(one_query).to eq another_query
+    end
+
+    it 'should not be equal if the examples differ' do
+      one_query.example = { this: 23 }
+      another_query.example = { that: 42 }
+
+      expect(one_query).not_to eq another_query
+    end
+  end
 end

data/tasks/adjustments.rake

@@ -27,7 +27,6 @@ task ci: %w[
   spec
   metrics:coverage
   metrics:reek
-  metrics:rubocop
   metrics:yardstick:verify
 ]