neography 1.3.14 → 1.4.0

data/lib/neography/rest/relationship_properties.rb

@@ -1,10 +1,51 @@
 module Neography
   class Rest
-    class RelationshipProperties < Properties
-      extend Neography::Rest::Paths
+    module RelationshipProperties
+    
+      def set_relationship_properties(id, properties)
+        properties.each do |property, value|
+          options = { :body => value.to_json, :headers => json_content_type }
+          @connection.put("/relationship/%{id}/properties/%{property}" % {:id => get_id(id), :property => property}, options)
+        end
+      end
+
+      def reset_relationship_properties(id, properties)
+        options = { :body => properties.to_json, :headers => json_content_type }
+        @connection.put("/relationship/%{id}/properties" % {:id => get_id(id)}, options)
+      end
+
+      def get_relationship_properties(id, *properties)
+        if properties.none?
+          @connection.get("/relationship/%{id}/properties" % {:id => get_id(id)})
+        else
+          get_each_relationship_properties(id, *properties)
+        end
+      end
+
+      def get_each_relationship_properties(id, *properties)
+        retrieved_properties = properties.flatten.inject({}) do |memo, property|
+          value = @connection.get("/relationship/%{id}/properties/%{property}" % {:id => get_id(id), :property => property})
+          memo[property] = value unless value.nil?
+          memo
+        end
+        return nil if retrieved_properties.empty?
+        retrieved_properties
+      end
+
+      def remove_relationship_properties(id, *properties)
+        if properties.none?
+          @connection.delete("/relationship/%{id}/properties" % {:id => get_id(id)})
+        else
+          remove_each_relationship_properties(id, *properties)
+        end
+      end
+
+      def remove_each_relationship_properties(id, *properties)
+        properties.flatten.each do |property|
+          @connection.delete("/relationship/%{id}/properties/%{property}" % {:id => get_id(id), :property => property})
+        end
+      end
 
-      add_path :all,    "/relationship/:id/properties"
-      add_path :single, "/relationship/:id/properties/:property"
 
     end
   end

data/lib/neography/rest/relationship_types.rb

@@ -1,16 +1,9 @@
 module Neography
   class Rest
-    class RelationshipTypes
-      extend Neography::Rest::Paths
-
-      add_path :all,    "/relationship/types"
-      
-      def initialize(connection)
-        @connection ||= connection
-      end
-            
-      def list
-        @connection.get(all_path)
+    module RelationshipTypes
+                  
+      def list_relationship_types
+        @connection.get("/relationship/types")
       end
 
     end

data/lib/neography/rest/relationships.rb

@@ -1,21 +1,14 @@
 module Neography
   class Rest
-    class Relationships
-      extend Neography::Rest::Paths
+    module Relationships
       include Neography::Rest::Helpers
-
-      add_path :base,   "/relationship/:id"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def get(id)
-        @connection.get(base_path(:id => get_id(id)))
+        
+      def get_relationship(id)
+        @connection.get("/relationship/%{id}" % {:id => get_id(id)})
       end
 
-      def delete(id)
-        @connection.delete(base_path(:id => get_id(id)))
+      def delete_relationship(id)
+        @connection.delete("/relationship/%{id}" % {:id => get_id(id)})
       end
 
     end

data/lib/neography/rest/schema_indexes.rb

@@ -1,25 +1,17 @@
 module Neography
   class Rest
-    class SchemaIndexes
-      extend Neography::Rest::Paths
+    module SchemaIndexes
       include Neography::Rest::Helpers
-
-      add_path :base,      "/schema/index/:label"
-      add_path :drop,      "/schema/index/:label/:index"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def list(label)
-        @connection.get(base_path(:label => label))
+        
+      def get_schema_index(label)
+        @connection.get("/schema/index/%{label}" % {:label => label})
       end
 
-      def drop(label, index)
-        @connection.delete(drop_path(:label => label, :index => index))
+      def delete_schema_index(label, index)
+        @connection.delete("/schema/index/%{label}/%{index}" % {:label => label, :index => index})
       end
 
