guacamole 0.3.0 → 0.4.0

data/spec/unit/configuration_spec.rb

@@ -81,6 +81,57 @@ describe Guacamole::Configuration do
     end
   end
 
+  describe 'graph' do
+    let(:database) { instance_double('Ashikawa::Core::Database') }
+    let(:graph) { instance_double('Ashikawa::Core::Graph') }
+    let(:graph_name) { 'my-amazing-graph' }
+
+    before do
+      subject.graph_name = nil
+      allow(subject).to receive(:database).and_return(database)
+      allow(database).to receive(:graph).with(graph_name).and_return(graph)
+    end
+
+    it 'should allow access to the associated graph based on the graph_name attribute' do
+      allow(subject).to receive(:graph_name).and_return(graph_name)
+
+      expect(subject.graph).to eq graph
+    end
+
+    context 'configure the graph name' do
+      context 'within a Rails application' do
+        let(:rails_module) { double('Rails') }
+        let(:application_class) { double('ApplicationClass', name: 'MyAwesomeApp::Application') }
+        let(:rails_application) { double('MyAwesomeApp::Application', class: application_class) }
+
+        before do
+          allow(rails_module).to receive(:application).and_return(rails_application)
+          stub_const('Rails', rails_module)
+        end
+
+        its(:graph_name) { should eq 'my_awesome_app_graph' }
+      end
+
+      it 'should be generated based on the current database name' do
+        allow(database).to receive(:name).and_return('my_database')
+
+        expect(subject.graph_name).to eq 'my_database_graph'
+      end
+
+      it 'should use a custom set graph name' do
+        subject.graph_name = 'fabulous_graph'
+
+        expect(subject.graph_name).to eq 'fabulous_graph'
+      end
+
+      it 'should take the graph name from the ENV' do
+        allow(ENV).to receive(:[]).with('GUACAMOLE_GRAPH').and_return('graph_from_env')
+
+        expect(subject.graph_name).to eq 'graph_from_env'
+      end
+    end
+  end
+
   describe 'build_config' do
     context 'from a hash' do
       let(:config_hash) do
@@ -90,47 +141,29 @@ describe Guacamole::Configuration do
           'port'     => 8529,
           'username' => 'username',
           'password' => 'password',
-          'database' => 'awesome_db'
+          'database' => 'awesome_db',
+          'graph'    => 'custom_graph'
         }
       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
+      subject { Guacamole::Configuration.build_config(config_hash) }
 
-      it 'should create a struct with database' do
-        expect(config_struct.database).to eq 'awesome_db'
-      end
+      its(:url)      { should eq 'http://localhost:8529' }
+      its(:username) { should eq 'username' }
+      its(:password) { should eq 'password' }
+      its(:database) { should eq 'awesome_db' }
+      its(:graph)    { should eq 'custom_graph' }
     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
+      subject { Guacamole::Configuration.build_config(database_url) }
 
-      it 'should create a struct with database' do
-        expect(config_struct.database).to eq 'awesome_db'
-      end
+      its(:url)      { should eq 'http://localhost:8529' }
+      its(:username) { should eq 'username' }
+      its(:password) { should eq 'password' }
+      its(:database) { should eq 'awesome_db' }
     end
   end
 
@@ -178,8 +211,9 @@ describe Guacamole::Configuration do
       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)
+      allow(config).to receive(:[]).with('development').and_return(env_config)
+      allow(config_struct).to receive(:graph).and_return('custom_graph_name')
+      allow(YAML).to receive(:load).and_return(config)
     end
 
     it 'should parse a YAML configuration' do
@@ -206,6 +240,12 @@ describe Guacamole::Configuration do
       subject.load 'config_file.yml'
     end
 
+    it 'should set the graph name as read from the YAML file' do
+      expect(subject).to receive(:graph_name=).with('custom_graph_name')
+
+      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)
@@ -270,21 +310,4 @@ development:
       subject.configure_with_uri(connection_uri)
     end
   end
