guacamole 0.3.0 → 0.4.0

data/spec/acceptance/aql_spec.rb

@@ -10,49 +10,41 @@ describe 'BasicAQLSupport' do
   let(:earth_pony) { Fabricate(:pony, type: ['Earthpony'], name: 'Candy Mane') }
   let(:unicorn_pegasus_pony) { Fabricate(:pony, type: ['Pegasus', 'Unicorn']) }
 
-  context 'with experimental AQL support enabled' do
-    before do
-      Guacamole.configuration.experimental_features = [:aql_support]
-
-      [pegasus_pony, earth_pony, unicorn_pegasus_pony]
-    end
-
-    it 'should retrieve models by simple AQL queries' do
-      pony_by_name = PoniesCollection.by_aql('FILTER pony.name == @name', name: 'Candy Mane').first
-      expect(pony_by_name).to eq earth_pony
-    end
-
-    it 'should retrieve models by more complex AQL queries' do
-      ponies_by_type = PoniesCollection.by_aql('FILTER POSITION(pony.type, @pony_type, false) == true',
-                                               pony_type: 'Pegasus')
-      expect(ponies_by_type).to include unicorn_pegasus_pony
-      expect(ponies_by_type).to include pegasus_pony
-    end
-
-    it 'should allow a custom RETURN statement' do
-      custom_color = 'fancy white pink with sparkles'
-      pony_by_name = PoniesCollection.by_aql('FILTER pony.name == @name',
-                                             { name: 'Candy Mane' },
-                                             return_as: %Q{RETURN MERGE(pony, {"color": "#{custom_color}"})}).first
-      expect(pony_by_name.color).to eq custom_color
-    end
-
-    it 'should allow to disable the mapping' do
-      pony_hash = PoniesCollection.by_aql('FILTER pony.name == @name',
-                                          { name: 'Candy Mane' },
-                                          mapping: false ).first
-      expect(pony_hash).to be_an(Ashikawa::Core::Document)
-    end
+  before do
+    [pegasus_pony, earth_pony, unicorn_pegasus_pony]
   end
 
-  context 'without experimental AQL support enabled' do
-    before do
-      Guacamole.configuration.experimental_features = []
-    end
+  it 'should retrieve models by simple AQL queries' do
+    pony_by_name = PoniesCollection.by_aql('FILTER pony.name == @name', name: 'Candy Mane').first
+    expect(pony_by_name).to eq earth_pony
+  end
+
+  it 'should retrieve models by more complex AQL queries' do
+    ponies_by_type = PoniesCollection.by_aql('FILTER POSITION(pony.type, @pony_type, false) == true',
+                                             pony_type: 'Pegasus')
+    expect(ponies_by_type).to include unicorn_pegasus_pony
+    expect(ponies_by_type).to include pegasus_pony
+  end
 
-    it 'should raise an error accessing the AQL feature' do
-      expect { PoniesCollection.by_aql("random AQL fragment") }.to raise_error(Guacamole::AQLNotSupportedError)
-    end
+  it 'should allow a custom RETURN statement' do
+    custom_color = 'fancy white pink with sparkles'
+    pony_by_name = PoniesCollection.by_aql('FILTER pony.name == @name',
+                                           { name: 'Candy Mane' },
+                                           return_as: %{RETURN MERGE(pony, {"color": "#{custom_color}"})}).first
+    expect(pony_by_name.color).to eq custom_color
   end
 
+  it 'should allow to disable the mapping' do
+    pony_hash = PoniesCollection.by_aql('FILTER pony.name == @name',
+                                        { name: 'Candy Mane' },
+                                        mapping: false).first
+    expect(pony_hash).to be_an(Ashikawa::Core::Document)
+  end
+
+  it 'should allow to provide a custom `FOR x IN y` part' do
+    pony_by_name = PoniesCollection.by_aql('FILTER p.name == @name',
+                                           { name: 'Candy Mane' },
+                                           for_in: 'FOR p IN ponies', return_as: 'RETURN p').first
+    expect(pony_by_name).to eq earth_pony
+  end
 end

