neography 0.0.31 → 1.0.0

data/spec/unit/rest/batch_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Batch do
+
+      let(:connection) { stub(:gremlin_path => "/gremlin", :cypher_path => "/cypher") }
+      subject { Batch.new(connection) }
+
+      it "gets nodes" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/node/foo" },
+          { "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"]
+      end
+
+      it "creates nodes" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/node", "body" => { "foo" => "bar" } },
+          { "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" }]
+      end
+
+      it "deletes nodes" do
+        expected_body = [
+          { "id" => 0, "method" => "DELETE", "to" => "/node/foo" },
+          { "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"]
+      end
+
+      it "creates unique nodes" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/index/node/foo?unique",  "body" => { "key" => "bar",   "value" => "baz",    "properties" => "qux"    } },
+          { "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" ],
+                        [:create_unique_node, "quux", "corge", "grault", "garply"]
+      end
+
+      it "adds nodes to an index" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/index/node/foo",  "body" => { "uri" => "/node/qux",    "key" => "bar",   "value" => "baz"    } },
+          { "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" ],
+                        [:add_node_to_index, "quux", "corge", "grault", "{0}"]
+      end
+
+      it "gets nodes from an index" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/index/node/foo/bar/baz" },
+          { "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" ],
+                        [:get_node_index, "qux", "quux", "corge" ]
+      end
+
+      it "deletes nodes from an index" do
+        expected_body = [
+          { "id" => 0, "method" => "DELETE", "to" => "/index/node/index1/id1" },
+          { "id" => 1, "method" => "DELETE", "to" => "/index/node/index2/key2/id2" },
+          { "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", ],
+                        [:remove_node_from_index, "index2", "key2", "id2" ],
+                        [:remove_node_from_index, "index3", "key3", "value3", "id3" ]
+      end
+
+      it "sets node properties" do
+        expected_body = [
+          { "id" => 0, "method" => "PUT", "to" => "/node/index1/properties/key1", "body" => "value1" },
+          { "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" } ],
+                        [:set_node_property, "index2", { "key2" => "value2" } ]
+      end
+
+      it "resets node properties" do
+        expected_body = [
+          { "id" => 0, "method" => "PUT", "to" => "/node/index1/properties", "body" => { "key1" => "value1" } },
+          { "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" } ],
+                        [:reset_node_properties, "index2", { "key2" => "value2" } ]
+      end
+
+      it "gets node relationships" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/node/id1/relationships/direction1" },
+          { "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" ],
+                        [:get_node_relationships, "id2" ]
+      end
+
+      it "gets relationships" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/relationship/foo" },
+          { "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"]
+      end
+
+      it "creates relationships" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/node/from1/relationships", "body" => { "to" => "/node/to1", "type" => "type1", "data" => "data1" } },
+          { "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" ],
+                        [:create_relationship, "type2", "{0}", "{1}", "data2" ]
+      end
+
+      it "deletes relationships" do
+        expected_body = [
+          { "id" => 0, "method" => "DELETE", "to" => "/relationship/foo" },
+          { "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"]
+      end
+
+      it "creates unique nodes" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/index/relationship/index1?unique", "body" => { "key" => "key1", "value" => "value1", "type" => "type1", "start" => "/node/node1", "end" => "/node/node2" } },
+          { "id" => 1, "method" => "POST", "to" => "/index/relationship/index2?unique", "body" => { "key" => "key2", "value" => "value2", "type" => "type2", "start" => "{0}", "end" => "{1}" } }
+        ]
+
+        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.execute [:create_unique_relationship, "index1", "key1", "value1", "type1", "node1", "node2" ],
+                        [:create_unique_relationship, "index2", "key2", "value2", "type2", "{0}", "{1}" ]
+      end
+
+      it "adds relationships to an index" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/index/relationship/index1", "body" => { "uri" => "/relationship/rel1", "key" => "key1", "value" => "value1" } },
+          { "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" ],
+                        [:add_relationship_to_index, "index2", "key2", "value2", "{0}"]
+      end
+
+      it "gets relationships from an index" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/index/relationship/foo/bar/baz" },
+          { "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" ],
+                        [:get_relationship_index, "qux", "quux", "corge" ]
+      end
+
+      it "deletes relationships from an index" do
+        expected_body = [
+          { "id" => 0, "method" => "DELETE", "to" => "/index/relationship/index1/id1" },
+          { "id" => 1, "method" => "DELETE", "to" => "/index/relationship/index2/key2/id2" },
+          { "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", ],
+                        [:remove_relationship_from_index, "index2", "key2", "id2" ],
+                        [:remove_relationship_from_index, "index3", "key3", "value3", "id3" ]
+      end
+
+      it "sets relationship properties" do
+        expected_body = [
+          { "id" => 0, "method" => "PUT", "to" => "/relationship/index1/properties/key1", "body" => "value1" },
+          { "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" } ],
+                        [:set_relationship_property, "index2", { "key2" => "value2" } ]
+      end
+
+      it "resets relationship properties" do
+        expected_body = [
+          { "id" => 0, "method" => "PUT", "to" => "/relationship/index1/properties", "body" => { "key1" => "value1" } },
+          { "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" } ],
+                        [:reset_relationship_properties, "{0}", { "key2" => "value2" } ]
+      end
+
+      it "executes 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" } }
+        ]
+
+        connection.should_receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.execute [:execute_script, "script1", "params1"],
+                        [:execute_script, "script2", "params2"]
+      end
+
+      it "executes 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"],
+                        [:execute_query, "query2" ]
+      end
+
+    end
+  end
+end
+