-      def create(label, keys = [])
+      def create_schema_index(label, keys = [])
         options = {
           :body => (
             { :property_keys => keys
@@ -27,7 +19,7 @@ module Neography
           ).to_json,
           :headers => json_content_type
         }
-        @connection.post(base_path(:label => label), options)
+        @connection.post("/schema/index/%{label}" % {:label => label}, options)
       end
     end
   end

data/lib/neography/rest/spatial.rb

@@ -1,30 +1,13 @@
 module Neography
   class Rest
-    class Spatial
-      extend Neography::Rest::Paths
+    module Spatial
       include Neography::Rest::Helpers
-
-      add_path :index,                          "/ext/SpatialPlugin"
-      add_path :add_simple_point_layer,         "/ext/SpatialPlugin/graphdb/addSimplePointLayer"
-      add_path :add_editable_layer,             "/ext/SpatialPlugin/graphdb/addEditableLayer"
-      add_path :get_layer,                      "/ext/SpatialPlugin/graphdb/getLayer"
-      add_path :add_geometry_to_layer,          "/ext/SpatialPlugin/graphdb/addGeometryWKTToLayer"
-      add_path :edit_geometry_from_layer,       "/ext/SpatialPlugin/graphdb/updateGeometryFromWKT"
-      add_path :add_node_to_layer,              "/ext/SpatialPlugin/graphdb/addNodeToLayer"
-      add_path :find_geometries_in_bbox,        "/ext/SpatialPlugin/graphdb/findGeometriesInBBox"
-      add_path :find_geometries_within_distance,"/ext/SpatialPlugin/graphdb/findGeometriesWithinDistance"
-      add_path :create_index,                   "/index/node"
-      add_path :add_to_index,                   "/index/node/:index"
-
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def index
-        @connection.get(index_path)
+    
+      def get_spatial
+        @connection.get("/ext/SpatialPlugin")
       end
 
-      def add_point_layer(layer, lat, lon)
+      def add_point_layer(layer, lat = nil, lon = nil)
         options = {
           :body => {
             :layer => layer,
@@ -34,7 +17,7 @@ module Neography
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
         
-        @connection.post(add_simple_point_layer_path, options)        
+        @connection.post("/ext/SpatialPlugin/graphdb/addSimplePointLayer", options)        
       end
 
       def add_editable_layer(layer, format = "WKT", node_property_name = "wkt")
@@ -47,7 +30,7 @@ module Neography
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
         
-        @connection.post(add_editable_layer_path, options)        
+        @connection.post("/ext/SpatialPlugin/graphdb/addEditableLayer", options)        
       end
 
       def get_layer(layer)
@@ -57,7 +40,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(get_layer_path, options)
+        @connection.post("/ext/SpatialPlugin/graphdb/getLayer", options)
       end
       
       def add_geometry_to_layer(layer, geometry)
@@ -68,7 +51,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(add_geometry_to_layer_path, options)
+        @connection.post("/ext/SpatialPlugin/graphdb/addGeometryWKTToLayer", options)
       end
 
       def edit_geometry_from_layer(layer, geometry, node)
@@ -80,7 +63,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(edit_geometry_from_layer_path, options)
+        @connection.post("/ext/SpatialPlugin/graphdb/updateGeometryFromWKT", options)
       end
 
       def add_node_to_layer(layer, node)
@@ -91,7 +74,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(add_node_to_layer_path, options)
+        @connection.post("/ext/SpatialPlugin/graphdb/addNodeToLayer", options)
       end
 
       def find_geometries_in_bbox(layer, minx, maxx, miny, maxy)
@@ -105,7 +88,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(find_geometries_in_bbox_path, options)
+        @connection.post("/ext/SpatialPlugin/graphdb/findGeometriesInBBox", options)
       end
 
       def find_geometries_within_distance(layer, pointx, pointy, distance)
@@ -118,10 +101,10 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(find_geometries_within_distance_path, options)
+        @connection.post("/ext/SpatialPlugin/graphdb/findGeometriesWithinDistance", options)
       end
       
-      def create_spatial_index(name, type, lat, lon)
+      def create_spatial_index(name, type = nil, lat = nil, lon = nil)
         options = {
           :body => {
             :name => name,
@@ -134,7 +117,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(create_index_path, options) 
+        @connection.post("/index/node", options) 
       end
 
       def add_node_to_spatial_index(index, id)
@@ -146,7 +129,7 @@ module Neography
           }.to_json,
           :headers => json_content_type.merge({'Accept' => 'application/json;charset=UTF-8'})
         }
-        @connection.post(add_to_index_path(:index => index), options)
+        @connection.post("/index/node/%{index}" % {:index => index}, options)
       end
 
     end

data/lib/neography/rest/transactions.rb

@@ -1,54 +1,53 @@
 module Neography
   class Rest
-    class Transactions
-      extend Neography::Rest::Paths
+    module Transactions
       include Neography::Rest::Helpers
-
-      add_path :base,   "/transaction"
-      add_path :tx,    "/transaction/:id"
-      add_path :commit, "/transaction/:id/commit"
-      
-      def initialize(connection)
-        @connection ||= connection
-      end
-
-      def begin(statements = [], commit = "")
+    
+      def begin_transaction(statements = [], commit = "")
         options = {
           :body => (
             convert_cypher(statements)
           ).to_json,
           :headers => json_content_type
         }
-        @connection.post(base_path + commit, options)
+        @connection.post("/transaction" + commit, options)
       end
 
-      def add(tx, statements = [])
+      def in_transaction(tx, statements = [])
         options = {
           :body => (
             convert_cypher(statements)
           ).to_json,
           :headers => json_content_type
         }
-        @connection.post(tx_path(:id => get_id(tx)), options)
+        @connection.post("/transaction/%{id}" % {:id => get_tx_id(tx)}, options)
+      end
+      
+      def keep_transaction(tx)
+        in_transaction(tx)
       end
 
-      def commit(tx, statements = [])
-        options = {
-          :body => (
-            convert_cypher(statements)
-          ).to_json,
-          :headers => json_content_type
-        }
-        @connection.post(commit_path(:id => get_id(tx)), options)
+      def commit_transaction(tx, statements = [])
+        if (tx.is_a?(Hash) || tx.is_a?(Integer))
+          options = {
+            :body => (
+              convert_cypher(statements)
+            ).to_json,
+            :headers => json_content_type
+          }
+          @connection.post("/transaction/%{id}/commit" %  {:id => get_tx_id(tx)}, options)
+        else
+          begin_transaction(tx, "/commit")
+        end
       end
       
-      def rollback(tx)
-        @connection.delete(tx_path(:id => get_id(tx)))
+      def rollback_transaction(tx)
+        @connection.delete("/transaction/%{id}" % {:id => get_tx_id(tx)})
       end
 
       private
       
-      def get_id(tx)
+      def get_tx_id(tx)
         return tx if tx.is_a?(Integer)
         return tx.split("/")[-2] if tx.is_a?(String)
         return tx["commit"].split("/")[-2] if tx["commit"]

data/lib/neography/tasks.rb

@@ -163,8 +163,8 @@ namespace :neo4j do
         df = File.open('neo4j-spatial.zip', 'wb')
         case args[:version]
           when "2.0.1"
-            dist = "dist.neo4j.org"
-            request = "/spatial/neo4j-spatial-0.12-neo4j-2.0.1-server-plugin.zip"
+            dist = "m2.neo4j.org"
+            request = "/content/repositories/releases/org/neo4j/neo4j-spatial/0.13-neo4j-2.0.1/neo4j-spatial-0.13-neo4j-2.0.1-server-plugin.zip"
           when "2.0.0"
             dist = "dist.neo4j.org"
             request = "/spatial/neo4j-spatial-0.12-neo4j-2.0.0-server-plugin.zip"

data/lib/neography/version.rb

@@ -1,3 +1,3 @@
 module Neography
-  VERSION = "1.3.14"
+  VERSION = "1.4.0"
 end

data/spec/unit/rest/batch_spec.rb

@@ -4,8 +4,7 @@ module Neography
   class Rest
     describe Batch do
 
-      let(:connection) { double(:gremlin_path => "/gremlin", :cypher_path => "/cypher") }
-      subject { Batch.new(connection) }
+      subject { Neography::Rest.new }
 
       it "gets nodes" do
         expected_body = [
@@ -13,8 +12,8 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/node/bar" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:get_node, "foo"], [:get_node, "bar"]
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:get_node, "foo"], [:get_node, "bar"]
       end
 
       it "creates nodes" do
@@ -23,8 +22,8 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/node", "body" => { "baz" => "qux" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:create_node, { "foo" => "bar" }], [:create_node, { "baz" => "qux" }]
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:create_node, { "foo" => "bar" }], [:create_node, { "baz" => "qux" }]
       end
 
       it "deletes nodes" do
@@ -33,8 +32,8 @@ module Neography
           { "id" => 1, "method" => "DELETE", "to" => "/node/bar" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:delete_node, "foo"], [:delete_node, "bar"]
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:delete_node, "foo"], [:delete_node, "bar"]
       end
 
       it "creates unique nodes" do
@@ -43,8 +42,8 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/node/quux?unique", "body" => { "key" => "corge", "value" => "grault", "properties" => "garply" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:create_unique_node, "foo", "bar", "baz", "qux" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:create_unique_node, "foo", "bar", "baz", "qux" ],
                         [:create_unique_node, "quux", "corge", "grault", "garply"]
       end
 
@@ -54,8 +53,8 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/node/quux", "body" => { "uri" => "{0}", "key" => "corge", "value" => "grault" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:add_node_to_index, "foo", "bar", "baz", "qux" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:add_node_to_index, "foo", "bar", "baz", "qux" ],
                         [:add_node_to_index, "quux", "corge", "grault", "{0}"]
       end
 
@@ -65,8 +64,8 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/index/node/qux/quux/corge" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:get_node_index, "foo", "bar", "baz" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:get_node_index, "foo", "bar", "baz" ],
                         [:get_node_index, "qux", "quux", "corge" ]
       end
 
@@ -77,8 +76,8 @@ module Neography
           { "id" => 2, "method" => "DELETE", "to" => "/index/node/index3/key3/value3/id3" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:remove_node_from_index, "index1", "id1", ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:remove_node_from_index, "index1", "id1", ],
                         [:remove_node_from_index, "index2", "key2", "id2" ],
                         [:remove_node_from_index, "index3", "key3", "value3", "id3" ]
       end
@@ -89,8 +88,8 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "/node/index2/properties/key2", "body" => "value2" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:set_node_property, "index1", { "key1" => "value1" } ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:set_node_property, "index1", { "key1" => "value1" } ],
                         [:set_node_property, "index2", { "key2" => "value2" } ]
       end
 
