ashikawa-core 0.12.0 → 0.13.0

data/spec/unit/connection_spec.rb

@@ -21,6 +21,19 @@ describe Ashikawa::Core::Connection do
     end
   end
 
+  it 'should include include the x-arango-version header in each request' do
+    [:get, :post, :put, :delete].each do |http_verb|
+      request_stub.send(http_verb, '/_db/_system/_api/my/path') do |request|
+        expect(request[:request_headers][:'X-Arango-Version']).to eq '20200'
+        [200, response_headers, JSON.generate({ 'name' => 'dude' })]
+      end
+
+      subject.send_request 'my/path', http_verb => {}
+
+      request_stub.verify_stubbed_calls
+    end
+  end
+
   it 'should send a get request' do
     request_stub.get('/_db/_system/_api/my/path') do
       [200, response_headers, JSON.generate({ 'name' => 'dude' })]
@@ -205,6 +218,40 @@ describe Ashikawa::Core::Connection do
       request_stub.verify_stubbed_calls
     end
 
+    context 'handle 404 in the gharial module' do
+      let(:request_url) { '/_db/_system/_api/gharial/vertex/42' }
+
+      it 'should raise GraphNotFoundException if the graph could not be found' do
+        request_stub.get(request_url) do
+          [404, response_headers, { 'errorMessage' => 'graph not found' }]
+        end
+
+        expect { subject.send_request 'gharial/vertex/42' }.to raise_error(Ashikawa::Core::GraphNotFoundException)
+
+        request_stub.verify_stubbed_calls
+      end
+
+      it 'should raise CollectionNotFoundException the collection could not be found' do
+        request_stub.get(request_url) do
+          [404, response_headers, { 'errorMessage' => 'collection not found' }]
+        end
+
+        expect { subject.send_request 'gharial/vertex/42' }.to raise_error(Ashikawa::Core::CollectionNotFoundException)
+
+        request_stub.verify_stubbed_calls
+      end
+
+      it 'should raise DocumentNotFoundException the document could not be found' do
+        request_stub.get(request_url) do
+          [404, response_headers, { 'errorMessage' => 'document not found' }]
+        end
+
+        expect { subject.send_request 'gharial/vertex/42' }.to raise_error(Ashikawa::Core::DocumentNotFoundException)
+
+        request_stub.verify_stubbed_calls
+      end
+    end
+
     it 'should raise an exception for unknown pathes' do
       request_stub.get('/_db/_system/_api/unknown_path/4590/333') do
         [404, response_headers, '']

data/spec/unit/database_spec.rb

@@ -208,5 +208,116 @@ describe Ashikawa::Core::Database do
 
       expect(subject.create_transaction(js_function, collections)).to be(transaction)
     end