-
-  describe 'experimental_features' do
-    let(:fresh_config) { Guacamole::Configuration.new }
-
-    after do
-      subject.experimental_features = []
-    end
-
-    it 'should default to none' do
-      expect(fresh_config.experimental_features).to be_empty
-    end
-
-    it 'should accept a list of features to activate' do
-      subject.experimental_features = [:aql_support]
-      expect(subject.experimental_features).to include :aql_support
-    end
-  end
 end

data/spec/unit/document_model_mapper_spec.rb

@@ -22,6 +22,22 @@ describe Guacamole::DocumentModelMapper do
     expect(mapper.model_class).to eq FancyModel
   end
 
+  context 'document mapper instance' do
+    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
+
+    let(:model) { double('Model') }
+    let(:model_class) { double('ModelClass') }
+
+    before do
+      allow(subject).to receive(:model_class).and_return(model_class)
+      allow(model).to receive(:instance_of?).with(model_class).and_return(true)
+    end
+
+    it 'should know if it responsible for a certain model' do
+      expect(subject.responsible_for?(model)).to be_truthy
+    end
+  end
+
   describe 'document_to_model' do
     subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
 
@@ -52,57 +68,41 @@ 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)
+    context 'with attributes as edge relations' do
+      let(:attribute_with_edge_relation) do
+        instance_double('Guacamole::DocumentModelMapper::Attribute', name: 'my_relation')
       end
+      let(:related_edge_class) { instance_double('Guacamole::Edge') }
+      let(:relation_proxy_class) { Guacamole::Proxies::Relation }
+      let(:relation_proxy) { instance_double('Guacamole::Proxies::Relation') }
 
-      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
+      before do
+        allow(attribute_with_edge_relation).to receive(:setter).and_return('my_relation=')
+        allow(attribute_with_edge_relation).to receive(:edge_class).and_return(related_edge_class)
+        allow(subject).to receive(:edge_attributes).and_return([attribute_with_edge_relation])
+        allow(relation_proxy_class).to receive(:new).
+                                        with(model_instance, related_edge_class).
+                                        and_return(relation_proxy)
       end
 
-      it 'should set an association proxy' do
-        expect(model_instance).to receive("#{referenced_by_model_name}=").with(association_proxy_instance)
+      it 'should initialize a relation proxy with the model and the appropriate edge class' do
+        expect(relation_proxy_class).to receive(:new).
+                                         with(model_instance, related_edge_class).
+                                         and_return(relation_proxy)
 
         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)
+      it 'should set first the key and rev and after that the proxy' do
+        expect(model_instance).to receive(:key=).ordered
+        expect(model_instance).to receive(:rev=).ordered
+        expect(subject).to receive(:handle_related_documents).ordered
 
         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)
+      it 'should assign the relation proxy for the appropriate attribute' do
+        expect(model_instance).to receive(:my_relation=).with(relation_proxy)
 
         subject.document_to_model document
       end
@@ -171,39 +171,17 @@ describe Guacamole::DocumentModelMapper do
       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
+    context 'with attributes as edge relations' do
+      let(:attribute_with_edge_relation) do
+        instance_double('Guacamole::DocumentModelMapper::Attribute', name: 'my_relation')
       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
+        allow(subject).to receive(:edge_attributes).and_return([attribute_with_edge_relation])
       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)
+      it 'should remove the attributes from the document' do
+        expect(model_attributes).to receive(:delete).with('my_relation')
 
         subject.model_to_document(model)
       end
@@ -220,23 +198,52 @@ describe Guacamole::DocumentModelMapper do
     end
   end
 
-  describe 'referenced_by' do
-    subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
+  describe 'attribute' do
+    describe Guacamole::DocumentModelMapper::Attribute do
+      subject { Guacamole::DocumentModelMapper::Attribute.new(:attribute_name) }
+
+      its(:name) { should eq :attribute_name }
+      its(:options) { should eq({}) }
+      its(:getter) { should eq :attribute_name }
+      its(:setter) { should eq 'attribute_name=' }
 
-    it 'should remember which models holding references' do
-      subject.referenced_by :ponies
+      context 'attributes for relations' do
+        let(:edge_class) { double('SomeEdgeClass') }
 