data/spec/unit/rest/clean_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Clean do
+
+      let(:connection) { stub }
+      subject { Clean.new(connection) }
+
+      it "cleans the database" do
+        connection.should_receive(:delete).with("/cleandb/secret-key")
+        subject.execute
+      end
+
+    end
+  end
+end

data/spec/unit/rest/cypher_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Cypher do
+
+      let(:connection) { stub(:cypher_path => "/cypher") }
+      subject { Cypher.new(connection) }
+
+      it "executes a cypher query" do
+        options = {
+          :body=>"{\"query\":\"SOME QUERY\",\"params\":{\"foo\":\"bar\",\"baz\":\"qux\"}}",
+          :headers=>{"Content-Type"=>"application/json", "Accept"=>"application/json;stream=true"}
+        }
+        connection.should_receive(:post).with("/cypher", options)
+        subject.query("SOME QUERY", { :foo => "bar", :baz => "qux" })
+      end
+
+    end
+  end
+end

data/spec/unit/rest/gremlin_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Gremlin do
+
+      let(:connection) { stub(:gremlin_path => "/gremlin") }
+      subject { Gremlin.new(connection) }
+
+      it "executes a gremlin script" do
+        options = {
+          :body=>"{\"script\":\"SOME SCRIPT\",\"params\":{\"foo\":\"bar\",\"baz\":\"qux\"}}",
+          :headers=>{"Content-Type"=>"application/json"}
+        }
+        connection.should_receive(:post).with("/gremlin", options)
+        subject.execute("SOME SCRIPT", { :foo => "bar", :baz => "qux" })
+      end
+
+      it "returns nil if script result is null" do
+        connection.stub(:post).and_return("null")
+        subject.execute("", {}).should be_nil
+      end
+
+    end
+  end
+end

data/spec/unit/rest/node_auto_indexes_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeAutoIndexes do
+
+      let(:connection) { stub }
+      subject { NodeAutoIndexes.new(connection) }
+
+      it "gets a node from an auto index" do
+        connection.should_receive(:get).with("/index/auto/node/some_key/some_value")
+        subject.get("some_key", "some_value")
+      end
+
+      it "returns nil if nothing was found in the auto index" do
+        connection.stub(:get).and_return(nil)
+        subject.get("some_key", "some_value").should be_nil
+      end
+
+      it "finds by key and value if value passed to #find_or_query" do
+        connection.should_receive(:get).with("/index/auto/node/some_key/some_value")
+        subject.find_or_query("some_key", "some_value")
+      end
+
+      it "finds by query if no value passed to #find_or_query" do
+        connection.should_receive(:get).with("/index/auto/node/?query=some_query")
+        subject.find_or_query("some_query")
+      end
+
+      it "finds by key and value" do
+        connection.should_receive(:get).with("/index/auto/node/some_key/some_value")
+        subject.find("some_key", "some_value")
+      end
+
+      it "finds by query" do
+        connection.should_receive(:get).with("/index/auto/node/?query=some_query")
+        subject.query("some_query")
+      end
+
+      it "gets the status" do
+        connection.should_receive(:get).with("/index/auto/node/status")
+        subject.status
+      end
+
+      it "sets the status" do
+        connection.should_receive(:put).with("/index/auto/node/status", hash_match(:body, '"foo"'))
+        subject.status = "foo"
+      end
+
+      it "gets auto index properties" do
+        connection.should_receive(:get).with("/index/auto/node/properties")
+        subject.properties
+      end
+
+      it "adds a property to an auto index" do
+        connection.should_receive(:post).with("/index/auto/node/properties", hash_match(:body, "foo"))
+        subject.add_property("foo")
+      end
+
+      it "removes a property from an auto index" do
+        connection.should_receive(:delete).with("/index/auto/node/properties/foo")
+        subject.remove_property("foo")
+      end
+
+    end
+  end
+end