+
+    context 'managing graphs' do
+      let(:raw_graph) { double('RawGraph') }
+      let(:gharial_response) { double('GharialResponse') }
+      let(:graph)     { instance_double(Ashikawa::Core::Graph) }
+
+      before do
+        allow(gharial_response).to receive(:[]).with('graph').and_return(raw_graph)
+      end
+
+      it 'should fetch a single graph if it exists' do
+        expect(connection).to receive(:send_request)
+          .with('gharial/my_awesome_graph')
+          .and_return(gharial_response)
+
+        expect(Ashikawa::Core::Graph).to receive(:new)
+          .with(subject, raw_graph)
+          .and_return(graph)
+
+        expect(subject.graph('my_awesome_graph')).to eq graph
+      end
+
+      it "should create a single graph if it doesn't exist" do
+        expect(connection).to receive(:send_request).with('gharial/my_awesome_graph') do
+          raise Ashikawa::Core::GraphNotFoundException
+        end
+
+        expect(subject).to receive(:create_graph).with('my_awesome_graph').and_return(graph)
+
+        expect(subject.graph('my_awesome_graph')).to eq graph
+      end
+
+      it 'should create a graph' do
+        expect(connection).to receive(:send_request)
+          .with('gharial', post: { name: 'my_awesome_graph' })
+          .and_return(gharial_response)
+
+        expect(Ashikawa::Core::Graph).to receive(:new)
+          .with(subject, raw_graph)
+          .and_return(graph)
+
+        expect(subject.create_graph('my_awesome_graph')).to eq graph
+      end
+
+      it 'should create a single graph with list of edge_definitions' do
+        create_params = {
+          name: 'my_awesome_graph',
+          edgeDefinitions: [
+            { collection: 'visited', from: ['ponies'], to: ['places'] }
+          ]
+        }
+        expect(connection).to receive(:send_request)
+          .with('gharial', post: create_params)
+          .and_return(gharial_response)
+
+        expect(Ashikawa::Core::Graph).to receive(:new)
+          .with(subject, raw_graph)
+          .and_return(graph)
+
+        options = {
+          edge_definitions: [
+            {
+              collection: 'visited',
+              from: ['ponies'],
+              to: ['places']
+            }
+          ]
+        }
+
+        expect(subject.create_graph('my_awesome_graph', options)).to eq graph
+      end
+
+      it 'should create a single graph with list of orphan_collections' do
+        create_params = {
+          name: 'my_awesome_graph',
+          orphanCollections: ['i_am_alone']
+        }
+        expect(connection).to receive(:send_request)
+          .with('gharial', post: create_params)
+          .and_return(gharial_response)
+
+        expect(Ashikawa::Core::Graph).to receive(:new)
+          .with(subject, raw_graph)
+          .and_return(graph)
+
+        options = {
+          orphan_collections: ['i_am_alone']
+        }
+
+        expect(subject.create_graph('my_awesome_graph', options)).to eq graph
+
+      end
+
+      it 'should fetch a list of all graphs in the database' do
+        raw_list_of_graphs = double('ListOfGraphs')
+        allow(raw_list_of_graphs).to receive(:[])
+          .with('graphs')
+          .and_return([raw_graph])
+
+        expect(connection).to receive(:send_request)
+          .with('gharial')
+          .and_return(raw_list_of_graphs)
+
+        expect(Ashikawa::Core::Graph).to receive(:new)
+          .with(subject, raw_graph)
+          .and_return(graph)
+
+        expect(subject.graphs).to eq [graph]
+      end
+    end
+
   end
 end

data/spec/unit/document_spec.rb

@@ -57,6 +57,22 @@ describe Ashikawa::Core::Document do
     end
   end
 
+  describe 'initialized with a garaph' do
+    let(:graph) { double('Ashikawa::Core::Graph', name: 'my-graph') }
+    let(:additional_data_with_graph) { { graph: graph, more_info: more_info } }
+    subject { Ashikawa::Core::Document.new(database, raw_data, additional_data_with_graph) }
+
+    its(['more_info']) { should eq(more_info) }
+    its(:graph) { should eq(graph) }
+
+    it 'should send requests through the graph module' do
+      expect(database).to receive(:send_request)
+        .with("gharial/my-graph/vertex/#{id}", {})
+
+      subject.send(:send_request_for_document, {})
+    end
+  end
+
   describe 'initialized document with ID' do
     subject { Ashikawa::Core::Document.new(database, raw_data) }
 

data/spec/unit/edge_collection_spec.rb