-      expect(subject.referenced_by_models).to include :ponies
+        before do
+          subject.options[:via] = edge_class
+        end
+
+        it 'should know if the attribute must be mapped via an edge' do
+          expect(subject.map_via_edge?).to be_truthy
+        end
+
+        it 'should hold a reference to the edge class' do
+          expect(subject.edge_class).to eq edge_class
+        end
+      end
     end
-  end
 
-  describe 'references' do
     subject { Guacamole::DocumentModelMapper.new FancyModel, FakeIdentityMap }
 
-    it 'should remember which models are referenced' do
-      subject.references :pony
+    it 'should add an attribute to be handled differently during the mapping' do
+      subject.attribute :special_one
+
+      expect(subject.attributes).to include Guacamole::DocumentModelMapper::Attribute.new(:special_one)
+    end
+
+    it 'should hold a list of all attributes to be considered during the mapping' do
+      subject.attribute :some_attribute
+      subject.attribute :another_attribute
+
+      expect(subject.attributes.count).to eq 2
+    end
+
+    it 'should hold a list of all attributes to be mapped via Edges' do
+      subject.attribute :normal_attribute
+      subject.attribute :related_model, via: double('EdgeClass')
 
-      expect(subject.referenced_models).to include :pony
+      expect(subject.edge_attributes).to include(an_object_having_attributes(name: :related_model))
     end
   end
 end

data/spec/unit/edge_collection_spec.rb