data/spec/acceptance/relations_spec.rb

@@ -0,0 +1,239 @@
+# -*- encoding : utf-8 -*-
+require 'guacamole'
+require 'acceptance/spec_helper'
+
+require 'fabricators/book'
+require 'fabricators/author'
+
+class Authorship
+  include Guacamole::Edge
+
+  from :authors
+  to   :books
+end
+
+class BooksCollection
+  include Guacamole::Collection
+
+  map do
+    attribute :author, via: Authorship, inverse: true
+  end
+end
+
+class AuthorsCollection
+  include Guacamole::Collection
+
+  map do
+    attribute :books, via: Authorship
+  end
+end
+
+describe 'Graph based relations' do
+
+  context 'having a start vertex and multiple target vertices' do
+    context 'all are new' do
+      let(:suzanne_collins) { Fabricate.build(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate.build(:book, title: 'The Hunger Games') }
+      let(:catching_fire) { Fabricate.build(:book, title: 'Catching Fire') }
+      let(:mockingjay) { Fabricate.build(:book, title: 'Mockingjay') }
+      let(:panem_trilogy) { [the_hunger_games, catching_fire, mockingjay] }
+
+      it 'should create the start, all targets and connect them' do
+        suzanne_collins.books = panem_trilogy
+        AuthorsCollection.save suzanne_collins
+
+        author = AuthorsCollection.by_key(suzanne_collins.key)
+
+        expect(author.books.map(&:title)).to match_array panem_trilogy.map(&:title)
+      end
+    end
+
+    context 'one target is new' do
+      let(:suzanne_collins) { Fabricate.build(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+      let(:catching_fire) { Fabricate(:book, title: 'Catching Fire') }
+      let(:mockingjay) { Fabricate.build(:book, title: 'Mockingjay') }
+      let(:panem_trilogy) { [the_hunger_games, catching_fire, mockingjay] }
+
+      it 'should create the start, the new target and connect both the new and existing ones' do
+        suzanne_collins.books = panem_trilogy
+        AuthorsCollection.save suzanne_collins
+
+        author = AuthorsCollection.by_key(suzanne_collins.key)
+
+        expect(author.books.map(&:title)).to match_array panem_trilogy.map(&:title)
+      end
+    end
+
+    context 'existing start gets another target' do
+      let(:suzanne_collins) { Fabricate(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+      let(:catching_fire) { Fabricate(:book, title: 'Catching Fire') }
+      let(:mockingjay) { Fabricate.build(:book, title: 'Mockingjay') }
+      let(:panem_trilogy) { [the_hunger_games, catching_fire, mockingjay] }
+
+      before do
+        suzanne_collins.books = [the_hunger_games, catching_fire]
+        AuthorsCollection.save suzanne_collins
+      end
+
+      it 'should save the new target and connect it to the start' do
+        suzanne_collins.books << mockingjay
+        AuthorsCollection.save suzanne_collins
+
+        author = AuthorsCollection.by_key(suzanne_collins.key)
+
+        expect(author.books.map(&:title)).to match_array panem_trilogy.map(&:title)
+      end
+    end
+
+    context 'new connection between existing start and existing target' do
+      let(:suzanne_collins) { Fabricate(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+      let(:catching_fire) { Fabricate(:book, title: 'Catching Fire') }
+      let(:mockingjay) { Fabricate(:book, title: 'Mockingjay') }
+      let(:panem_trilogy) { [the_hunger_games, catching_fire, mockingjay] }
+
+      before do
+        suzanne_collins.books = [the_hunger_games, catching_fire]
+        AuthorsCollection.save suzanne_collins
+      end
+
+      it 'should just add a connection between start and target' do
+        suzanne_collins.books << mockingjay
+        AuthorsCollection.save suzanne_collins
+
+        author = AuthorsCollection.by_key(suzanne_collins.key)
+
+        expect(author.books.map(&:title)).to match_array panem_trilogy.map(&:title)
+      end
+    end
+
+    context 'remove an existing connection' do
+      let(:suzanne_collins) { Fabricate(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+      let(:catching_fire) { Fabricate(:book, title: 'Catching Fire') }
+      let(:mockingjay) { Fabricate(:book, title: 'Mockingjay') }
+      let(:deathly_hallows) { Fabricate(:book, title: 'Deathly Hallows') }
+      let(:panem_trilogy) { [the_hunger_games, catching_fire, mockingjay] }
+
+      let(:authorships_count) { -> { AuthorshipsCollection.by_example(_from: suzanne_collins._id).count } }
+
+      before do
+        suzanne_collins.books = [the_hunger_games, catching_fire, mockingjay, deathly_hallows]
+        AuthorsCollection.save suzanne_collins
+      end
+
+      it 'should remove the edge' do
+        suzanne_collins.books.pop
+
+        expect { AuthorsCollection.save suzanne_collins }.to change(&authorships_count).by -1
+      end
+
+      it 'should not remove the target vertex' do
+        suzanne_collins.books.pop
+
+        AuthorsCollection.save suzanne_collins
+
+        expect(BooksCollection.by_key(deathly_hallows.key)).not_to be_nil
+      end
+
+      context 'removing the target' do
+        # This is just a sanity check at this point since it is handled by ArangoDB itself
+        it 'should remove the edge too' do
+          expect { BooksCollection.delete(deathly_hallows) }.to change(&authorships_count).by -1
+        end
+      end
+    end
+
+    context 'remove one target should remove the edge too' do
+      let(:suzanne_collins) { Fabricate(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+      let(:catching_fire) { Fabricate(:book, title: 'Catching Fire') }
+      let(:mockingjay) { Fabricate(:book, title: 'Mockingjay') }
+      let(:deathly_hallows) { Fabricate(:book, title: 'Deathly Hallows') }
+      let(:panem_trilogy) { [the_hunger_games, catching_fire, mockingjay] }
+
+      let(:authorships_count) { -> { AuthorshipsCollection.by_example(_from: suzanne_collins._id).count } }
+
+      before do
+        suzanne_collins.books = [the_hunger_games, catching_fire, mockingjay, deathly_hallows]
+        AuthorsCollection.save suzanne_collins
+      end
+    end
+  end
+
+  context 'having the target vertex and one target' do
+    context 'all are new' do
+      let(:suzanne_collins) { Fabricate.build(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate.build(:book, title: 'The Hunger Games') }
+
+      it 'should create the target, the start and connects them' do
+        the_hunger_games.author = suzanne_collins
+        BooksCollection.save the_hunger_games
+
+        book = BooksCollection.by_key the_hunger_games.key
+
+        expect(book.author.name).to eq suzanne_collins.name
+      end
+    end
+
+    context 'the target is new' do
+      let(:suzanne_collins) { Fabricate.build(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+
+      it 'should create the start and make the connection' do
+        the_hunger_games.author = suzanne_collins
+        BooksCollection.save the_hunger_games
+
+        book = BooksCollection.by_key the_hunger_games.key
+
+        expect(book.author.name).to eq suzanne_collins.name
+      end
+    end
+
+    context 'existing target gets another start' do
+      let(:jk_rowling) { Fabricate.build(:author, name: 'J.K. Rowling') }
+      let(:suzanne_collins) { Fabricate.build(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+
+      before do
+        the_hunger_games.author = jk_rowling
+        BooksCollection.save the_hunger_games
+      end
+
+      it 'should create the new target and connect it with the start' do
+        the_hunger_games.author = suzanne_collins
+        BooksCollection.save the_hunger_games
+
+        book = BooksCollection.by_key the_hunger_games.key
+
+        expect(book.author.name).to eq suzanne_collins.name
+      end
+    end
+
+    context 'new connection between existing start and existing target' do
+      let(:suzanne_collins) { Fabricate(:author, name: 'Suzanne Collins') }
+
+      let(:the_hunger_games) { Fabricate(:book, title: 'The Hunger Games') }
+
+      it 'should just connect the target with the start' do
+        the_hunger_games.author = suzanne_collins
+        BooksCollection.save the_hunger_games
+
+        book = BooksCollection.by_key the_hunger_games.key
+
+        expect(book.author.name).to eq suzanne_collins.name
+      end
+    end
+  end
+end

data/spec/acceptance/spec_helper.rb

@@ -37,9 +37,9 @@ ENV['GUACAMOLE_ENV'] = 'test'
 Guacamole.configure do |config|
   logger = Logging.logger['guacamole_logger']
   logger.add_appenders(
-      Logging.appenders.file('log/acceptance.log')
+      Logging.appenders.file(File.join(__dir__, '..', '..', 'log/acceptance.log'))
   )
-  logger.level = :info
+  logger.level = :debug
 
   config.logger = logger
 

data/spec/fabricators/author_fabricator.rb

@@ -1,5 +1,7 @@
 # -*- encoding: utf-8 -*-
 
+Fabricator(:author)
+
 Fabricator(:author_with_three_books, from: :author) do
   name 'Star Swirl the Bearded'
 

data/spec/setup/arangodb.sh

@@ -7,8 +7,8 @@ NAME=ArangoDB-$VERSION
 
 if [ ! -d "$DIR/$NAME" ]; then
   # download ArangoDB
-  echo "wget http://www.arangodb.org/repositories/travisCI/$NAME.tar.gz"
-  wget http://www.arangodb.org/repositories/travisCI/$NAME.tar.gz
+  echo "wget http://www.arangodb.com/repositories/travisCI/$NAME.tar.gz"
+  wget --no-check-certificate http://www.arangodb.com/repositories/travisCI/$NAME.tar.gz
   echo "tar zxf $NAME.tar.gz"
   tar zvxf $NAME.tar.gz
   mv `find . -type d -name "ArangoDB-*"` $NAME

data/spec/unit/collection_spec.rb

@@ -69,16 +69,31 @@ describe Guacamole::Collection do
     end
   end
 
+  describe 'graph' do
+    before do
+      subject.graph = nil
+    end
+
+    it 'should default to Guacamole.configuration.graph' do
+      default_graph = double('Graph')
+      configuration = double('Configuration', graph: default_graph)
+      allow(Guacamole).to receive(:configuration).and_return(configuration)
+
+      expect(subject.graph).to eq default_graph
+    end
+  end
+
   describe 'connection' do
+    let(:graph) { double('Graph') }
+    let(:vertex_collection) { double('VertexCollection') }
+
     before do
       subject.connection = nil
+      allow(subject).to receive(:graph).and_return(graph)
     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)
+    it 'should be fetched through the #graph and default to "collection_name"' do
+      expect(graph).to receive(:add_vertex_collection).with(subject.collection_name)
 
       subject.connection
     end
@@ -125,11 +140,8 @@ describe Guacamole::Collection do
   end
 
   describe 'save' do
-
     before do
       allow(mapper).to receive(:model_to_document).with(model).and_return(document)
-      allow(mapper).to receive(:referenced_by_models).and_return([])
-      allow(mapper).to receive(:referenced_models).and_return([])
     end
 
     let(:key)       { double('Key') }
@@ -139,7 +151,6 @@ describe Guacamole::Collection do
     let(:response)  { double('Hash') }
 
     context 'a valid model' do
-
       before do
         allow(model).to receive(:valid?).and_return(true)
         allow(connection).to receive(:create_document).with(document).and_return(document)
@@ -171,7 +182,6 @@ describe Guacamole::Collection do
       end
 
       context 'which is persisted' do
-
         before do
           allow(model).to receive(:persisted?).and_return(true)
           allow(connection).to receive(:replace).and_return(response)
@@ -207,7 +217,6 @@ describe Guacamole::Collection do
     end
 
     context 'an invalid model' do
-
       before do
         expect(model).to receive(:valid?).and_return(false)
       end
@@ -266,12 +275,9 @@ describe Guacamole::Collection do
   end
 
   describe 'create' 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)
-      allow(mapper).to receive(:referenced_by_models).and_return([])
-      allow(mapper).to receive(:referenced_models).and_return([])
     end
 
     let(:key)       { double('Key') }
@@ -319,92 +325,9 @@ describe Guacamole::Collection do
 
         subject.create model
       end
-
-      context 'with referenced model' do
-        let(:referenced_model)                { double('ReferencedModel') }
-        let(:referenced_model_name)           { :some_referenced_model }
-        let(:referenced_models)               { [referenced_model_name] }
-        let(:collection_for_referenced_model) { double('Collection') }
-
-        before do
-          allow(referenced_model).to receive(:persisted?).and_return(false)
-          allow(mapper).to receive(:collection_for)
-            .with(referenced_model_name)
-            .and_return(collection_for_referenced_model)
-          allow(mapper).to receive(:referenced_models).and_return(referenced_models)
-          allow(model).to receive(:send).with(referenced_model_name).and_return(referenced_model)
-          allow(collection_for_referenced_model).to receive(:save).with(referenced_model)
-        end
-
-        it 'should save each referenced model' do
-          expect(collection_for_referenced_model).to receive(:save).with(referenced_model)
-
-          subject.create model
-        end
-
-        it 'should save the reference only if it is not already persisted' do
-          allow(referenced_model).to receive(:persisted?).and_return(true)
-          expect(collection_for_referenced_model).not_to receive(:save).with(referenced_model)
-
-          subject.create model
-        end
-
-        it 'should save the reference only if it is present' do
-          allow(model).to receive(:send).with(:some_referenced_model).and_return(nil)
-          expect(collection_for_referenced_model).not_to receive(:save).with(referenced_model)
-
-          subject.create model
-        end
-      end
-
-      context 'with referenced_by model' do
-        let(:referenced_by_model)                { double('ReferencedByModel') }
-        let(:referenced_by_model_name)           { :some_referenced_by_model }
-        let(:referenced_by_models)               { [referenced_by_model_name] }
-        let(:collection_for_referenced_by_model) { double('Collection') }
-
-        before do
-          allow(referenced_by_model).to receive(:persisted?).and_return(false)
-          allow(referenced_by_model).to receive("#{model.class.name.demodulize.underscore}=").with(model)
-          allow(mapper).to receive(:collection_for)
-            .with(referenced_by_model_name)
-            .and_return(collection_for_referenced_by_model)
-          allow(mapper).to receive(:referenced_by_models).and_return(referenced_by_models)
-          allow(model).to receive(:send).with(referenced_by_model_name).and_return([referenced_by_model])
-          allow(collection_for_referenced_by_model).to receive(:save).with(referenced_by_model)
-        end
-
-        it 'should save the references' do
-          expect(collection_for_referenced_by_model).to receive(:save).with(referenced_by_model)
-
-          subject.create model
-        end
-
-        it 'should save the references only if it is not already persisted' do
-          allow(referenced_by_model).to receive(:persisted?).and_return(true)
-          expect(collection_for_referenced_by_model).not_to receive(:save).with(referenced_by_model)
-
-          subject.create model
-        end
-
-        it 'should save the references only if it is present' do
-          allow(model).to receive(:send).with(referenced_by_model_name).and_return([])
-          expect(collection_for_referenced_by_model).not_to receive(:save).with(referenced_by_model)
-
-          subject.create model
-        end
-
-        it 'should ensure the references have the parent model assigned prior saving' do
-          expect(referenced_by_model).to receive("#{model.class.name.demodulize.underscore}=").with(model).ordered
-          expect(collection_for_referenced_by_model).to receive(:save).with(referenced_by_model).ordered
-
-          subject.create model
-        end
-      end
     end
 
     context 'an invalid model' do
-
       before do
         expect(model).to receive(:valid?).and_return(false)
       end