@@ -100,8 +99,8 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "/node/index2/properties", "body" => { "key2" => "value2" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:reset_node_properties, "index1", { "key1" => "value1" } ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:reset_node_properties, "index1", { "key1" => "value1" } ],
                         [:reset_node_properties, "index2", { "key2" => "value2" } ]
       end
 
@@ -110,8 +109,8 @@ module Neography
           { "id" => 0, "method" => "POST", "to" => "{0}/labels", "body" => "foo" },
           { "id" => 1, "method" => "POST", "to" => "{0}/labels", "body" => "bar" },
         ]
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:add_label, "{0}", "foo"],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:add_label, "{0}", "foo"],
                         [:add_label, "{0}", "bar"]
       end
 
@@ -121,8 +120,8 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/node/id2/relationships/all" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:get_node_relationships, "id1", "direction1" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:get_node_relationships, "id1", "direction1" ],
                         [:get_node_relationships, "id2" ]
       end
 
@@ -132,8 +131,8 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/relationship/bar" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:get_relationship, "foo"], [:get_relationship, "bar"]
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:get_relationship, "foo"], [:get_relationship, "bar"]
       end
 
       it "creates relationships" do
@@ -142,8 +141,8 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "{0}/relationships", "body" => { "to" => "{1}", "type" => "type2", "data" => "data2" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:create_relationship, "type1", "from1", "to1", "data1" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:create_relationship, "type1", "from1", "to1", "data1" ],
                         [:create_relationship, "type2", "{0}", "{1}", "data2" ]
       end
 