@@ -0,0 +1,174 @@
+# -*- encoding : utf-8 -*-
+
+require 'spec_helper'
+require 'guacamole/edge_collection'
+
+describe Guacamole::EdgeCollection do
+  let(:graph)  { double('Graph') }
+  let(:config) { double('Configuration') }
+
+  before do
+    allow(Guacamole).to receive(:configuration).and_return(config)
+    allow(config).to receive(:graph).and_return(graph)
+    allow(graph).to receive(:add_edge_definition)
+  end
+
+  context 'the edge collection module' do
+    subject { Guacamole::EdgeCollection }
+
+    context 'with user defined edge collection class' do
+      let(:edge_class) { double('EdgeClass', name: 'MyEdge') }
+      let(:user_defined_edge_collection) { double('EdgeCollection') }
+
+      before do
+        stub_const('MyEdgesCollection', user_defined_edge_collection)
+        allow(user_defined_edge_collection).to receive(:add_edge_definition_to_graph)
+      end
+
+      it 'should return the edge collection for a given edge class' do
+        expect(subject.for(edge_class)).to eq user_defined_edge_collection
+      end
+    end
+
+    context 'without user defined edge collection class' do
+      let(:edge_class) { double('EdgeClass', name: 'AmazingEdge') }
+      let(:auto_defined_edge_collection) { double('EdgeCollection') }
+
+      before do
+        stub_const('ExampleEdge', double('Edge').as_null_object)
+        allow(auto_defined_edge_collection).to receive(:add_edge_definition_to_graph)
+      end
+
+      it 'should create an edge collection class' do
+        edge_collection = subject.create_edge_collection('ExampleEdgesCollection')
+
+        expect(edge_collection.name).to eq 'ExampleEdgesCollection'
+        expect(edge_collection.ancestors).to include Guacamole::EdgeCollection
+      end
+
+      it 'should return the edge collection for a givene edge class' do
+        allow(subject).to receive(:create_edge_collection).
+                           with('AmazingEdgesCollection').
+                           and_return(auto_defined_edge_collection)
+
+        expect(subject.for(edge_class)).to eq auto_defined_edge_collection
+      end
+    end
+  end
+
+  context 'concrete edge collections' do
+    subject do
+      class SomeEdgesCollection
+        include Guacamole::EdgeCollection
+      end
+    end
+
+    let(:database) { double('Database') }
+    let(:edge_collection_name) { 'some_edges' }
+    let(:raw_edge_collection) { double('Ashikawa::Core::EdgeCollection') }
+    let(:collection_a) { :a }
+    let(:collection_b) { :b }
+    let(:edge_class) { double('EdgeClass', name: 'SomeEdge', from: collection_a, to: collection_b) }
+    let(:model) { double('Model') }
+
+    before do
+      stub_const('SomeEdge', edge_class)
+      allow(graph).to receive(:edge_collection).with(edge_collection_name).and_return(raw_edge_collection)
+      allow(subject).to receive(:database).and_return(database)
+      allow(graph).to receive(:add_edge_definition)
+    end
+
+    after do
+      # This stunt is required to have a fresh subject each time and not running into problems
+      # with cached mock doubles that will raise errors upon test execution.
+      Object.send(:remove_const, subject.name)
+    end
+
+    its(:edge_class) { should eq edge_class }
+
+    it 'should be a specialized Guacamole::Collection' do
+      expect(subject).to include Guacamole::Collection
+    end
+
+    it 'should map the #connectino to the underlying edge_connection' do
+      allow(subject).to receive(:graph).and_return(graph)
+
+      expect(subject.connection).to eq raw_edge_collection
+    end
+
+    context 'initialize the edge definition' do
+      it 'should add the edge definition as soon as the module is included' do
+        just_another_edge_collection = Class.new
+        expect(just_another_edge_collection).to receive(:add_edge_definition_to_graph)
+
+        just_another_edge_collection.send(:include, Guacamole::EdgeCollection)
+      end
+
+      it 'should ignore if the the edge definition was already added' do
+        expect(graph).to receive(:add_edge_definition).and_raise(Ashikawa::Core::ResourceNotFound)
+
+        expect { subject.add_edge_definition_to_graph }.not_to raise_error
+      end
+
+      it 'should create the edge definition based on the edge class' do
+        expect(graph).to receive(:add_edge_definition).with(edge_collection_name,
+                                                            from: [collection_a], to: [collection_b])
+
+        subject.add_edge_definition_to_graph
+      end
+    end
+
+    context 'accessing the mapper' do
+      let(:collection_a) { double('Collection') }
+      let(:collection_b) { double('Collection') }
+      let(:mapper_a) { double('DocumentModelMapper') }
+      let(:mapper_b)  { double('DocumentModelMapper') }
+
+      before do
+        allow(collection_a).to receive(:mapper).and_return(mapper_a)
+        allow(collection_b).to receive(:mapper).and_return(mapper_b)
+        allow(edge_class).to receive(:from_collection).and_return(collection_a)
+        allow(edge_class).to receive(:to_collection).and_return(collection_b)
+        allow(mapper_a).to receive(:responsible_for?).with(model).and_return(true)
+        allow(mapper_b).to receive(:responsible_for?).with(model).and_return(false)
+      end
+
+      it 'should provide a method to get the mapper for the :to collection' do
+        expect(subject.mapper_for_target(model)).to eq mapper_b
+      end
+
+      it 'should provide a method to get the mapper for the :from collection' do
+        expect(subject.mapper_for_start(model)).to eq mapper_a
+      end
+    end
+
+    context 'getting neighbors' do
+      let(:graph_query) { instance_double('Guacamole::GraphQuery') }
+      let(:target_mapper) { double('DocumentModelMapper') }
+
+      before do
+        allow(Guacamole::GraphQuery).to receive(:new).and_return(graph_query)
+        allow(subject).to receive(:mapper_for_target).with(model).and_return(target_mapper)
+        allow(graph_query).to receive(:neighbors).and_return(graph_query)
+      end
+
+      it 'should return a query object' do
+        query = subject.neighbors(model)
+
+        expect(query).to eq graph_query
+      end
+
+      it 'should initialize the query object with the graph an the appropriate mapper' do
+        expect(Guacamole::GraphQuery).to receive(:new).with(graph, target_mapper).and_return(graph_query)
+
+        subject.neighbors(model)
+      end
+
+      it 'should provide a #neighbors function' do
+        expect(graph_query).to receive(:neighbors).with(model, 'some_edges')
+
+        subject.neighbors(model)
+      end
+    end
+  end
+end