@@ -0,0 +1,105 @@
+# -*- encoding : utf-8 -*-
+require 'unit/spec_helper'
+require 'ashikawa-core/edge_collection'
+require 'ashikawa-core/document'
+require 'ashikawa-core/graph'
+require 'ashikawa-core/database'
+
+describe Ashikawa::Core::EdgeCollection do
+  let(:database) { instance_double('Ashikawa::Core::Database') }
+  let(:raw_collection) do
+    {
+      'id' => '60768679',
+      'name' => 'relation',
+      'status' => 3,
+      'type' => 3,
+      'error' => false,
+      'code' => 200
+    }
+  end
+  let(:graph) { instance_double('Ashikawa::Core::Graph', name: 'my_graph') }
+  let(:new_edge) { instance_double('Ashikawa::Core::Edge') }
+  let(:raw_edge) { double('RawEdge') }
+  let(:post_response) { { 'edge' => { '_key' => '123' } } }
+
+  context 'an initialized edge collection' do
+    subject { Ashikawa::Core::EdgeCollection.new(database, raw_collection, graph) }
+
+    it 'should be a subclass of Collection' do
+      expect(subject).to be_kind_of Ashikawa::Core::Collection
+    end
+
+    it 'should have a reference to its graph' do
+      expect(subject.graph).to eq graph
+    end
+
+    context 'adding edges' do
+      let(:this_document) { instance_double('Ashikawa::Core::Document', id: 'this_document_id') }
+      let(:that_document) { instance_double('Ashikawa::Core::Document', id: 'that_document_id') }
+
+      before do
+        allow(subject).to receive(:send_request)
+          .with('gharial/my_graph/edge/relation/', post: { _from: 'this_document_id', _to: 'that_document_id' })
+          .and_return(post_response)
+
+        allow(subject).to receive(:fetch)
+          .with('123')
+          .and_return(new_edge)
+      end
+
+      it 'should add a directed relation between to vertices' do
+        expect(subject).to receive(:send_request)
+          .with('gharial/my_graph/edge/relation/', post: { _from: 'this_document_id', _to: 'that_document_id' })
+          .and_return(post_response)
+
+        subject.add(from: this_document, to: that_document)
+      end
+
+      it 'should return the edge documents' do
+        created_edges = subject.add(from: this_document, to: that_document)
+
+        expect(created_edges).to eq new_edge
+      end
+    end
+
+    context 'removing edges by example' do
+      let(:this_document) { instance_double('Ashikawa::Core::Document', id: 'this_document_id') }
+      let(:that_document) { instance_double('Ashikawa::Core::Document', id: 'that_document_id') }
+      let(:query)         { double('Query') }
+      let(:aql_string)    do
+        <<-AQL.gsub(/^[ \t]*/, '')
+        FOR e IN @@edge_collection
+          FILTER e._from == @from && e._to == @to
+          REMOVE e._key IN @@edge_collection
+        AQL
+      end
+      let(:bind_vars) { { :'@edge_collection' => 'relation', :from => 'this_document_id', :to => 'that_document_id' } }
+
+      before do
+        allow(database).to receive(:query).and_return(query)
+      end
+
+      it 'should remove the edges' do
+        expect(query).to receive(:execute)
+          .with(aql_string, bind_vars: bind_vars)
+
+        subject.remove(from: this_document, to: that_document)
+      end
+    end
+
+    it 'should overwrite #send_request_for_this_collection to use gharial' do
+      expect(subject).to receive(:send_request)
+        .with('gharial/my_graph/edge/relation/edge_key', {})
+
+      subject.send(:send_request_for_this_collection, 'edge_key')
+    end
+
+    it 'should overwrite the #build_content_class to create edges with the graph attached' do
+      expect(Ashikawa::Core::Edge).to receive(:new)
+        .with(database, raw_edge, graph: graph)
+        .and_return(new_edge)
+
+      subject.build_content_class(raw_edge)
+    end
+  end
+end

data/spec/unit/edge_spec.rb

@@ -55,6 +55,13 @@ describe Ashikawa::Core::Edge do
       subject['last_name'] = new_last_name
       subject.save
     end
+
+    it 'should send requests to the edge endpoint' do
+      expect(database).to receive(:send_request)
+        .with("edge/#{id}", {})
+
+      subject.send(:send_request_for_document, {})
+    end
   end
 
   describe 'initializing edge with additional data' do
@@ -63,5 +70,21 @@ describe Ashikawa::Core::Edge do
     subject { Ashikawa::Core::Edge.new(database, raw_data, additional_data) }
 
     its(['more_info']) { should eq(more_info) }
+
+    context 'initializing with a graph' do
+      let(:graph) { double('Ashikawa::Core::Graph', name: 'my-graph') }
+      let(:additional_data_with_graph) { { graph: graph,  more_info: more_info } }
+      subject { Ashikawa::Core::Edge.new(database, raw_data, additional_data_with_graph) }
+
+      its(['more_info']) { should eq(more_info) }
+      its(:graph) { should eq(graph) }
+
+      it 'should send requests through the graph module' do
+        expect(database).to receive(:send_request)
+          .with("gharial/my-graph/edge/#{id}", {})
+
+        subject.send(:send_request_for_document, {})
+      end
+    end
   end
 end

data/spec/unit/exception_spec.rb