@@ -153,8 +152,8 @@ module Neography
           { "id" => 1, "method" => "DELETE", "to" => "/relationship/bar" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:delete_relationship, "foo"], [:delete_relationship, "bar"]
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:delete_relationship, "foo"], [:delete_relationship, "bar"]
       end
 
       it "creates unique nodes" do
@@ -163,8 +162,8 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/relationship/index2?unique", "body" => { "key" => "key2", "value" => "value2", "type" => "type2", "start" => "{0}", "end" => "{1}", "properties" => "properties" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:create_unique_relationship, "index1", "key1", "value1", "type1", "node1", "node2","properties"  ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:create_unique_relationship, "index1", "key1", "value1", "type1", "node1", "node2","properties"  ],
                         [:create_unique_relationship, "index2", "key2", "value2", "type2", "{0}", "{1}", "properties" ]
       end
 
@@ -174,8 +173,8 @@ module Neography
           { "id" => 1, "method" => "POST", "to" => "/index/relationship/index2", "body" => { "uri" => "{0}", "key" => "key2", "value" => "value2" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:add_relationship_to_index, "index1", "key1", "value1", "rel1" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:add_relationship_to_index, "index1", "key1", "value1", "rel1" ],
                         [:add_relationship_to_index, "index2", "key2", "value2", "{0}"]
       end
 
@@ -185,8 +184,8 @@ module Neography
           { "id" => 1, "method" => "GET", "to" => "/index/relationship/qux/quux/corge" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:get_relationship_index, "foo", "bar", "baz" ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:get_relationship_index, "foo", "bar", "baz" ],
                         [:get_relationship_index, "qux", "quux", "corge" ]
       end
 
@@ -197,8 +196,8 @@ module Neography
           { "id" => 2, "method" => "DELETE", "to" => "/index/relationship/index3/key3/value3/id3" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:remove_relationship_from_index, "index1", "id1", ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:remove_relationship_from_index, "index1", "id1", ],
                         [:remove_relationship_from_index, "index2", "key2", "id2" ],
                         [:remove_relationship_from_index, "index3", "key3", "value3", "id3" ]
       end
@@ -209,8 +208,8 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "/relationship/index2/properties/key2", "body" => "value2" }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:set_relationship_property, "index1", { "key1" => "value1" } ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:set_relationship_property, "index1", { "key1" => "value1" } ],
                         [:set_relationship_property, "index2", { "key2" => "value2" } ]
       end
 