data/spec/unit/rest/node_indexes_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeIndexes do
+
+      let(:connection) { stub(:configuration => "http://configuration") }
+      subject { NodeIndexes.new(connection) }
+
+      it "lists all indexes" do
+        connection.should_receive(:get).with("/index/node")
+        subject.list
+      end
+
+      it "creates a node index" do
+        expected_body = {
+          "config" => {
+            "type" => "some_type",
+            "provider" => "some_provider"
+          },
+          "name" => "some_index"
+        }
+        connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
+        subject.create("some_index", "some_type", "some_provider")
+      end
+
+      it "returns the post result after creation" do
+        connection.stub(:post).and_return("foo")
+        subject.create("some_index", "some_type", "some_provider").should == "foo"
+      end
+
+      it "creates an auto-index" do
+        expected_body = {
+          "config" => {
+            "type" => "some_type",
+            "provider" => "some_provider"
+          },
+          "name" => "node_auto_index"
+        }
+        connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
+        subject.create_auto("some_type", "some_provider")
+      end
+
+      it "creates a unique node in an index" do
+        expected_body = {
+          "properties" => "properties",
+          "key" => "key",
+          "value" => "value"
+        }
+        connection.should_receive(:post).with("/index/node/some_index?unique", json_match(:body, expected_body))
+        subject.create_unique("some_index", "key", "value", "properties")
+      end
+
+      it "adds a node to an index" do
+        expected_body = {
+          "uri" => "http://configuration/node/42",
+          "key" => "key",
+          "value" => "value"
+        }
+        connection.should_receive(:post).with("/index/node/some_index", json_match(:body, expected_body))
+        subject.add("some_index", "key", "value", "42")
+      end
+
+      it "gets a node from an index" do
+        connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        subject.get("some_index", "some_key", "some_value")
+      end
+
+      it "returns nil if nothing was found in the index" do
+        connection.stub(:get).and_return(nil)
+        subject.get("some_index", "some_key", "some_value").should be_nil
+      end
+
+      it "finds by key and value if both passed to #find" do
+        connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        subject.find("some_index", "some_key", "some_value")
+      end
+
+      it "finds by query if no value passed to #find" do
+        connection.should_receive(:get).with("/index/node/some_index?query=some_query")
+        subject.find("some_index", "some_query")
+      end
+
+      it "finds by key and value" do
+        connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        subject.find_by_key_value("some_index", "some_key", "some_value")
+      end
+
+      it "finds by query" do
+        connection.should_receive(:get).with("/index/node/some_index?query=some_query")
+        subject.find_by_query("some_index", "some_query")
+      end
+
+      it "removes a node from an index by id for #remove with two arguments" do
+        connection.should_receive(:delete).with("/index/node/some_index/42")
+        subject.remove("some_index", "42")
+      end
+
+      it "removes a node from an index by key for #remove with three arguments" do
+        connection.should_receive(:delete).with("/index/node/some_index/some_key/42")
+        subject.remove("some_index", "some_key", "42")
+      end
+
+      it "removes a node from an index by key and value for #remove with four arguments" do
+        connection.should_receive(:delete).with("/index/node/some_index/some_key/some_value/42")
+        subject.remove("some_index", "some_key", "some_value", "42")
+      end
+
+      it "removes a node from an index" do
+        connection.should_receive(:delete).with("/index/node/some_index/42")
+        subject.remove_by_id("some_index", "42")
+      end
+
+      it "removes a node from an index by key" do
+        connection.should_receive(:delete).with("/index/node/some_index/some_key/42")
+        subject.remove_by_key("some_index", "42", "some_key")
+      end
+
+      it "removes a node from an index by key and value" do
+        connection.should_receive(:delete).with("/index/node/some_index/some_key/some_value/42")
+        subject.remove_by_value("some_index", "42", "some_key", "some_value")
+      end
+
+    end
+  end
+end