@@ -1,4 +1,6 @@
 # -*- encoding : utf-8 -*-
+require 'unit/spec_helper'
+
 require 'ashikawa-core/exceptions/no_collection_provided'
 require 'ashikawa-core/exceptions/client_error'
 require 'ashikawa-core/exceptions/client_error/authentication_failed'
@@ -6,7 +8,9 @@ require 'ashikawa-core/exceptions/client_error/bad_syntax'
 require 'ashikawa-core/exceptions/client_error/resource_not_found'
 require 'ashikawa-core/exceptions/client_error/resource_not_found/document_not_found'
 require 'ashikawa-core/exceptions/client_error/resource_not_found/collection_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/collection_not_in_graph'
 require 'ashikawa-core/exceptions/client_error/resource_not_found/index_not_found'
+require 'ashikawa-core/exceptions/client_error/resource_not_found/graph_not_found'
 require 'ashikawa-core/exceptions/server_error'
 require 'ashikawa-core/exceptions/server_error/json_error'
 
@@ -48,6 +52,14 @@ describe Ashikawa::Core::IndexNotFoundException do
   its(:to_s) { should include 'does not exist' }
 end
 
+describe Ashikawa::Core::GraphNotFoundException do
+  its(:to_s) { should include 'does not exist' }
+end
+
+describe Ashikawa::Core::CollectionNotInGraphException do
+  its(:to_s) { should include 'not been added to the graph yet' }
+end
+
 describe Ashikawa::Core::ServerError do
   let(:error_message) { 'The server is misbehaving' }
   subject { Ashikawa::Core::ServerError.new(error_message) }

data/spec/unit/faraday_factory_spec.rb

@@ -11,6 +11,7 @@ describe Ashikawa::Core::FaradayFactory do
     before do
       allow(Faraday).to receive(:new).with(api_string).and_yield(config_block)
       allow(config_block).to receive(:request).with(:json)
+      allow(config_block).to receive(:request).with(:x_arango_version)
       allow(config_block).to receive(:response).with(:error_response)
       allow(config_block).to receive(:response).with(:json)
       allow(config_block).to receive(:adapter).with(Faraday.default_adapter)

data/spec/unit/graph_spec.rb