@@ -220,30 +219,30 @@ module Neography
           { "id" => 1, "method" => "PUT", "to" => "{0}/properties", "body" => { "key2" => "value2" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:reset_relationship_properties, "index1", { "key1" => "value1" } ],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:reset_relationship_properties, "index1", { "key1" => "value1" } ],
                         [:reset_relationship_properties, "{0}", { "key2" => "value2" } ]
       end
 
-      it "executes scripts" do
+      it "batchs scripts" do
         expected_body = [
-          { "id" => 0, "method" => "POST", "to" => "/gremlin", "body" => { "script" => "script1", "params" => "params1" } },
-          { "id" => 1, "method" => "POST", "to" => "/gremlin", "body" => { "script" => "script2", "params" => "params2" } }
+          { "id" => 0, "method" => "POST", "to" => "/ext/GremlinPlugin/graphdb/execute_script", "body" => { "script" => "script1", "params" => "params1" } },
+          { "id" => 1, "method" => "POST", "to" => "/ext/GremlinPlugin/graphdb/execute_script", "body" => { "script" => "script2", "params" => "params2" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:execute_script, "script1", "params1"],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:execute_script, "script1", "params1"],
                         [:execute_script, "script2", "params2"]
       end
 
-      it "executes queries" do
+      it "batchs queries" do
         expected_body = [
           { "id" => 0, "method" => "POST", "to" => "/cypher", "body" => { "query" => "query1", "params" => "params1" } },
           { "id" => 1, "method" => "POST", "to" => "/cypher", "body" => { "query" => "query2" } }
         ]
 
-        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
-        subject.execute [:execute_query, "query1", "params1"],
+        subject.connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:execute_query, "query1", "params1"],
                         [:execute_query, "query2" ]
       end