data/spec/unit/rest/node_paths_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodePaths do
+
+      let(:connection) { stub(:configuration => "http://configuration") }
+      subject { NodePaths.new(connection) }
+
+      it "gets a shortest path between two nodes" do
+        expected_body = {
+          "to"            => "http://configuration/node/43",
+          "relationships" => "relationships",
+          "max_depth"     => 3,
+          "algorithm"     => "shortestPath"
+        }
+
+        connection.should_receive(:post).with("/node/42/path", json_match(:body, expected_body))
+
+        subject.get("42", "43", "relationships", 3, "shortestPath")
+      end
+
+      it "gets all shortest paths between two nodes" do
+        expected_body = {
+          "to"            => "http://configuration/node/43",
+          "relationships" => "relationships",
+          "max_depth"     => 3,
+          "algorithm"     => "shortestPath"
+        }
+
+        connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
+
+        subject.get_all("42", "43", "relationships", 3, "shortestPath")
+      end
+
+      it "gets all shortest weighted paths between two nodes" do
+        expected_body = {
+          "to"            => "http://configuration/node/43",
+          "relationships" => "relationships",
+          "cost_property" => "cost",
+          "max_depth"     => 3,
+          "algorithm"     => "shortestPath"
+        }
+
+        connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
+
+        subject.shortest_weighted("42", "43", "relationships", "cost", 3, "shortestPath")
+      end
+
+      context "algorithm" do
+
+        subject { NodePaths.new(nil) }
+
+        [ :shortest, "shortest", :shortestPath, "shortestPath", :short, "short" ].each do |algorithm|
+          it "parses shortestPath" do
+            subject.send(:get_algorithm, algorithm).should == "shortestPath"
+          end
+        end
+
+        [ :allSimplePaths, "allSimplePaths", :simple, "simple" ].each do |algorithm|
+          it "parses allSimplePaths" do
+            subject.send(:get_algorithm, algorithm).should == "allSimplePaths"
+          end
+        end
+
+        [ :dijkstra, "dijkstra" ].each do |algorithm|
+          it "parses dijkstra" do
+            subject.send(:get_algorithm, algorithm).should == "dijkstra"
+          end
+        end
+
+        it "parses allPaths by default" do
+          subject.send(:get_algorithm, "foo").should == "allPaths"
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/rest/node_properties_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeProperties do
+
+      let(:connection) { stub }
+      subject { NodeProperties.new(connection) }
+
+      it "sets properties" do
+        options1 = {
+          :body    => '"bar"',
+          :headers => json_content_type
+        }
+        options2 = {
+          :body    => '"qux"',
+          :headers => json_content_type
+        }
+        connection.should_receive(:put).with("/node/42/properties/foo", options1)
+        connection.should_receive(:put).with("/node/42/properties/baz", options2)
+        subject.set("42", {:foo => "bar", :baz => "qux"})
+      end
+
+      it "resets properties" do
+        options = {
+          :body    => '{"foo":"bar"}',
+          :headers => json_content_type
+        }
+        connection.should_receive(:put).with("/node/42/properties", options)
+        subject.reset("42", {:foo => "bar"})
+      end
+
+      context "getting properties" do
+
+        it "gets all properties" do
+          connection.should_receive(:get).with("/node/42/properties")
+          subject.get("42")
+        end
+
+        it "gets multiple properties" do
+          connection.should_receive(:get).with("/node/42/properties/foo")
+          connection.should_receive(:get).with("/node/42/properties/bar")
+          subject.get("42", "foo", "bar")
+        end
+
+        it "returns multiple properties as a hash" do
+          connection.stub(:get).and_return("baz", "qux")
+          subject.get("42", "foo", "bar").should == { "foo" => "baz", "bar" => "qux" }
+        end
+
+        it "returns nil if no properties were found" do
+          connection.stub(:get).and_return(nil, nil)
+          subject.get("42", "foo", "bar").should be_nil
+        end
+
+        it "returns hash without nil return values" do
+          connection.stub(:get).and_return("baz", nil)
+          subject.get("42", "foo", "bar").should == { "foo" => "baz" }
+        end
+
+      end
+
+      context "removing properties" do
+
+        it "removes all properties" do
+          connection.should_receive(:delete).with("/node/42/properties")
+          subject.remove("42")
+        end
+
+        it "removes multiple properties" do
+          connection.should_receive(:delete).with("/node/42/properties/foo")
+          connection.should_receive(:delete).with("/node/42/properties/bar")
+          subject.remove("42", "foo", "bar")
+        end
+
+      end
+
+    end
+  end
+end