@@ -0,0 +1,270 @@
+# -*- encoding : utf-8 -*-
+require 'unit/spec_helper'
+require 'ashikawa-core/graph'
+require 'ashikawa-core/document'
+require 'ashikawa-core/database'
+
+describe Ashikawa::Core::Graph do
+  let(:database) { instance_double('Ashikawa::Core::Database') }
+  let(:raw_graph) { double('RawGraph').as_null_object }
+  let(:edge_definition) do
+    {
+      'collection' => 'friends',
+      'from'       => %w(ponies),
+      'to'         => %w(dragons ponies)
+    }
+  end
+
+  def collection_double(name)
+    instance_double('Ashikawa::Core::VertexCollection', name: name.to_s)
+  end
+
+  def edge_collection_double(name)
+    instance_double('Ashikawa::Core::EdgeCollection', name: name.to_s)
+  end
+
+  context 'an initialized graph' do
+    subject { Ashikawa::Core::Graph.new(database, raw_graph) }
+
+    before do
+      allow(raw_graph).to receive(:[]).with('name').and_return('my_graph')
+      allow(raw_graph).to receive(:[]).with('_rev').and_return('A113')
+      allow(raw_graph).to receive(:fetch).with('orphanCollections').and_return(['orphan'])
+      allow(raw_graph).to receive(:fetch).with('edgeDefinitions').and_return([edge_definition])
+    end
+
+    its(:database) { should eq database }
+    its(:name) { should eq 'my_graph' }
+    its(:revision) { should eq 'A113' }
+    its(:edge_definitions) { should eq [edge_definition] }
+
+    it 'should delegate send_request to the database' do
+      expect(database).to receive(:send_request).with('gharial/my_graph')
+
+      subject.send_request 'gharial/my_graph'
+    end
+
+    it 'should extract the name from the _key if no name was provided' do
+      allow(raw_graph).to receive(:[]).with('name').and_return(nil)
+      allow(raw_graph).to receive(:[]).with('_key').and_return('my_graph')
+      expect(subject.name).to eq 'my_graph'
+    end
+
+    context 'finding neighbors' do
+      let(:some_document) { instance_double('Ashikawa::Core::Document', key: 'somekey') }
+      let(:query)         { double('Query') }
+      let(:cursor)        { double('Cursor') }
+
+      before do
+        allow(database).to receive(:query).and_return(query)
+      end
+
+      it 'should return the cursor for the query' do
+        allow(query).to receive(:execute)
+          .and_return(cursor)
+
+        expect(subject.neighbors(some_document)).to eq cursor
+      end
+
+      it 'should run a neighbors AQL for all edge collections' do
+        aql_string = <<-AQL.gsub(/^[ \t]*/, '')
+        FOR n IN GRAPH_NEIGHBORS(@graph, { _key:@vertex_key }, {})
+          RETURN n.vertex
+        AQL
+        bind_vars = { graph: 'my_graph', vertex_key: 'somekey' }
+
+        expect(query).to receive(:execute)
+          .with(aql_string, bind_vars: bind_vars)
+
+        subject.neighbors(some_document)
+      end
+
+      it 'should run a neighbors AQL for a specific edge collection' do
+        aql_string = <<-AQL.gsub(/^[ \t]*/, '')
+        FOR n IN GRAPH_NEIGHBORS(@graph, { _key:@vertex_key }, {edgeCollectionRestriction: @edge_collection})
+          RETURN n.vertex
+        AQL
+        bind_vars = { edge_collection: ['my-edges'], graph: 'my_graph', vertex_key: 'somekey' }
+
+        expect(query).to receive(:execute)
+          .with(aql_string, bind_vars: bind_vars)
+
+        subject.neighbors(some_document, edges: ['my-edges'])
+      end
+    end
+
+    context 'delete the graph' do
+      it 'should delete just the graph' do
+        expect(database).to receive(:send_request).with('gharial/my_graph', delete: { dropCollections: false })
+
+        subject.delete
+      end
+
+      it 'should delete the graph including all collections' do
+        expect(database).to receive(:send_request).with('gharial/my_graph', delete: { dropCollections: true })
+
+        subject.delete(drop_collections: true)
+      end
+    end
+
+    context 'vertex collections' do
+      let(:raw_vertex_collection) { double('RawVertexCollection') }
+
+      its(:vertex_collection_names) { should match_array %w(ponies dragons orphan) }
+
+      it 'should have a list of vertex collections' do
+        expected_vertex_collection = [
+          collection_double(:ponies),
+          collection_double(:orphan),
+          collection_double(:dragons)
+        ]
+        allow(subject).to receive(:vertex_collection).and_return(*expected_vertex_collection)
+
+        expect(subject.vertex_collections).to match_array expected_vertex_collection
+      end
+
+      it 'should know if a collection has already been added to the list of vertices' do
+        allow(subject).to receive(:vertex_collection_names).and_return(['ponies'])
+
+        expect(subject.has_vertex_collection?('dragons')).to be_falsy
+        expect(subject.has_vertex_collection?('ponies')).to be_truthy
+      end
+
+      context 'fetching a single collection' do
+        let(:existing_vertex_collection) { instance_double('Ashikawa::Core::VertexCollection') }
+
+        before do
+          allow(database).to receive(:send_request)
+            .with('collection/places')
+            .and_return(raw_vertex_collection)
+
+          allow(Ashikawa::Core::VertexCollection).to receive(:new)
+            .with(database, raw_vertex_collection, subject)
+            .and_return(existing_vertex_collection)
+        end
+
+        it 'should get a single vertex collection' do
+          places_collection = subject.vertex_collection 'places'
+          expect(places_collection).to eq existing_vertex_collection
+        end
+      end
+
+      context 'adding a collection' do
+        let(:updated_raw_graph) { double('UpdatedRawGraph') }
+        let(:new_vertex_collection) { instance_double('Ashikawa::Core::VertexCollection') }
+
+        before do
+          allow(updated_raw_graph).to receive(:[]).with('name').and_return('my_graph')
+          allow(updated_raw_graph).to receive(:[]).with('_rev')
+          allow(updated_raw_graph).to receive(:fetch).with('orphanCollections').and_return(['books'])
+          allow(updated_raw_graph).to receive(:fetch).with('edgeDefinitions').and_return([edge_definition])
+
+          allow(database).to receive(:send_request)
+            .with('gharial/my_graph/vertex', post: { collection: 'books' })
+            .and_return({ 'graph' => updated_raw_graph })
+
+          allow(database).to receive(:send_request)
+            .with('collection/books')
+            .and_return(raw_vertex_collection)
+
+          allow(Ashikawa::Core::VertexCollection).to receive(:new)
+            .with(database, raw_vertex_collection, subject)
+            .and_return(new_vertex_collection)
+        end
+
+        it 'should add the new collection to the vertex collections of the graph' do
+          books_collection = collection_double(:books)
+          allow(subject).to receive(:vertex_collection).and_return(books_collection)
+
+          subject.add_vertex_collection 'books'
+
+          expect(subject.vertex_collections).to include books_collection
+        end
+
+        it 'should return the newly created collection' do
+          expect(subject.add_vertex_collection('books')).to eq new_vertex_collection
+        end
+      end
+    end
+
+    context 'edge collections' do
+      let(:raw_edge_collection) { double('RawEdgeCollection') }
+
+      its(:edge_collection_names) { should match_array %w(friends) }
+
+      it 'should have a list of edge collections' do
+        expected_edge_collections = [edge_collection_double(:friends)]
+        allow(subject).to receive(:edge_collection).and_return(*expected_edge_collections)
+
+        expect(subject.edge_collections).to match_array expected_edge_collections
+      end
+
+      context 'fetching a single edge collections' do
+        let(:existing_edge_collection) { instance_double('Ashikawa::Core::EdgeCollection') }
+
+        before do
+          allow(database).to receive(:send_request)
+            .with('collection/friends')
+            .and_return(raw_edge_collection)
+
+          allow(Ashikawa::Core::EdgeCollection).to receive(:new)
+            .with(database, raw_edge_collection, subject)
+            .and_return(existing_edge_collection)
+        end
+
+        it 'should return a single edge collection' do
+          friends_colection = subject.edge_collection :friends
+          expect(friends_colection).to eq existing_edge_collection
+        end
+      end
+
+      context 'adding a definition' do
+        let(:updated_raw_graph) { double('UpdatedRawGraph') }
+        let(:new_edge_collection) { instance_double('Ashikawa::Core::EdgeCollection') }
+        let(:new_edge_definition) do
+          {
+            'collection' => 'authorship',
+            'from'       => ['author'],
+            'to'         => ['books']
+          }
+        end
+
+        before do
+          allow(updated_raw_graph).to receive(:[]).with('name').and_return('my_graph')
+          allow(updated_raw_graph).to receive(:[]).with('_rev')
+          allow(updated_raw_graph).to receive(:fetch).with('orphanCollections').and_return(['orphans'])
+          allow(updated_raw_graph).to receive(:fetch).with('edgeDefinitions').and_return([edge_definition])
+
+          allow(database).to receive(:send_request)
+            .with('gharial/my_graph/edge', post: { collection: :authorship, from: [:author], to: [:books] })
+            .and_return({ 'graph' => updated_raw_graph })
+
+          allow(subject).to receive(:edge_collection).and_return(new_edge_collection)
+        end
+
+        it 'should define the name and direction' do
+          expect(database).to receive(:send_request)
+            .with('gharial/my_graph/edge', post: { collection: :authorship, from: [:author], to: [:books] })
+            .and_return({ 'graph' => updated_raw_graph })
+
+          subject.add_edge_definition(:authorship, from: [:author], to: [:books])
+        end
+
+        it 'should add the definition to the collection edge collections' do
+          allow(updated_raw_graph).to receive(:fetch).with('edgeDefinitions').and_return([
+            edge_definition,
+            new_edge_definition
+          ])
+
+          subject.add_edge_definition(:authorship, from: [:author], to: [:books])
+
+          expect(subject.edge_collections).to include new_edge_collection
+        end
+
+        it 'should return the edge collection' do
+          expect(subject.add_edge_definition(:authorship, from: [:author], to: [:books])).to eq new_edge_collection
+        end
+      end
+    end
+  end
+end