neography 1.3.14 → 1.4.0

data/spec/unit/rest/nodes_spec.rb

@@ -4,35 +4,34 @@ module Neography
   class Rest
     describe Nodes do
 
-      let(:connection) { double }
-      subject { Nodes.new(connection) }
+      subject { Neography::Rest.new }
 
       context "get nodes" do
         it "gets single nodes" do
-          connection.should_receive(:get).with("/node/42")
-          subject.get("42")
+          subject.connection.should_receive(:get).with("/node/42")
+          subject.get_node("42")
         end
 
         it "gets multiple nodes" do
-          connection.should_receive(:get).with("/node/42")
-          connection.should_receive(:get).with("/node/43")
-          subject.get_each("42", "43")
+          subject.connection.should_receive(:get).with("/node/42")
+          subject.connection.should_receive(:get).with("/node/43")
+          subject.get_nodes("42", "43")
         end
 
         it "returns multiple nodes in an array" do
-          connection.stub(:get).and_return("foo", "bar")
-          subject.get_each("42", "43").should == [ "foo", "bar" ]
+          subject.connection.stub(:get).and_return("foo", "bar")
+          subject.get_nodes("42", "43").should == [ "foo", "bar" ]
         end
 
         it "gets the root node" do
-          connection.stub(:get).with("/").and_return({ "reference_node" => "42" })
-          connection.should_receive(:get).with("/node/42")
-          subject.root
+          subject.connection.stub(:get).with("/").and_return({ "reference_node" => "42" })
+          subject.connection.should_receive(:get).with("/node/42")
+          subject.get_root
         end
 
         it "returns the root node" do
-          connection.stub(:get).and_return({ "reference_node" => "42" }, "foo")
-          subject.root.should == "foo"
+          subject.connection.stub(:get).and_return({ "reference_node" => "42" }, "foo")
+          subject.get_root.should == "foo"
         end
       end
 
@@ -43,13 +42,13 @@ module Neography
             :body    => '{"foo":"bar","baz":"qux"}',
             :headers => json_content_type
           }
-          connection.should_receive(:post).with("/node", options)
-          subject.create_with_attributes({:foo => "bar", :baz => "qux"})
+          subject.connection.should_receive(:post).with("/node", options)
+          subject.create_node_with_attributes({:foo => "bar", :baz => "qux"})
         end
 
         it "returns the created node" do
-          connection.stub(:post).and_return("foo")
-          subject.create_with_attributes({}).should == "foo"
+          subject.connection.stub(:post).and_return("foo")
+          subject.create_node_with_attributes({}).should == "foo"
         end
 
         it "creates with attributes using #create method" do
@@ -57,23 +56,23 @@ module Neography
             :body    => '{"foo":"bar","baz":"qux"}',
             :headers => json_content_type
           }
-          connection.should_receive(:post).with("/node", options)
-          subject.create({:foo => "bar", :baz => "qux"})
+          subject.connection.should_receive(:post).with("/node", options)
+          subject.create_node({:foo => "bar", :baz => "qux"})
         end
 
         it "creates empty nodes" do
-          connection.should_receive(:post).with("/node")
-          subject.create_empty
+          subject.connection.should_receive(:post).with("/node")
+          subject.create_empty_node
         end
 
         it "returns an empty node" do
-          connection.stub(:post).and_return("foo")
-          subject.create_empty.should == "foo"
+          subject.connection.stub(:post).and_return("foo")
+          subject.create_empty_node.should == "foo"
         end
 
         it "creates empty nodes using #create method" do
-          connection.should_receive(:post).with("/node")
-          subject.create
+          subject.connection.should_receive(:post).with("/node")
+          subject.create_node
         end
 
       end
@@ -81,8 +80,8 @@ module Neography
       context "delete nodes" do
 
         it "deletes a node" do
-          connection.should_receive(:delete).with("/node/42")
-          subject.delete("42")
+          subject.connection.should_receive(:delete).with("/node/42")
+          subject.delete_node("42")
         end
 
       end
@@ -98,18 +97,18 @@ module Neography
             :body    => '{"foo2":"bar2","baz2":"qux2"}',
             :headers => json_content_type
           }
-          connection.should_receive(:post).with("/node", options1)
-          connection.should_receive(:post).with("/node", options2)
+          subject.connection.should_receive(:post).with("/node", options1)
+          subject.connection.should_receive(:post).with("/node", options2)
 
-          subject.create_multiple([
+          subject.create_nodes([
             {:foo1 => "bar1", :baz1 => "qux1"},
             {:foo2 => "bar2", :baz2 => "qux2"}
           ])
         end
 
         it "returns multiple nodes with attributes in an array" do
-          connection.stub(:post).and_return("foo", "bar")
-          subject.create_multiple([{},{}]).should == ["foo", "bar"]
+          subject.connection.stub(:post).and_return("foo", "bar")
+          subject.create_nodes([{},{}]).should == ["foo", "bar"]
         end
 
         # exotic?
@@ -118,23 +117,23 @@ module Neography
             :body    => '{"foo1":"bar1","baz1":"qux1"}',
             :headers => json_content_type
           }
-          connection.should_receive(:post).with("/node", options1)
-          connection.should_receive(:post).with("/node")
+          subject.connection.should_receive(:post).with("/node", options1)
+          subject.connection.should_receive(:post).with("/node")
 
-          subject.create_multiple([
+          subject.create_nodes([
             {:foo1 => "bar1", :baz1 => "qux1"},
             "not a hash" # ?
           ])
         end
 
         it "creates multiple empty nodes" do
-          connection.should_receive(:post).with("/node").twice
-          subject.create_multiple(2)
+          subject.connection.should_receive(:post).with("/node").twice
+          subject.create_nodes(2)
         end
 
         it "returns multiple empty nodes in an array" do
-          connection.stub(:post).and_return("foo", "bar")
-          subject.create_multiple(2).should == ["foo", "bar"]
+          subject.connection.stub(:post).and_return("foo", "bar")
+          subject.create_nodes(2).should == ["foo", "bar"]
         end
 
       end
@@ -152,10 +151,10 @@ module Neography
             :body    => '{"foo2":"bar2","baz2":"qux2"}',
             :headers => json_content_type
           }
-          connection.should_receive(:post).with("/node", options1)
-          connection.should_receive(:post).with("/node", options2)
+          subject.connection.should_receive(:post).with("/node", options1)
+          subject.connection.should_receive(:post).with("/node", options2)
 
-          subject.create_multiple_threaded([
+          subject.create_nodes_threaded([
             {:foo1 => "bar1", :baz1 => "qux1"},
             {:foo2 => "bar2", :baz2 => "qux2"}
           ])
@@ -167,18 +166,18 @@ module Neography
             :body    => '{"foo1":"bar1","baz1":"qux1"}',
             :headers => json_content_type
           }
-          connection.should_receive(:post).with("/node", options1)
-          connection.should_receive(:post).with("/node")
+          subject.connection.should_receive(:post).with("/node", options1)
+          subject.connection.should_receive(:post).with("/node")
 
-          subject.create_multiple_threaded([
+          subject.create_nodes_threaded([
             {:foo1 => "bar1", :baz1 => "qux1"},
             "not a hash" # ?
           ])
         end
 
         it "creates multiple empty nodes" do
-          connection.should_receive(:post).with("/node").twice
-          subject.create_multiple_threaded(2)
+          subject.connection.should_receive(:post).with("/node").twice
+          subject.create_nodes_threaded(2)
         end
 
       end

data/spec/unit/rest/relationship_auto_indexes_spec.rb

@@ -4,62 +4,61 @@ module Neography
   class Rest
     describe RelationshipAutoIndexes do
 
-      let(:connection) { double }
-      subject { RelationshipAutoIndexes.new(connection) }
+      subject { Neography::Rest.new }
 
       it "gets a relationship from an auto index" do
-        connection.should_receive(:get).with("/index/auto/relationship/some_key/some_value")
-        subject.get("some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/auto/relationship/some_key/some_value")
+        subject.get_relationship_auto_index("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
+        subject.connection.stub(:get).and_return(nil)
+        subject.get_relationship_auto_index("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/relationship/some_key/some_value")
-        subject.find_or_query("some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/auto/relationship/some_key/some_value")
+        subject.find_relationship_auto_index("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/relationship/?query=some_query")
-        subject.find_or_query("some_query")
+        subject.connection.should_receive(:get).with("/index/auto/relationship/?query=some_query")
+        subject.find_relationship_auto_index("some_query")
       end
 
       it "finds by key and value" do
-        connection.should_receive(:get).with("/index/auto/relationship/some_key/some_value")
-        subject.find("some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/auto/relationship/some_key/some_value")
+        subject.find_relationship_auto_index("some_key", "some_value")
       end
 
       it "finds by query" do
-        connection.should_receive(:get).with("/index/auto/relationship/?query=some_query")
-        subject.query("some_query")
+        subject.connection.should_receive(:get).with("/index/auto/relationship/?query=some_query")
+        subject.find_relationship_auto_index("some_query")
       end
 
       it "gets the status" do
-        connection.should_receive(:get).with("/index/auto/relationship/status")
-        subject.status
+        subject.connection.should_receive(:get).with("/index/auto/relationship/status")
+        subject.get_relationship_auto_index_status
       end
 
       it "sets the status" do
-        connection.should_receive(:put).with("/index/auto/relationship/status", hash_match(:body, '"foo"'))
-        subject.status = "foo"
+        subject.connection.should_receive(:put).with("/index/auto/relationship/status", hash_match(:body, '"foo"'))
+        subject.set_relationship_auto_index_status("foo")
       end
 
       it "gets auto index properties" do
-        connection.should_receive(:get).with("/index/auto/relationship/properties")
-        subject.properties
+        subject.connection.should_receive(:get).with("/index/auto/relationship/properties")
+        subject.get_relationship_auto_index_properties
       end
 
       it "adds a property to an auto index" do
-        connection.should_receive(:post).with("/index/auto/relationship/properties", hash_match(:body, "foo"))
-        subject.add_property("foo")
+        subject.connection.should_receive(:post).with("/index/auto/relationship/properties", hash_match(:body, "foo"))
+        subject.add_relationship_auto_index_property("foo")
       end
 
       it "removes a property from an auto index" do
-        connection.should_receive(:delete).with("/index/auto/relationship/properties/foo")
-        subject.remove_property("foo")
+        subject.connection.should_receive(:delete).with("/index/auto/relationship/properties/foo")
+        subject.remove_relationship_auto_index_property("foo")
       end
 
     end

data/spec/unit/rest/relationship_indexes_spec.rb

@@ -4,12 +4,11 @@ module Neography
   class Rest
     describe RelationshipIndexes do
 
-      let(:connection) { double(:configuration => "http://configuration") }
-      subject { RelationshipIndexes.new(connection) }
+      subject { Neography::Rest.new }
 
       it "lists all indexes" do
-        connection.should_receive(:get).with("/index/relationship")
-        subject.list
+        subject.connection.should_receive(:get).with("/index/relationship")
+        subject.list_relationship_indexes
       end
 
       it "creates a relationship index" do
@@ -20,13 +19,13 @@ module Neography
           },
           "name" => "some_index"
         }
-        connection.should_receive(:post).with("/index/relationship", json_match(:body, expected_body))
-        subject.create("some_index", "some_type", "some_provider")
+        subject.connection.should_receive(:post).with("/index/relationship", json_match(:body, expected_body))
+        subject.create_relationship_index("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"
+        subject.connection.stub(:post).and_return("foo")
+        subject.create_relationship_index("some_index", "some_type", "some_provider").should == "foo"
       end
 
       it "creates an auto-index" do
@@ -37,8 +36,8 @@ module Neography
           },
           "name" => "relationship_auto_index"
         }
-        connection.should_receive(:post).with("/index/relationship", json_match(:body, expected_body))
-        subject.create_auto("some_type", "some_provider")
+        subject.connection.should_receive(:post).with("/index/relationship", json_match(:body, expected_body))
+        subject.create_relationship_auto_index("some_type", "some_provider")
       end
 
       it "creates a unique relationship in an index" do
@@ -46,87 +45,87 @@ module Neography
           "key"        => "key",
           "value"      => "value",
           "type"       => "type",
-          "start"      => "http://configuration/node/42",
-          "end"        => "http://configuration/node/43",
+          "start"      => "http://localhost:7474/node/42",
+          "end"        => "http://localhost:7474/node/43",
           "properties" => "properties"
         }
-        connection.should_receive(:post).with("/index/relationship/some_index?unique", json_match(:body, expected_body))
-        subject.create_unique("some_index", "key", "value", "type", "42", "43", "properties")
+        subject.connection.should_receive(:post).with("/index/relationship/some_index?unique", json_match(:body, expected_body))
+        subject.create_unique_relationship("some_index", "key", "value", "type", "42", "43", "properties")
       end
 
       it "adds a relationship to an index" do
         expected_body = {
-          "uri" => "http://configuration/relationship/42",
+          "uri" => "http://localhost:7474/relationship/42",
           "key" => "key",
           "value" => "value"
         }
-        connection.should_receive(:post).with("/index/relationship/some_index", json_match(:body, expected_body))
-        subject.add("some_index", "key", "value", "42")
+        subject.connection.should_receive(:post).with("/index/relationship/some_index", json_match(:body, expected_body))
+        subject.add_relationship_to_index("some_index", "key", "value", "42")
       end
 
       it "gets a relationship from an index" do
-        connection.should_receive(:get).with("/index/relationship/some_index/some_key/some_value")
-        subject.get("some_index", "some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/relationship/some_index/some_key/some_value")
+        subject.get_relationship_index("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
+        subject.connection.stub(:get).and_return(nil)
+        subject.get_relationship_index("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/relationship/some_index/some_key/some_value")
-        subject.find("some_index", "some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/relationship/some_index/some_key/some_value")
+        subject.find_relationship_index("some_index", "some_key", "some_value")
       end
 
       it "finds by query if no value passed to #find" do
-        connection.should_receive(:get).with("/index/relationship/some_index?query=some_query")
-        subject.find("some_index", "some_query")
+        subject.connection.should_receive(:get).with("/index/relationship/some_index?query=some_query")
+        subject.find_relationship_index("some_index", "some_query")
       end
 
       it "finds by key query" do
-        connection.should_receive(:get).with("/index/relationship/some_index/some_key/some_value")
-        subject.find_by_key_value("some_index", "some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/relationship/some_index/some_key/some_value")
+        subject.find_relationship_index_by_key_value("some_index", "some_key", "some_value")
       end
 
       it "finds by query" do
-        connection.should_receive(:get).with("/index/relationship/some_index?query=some_query")
-        subject.find_by_query("some_index", "some_query")
+        subject.connection.should_receive(:get).with("/index/relationship/some_index?query=some_query")
+        subject.find_relationship_index_by_query("some_index", "some_query")
       end
 
       it "removes a relationship from an index for #remove with two arguments" do
-        connection.should_receive(:delete).with("/index/relationship/some_index/42")
-        subject.remove("some_index", "42")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index/42")
+        subject.remove_relationship_from_index("some_index", "42")
       end
 
       it "removes a relationship from an index by key for #remove with three arguments" do
-        connection.should_receive(:delete).with("/index/relationship/some_index/some_key/42")
-        subject.remove("some_index", "some_key", "42")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index/some_key/42")
+        subject.remove_relationship_from_index("some_index", "some_key", "42")
       end
 
       it "removes a relationship from an index by key and value for #remove with four arguments" do
-        connection.should_receive(:delete).with("/index/relationship/some_index/some_key/some_value/42")
-        subject.remove("some_index", "some_key", "some_value", "42")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index/some_key/some_value/42")
+        subject.remove_relationship_from_index("some_index", "some_key", "some_value", "42")
       end
 
       it "removes a relationship from an index" do
-        connection.should_receive(:delete).with("/index/relationship/some_index/42")
-        subject.remove_by_id("some_index", "42")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index/42")
+        subject.remove_relationship_index_by_id("some_index", "42")
       end
 
       it "removes a relationship from an index by key" do
-        connection.should_receive(:delete).with("/index/relationship/some_index/some_key/42")
-        subject.remove_by_key("some_index", "42", "some_key")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index/some_key/42")
+        subject.remove_relationship_index_by_key("some_index", "42", "some_key")
       end
 
       it "removes a relationship from an index by key and value" do
-        connection.should_receive(:delete).with("/index/relationship/some_index/some_key/some_value/42")
-        subject.remove_by_value("some_index", "42", "some_key", "some_value")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index/some_key/some_value/42")
+        subject.remove_relationship_index_by_value("some_index", "42", "some_key", "some_value")
       end
 
       it "drops an index" do
-        connection.should_receive(:delete).with("/index/relationship/some_index")
-        subject.drop("some_index")
+        subject.connection.should_receive(:delete).with("/index/relationship/some_index")
+        subject.drop_relationship_index("some_index")
       end
     end
   end

data/spec/unit/rest/relationship_properties_spec.rb

@@ -4,8 +4,7 @@ module Neography
   class Rest
     describe RelationshipProperties do
 
-      let(:connection) { double }
-      subject { RelationshipProperties.new(connection) }
+      subject { Neography::Rest.new }
 
       it "sets properties" do
         options1 = {
@@ -16,9 +15,9 @@ module Neography
           :body    => '"qux"',
           :headers => json_content_type
         }
-        connection.should_receive(:put).with("/relationship/42/properties/foo", options1)
-        connection.should_receive(:put).with("/relationship/42/properties/baz", options2)
-        subject.set("42", {:foo => "bar", :baz => "qux"})
+        subject.connection.should_receive(:put).with("/relationship/42/properties/foo", options1)
+        subject.connection.should_receive(:put).with("/relationship/42/properties/baz", options2)
+        subject.set_relationship_properties("42", {:foo => "bar", :baz => "qux"})
       end
 
       it "resets properties" do
@@ -26,36 +25,36 @@ module Neography
           :body    => '{"foo":"bar"}',
           :headers => json_content_type
         }
-        connection.should_receive(:put).with("/relationship/42/properties", options)
-        subject.reset("42", {:foo => "bar"})
+        subject.connection.should_receive(:put).with("/relationship/42/properties", options)
+        subject.reset_relationship_properties("42", {:foo => "bar"})
       end
 
       context "getting properties" do
 
         it "gets all properties" do
-          connection.should_receive(:get).with("/relationship/42/properties")
-          subject.get("42")
+          subject.connection.should_receive(:get).with("/relationship/42/properties")
+          subject.get_relationship_properties("42")
         end
 
         it "gets multiple properties" do
-          connection.should_receive(:get).with("/relationship/42/properties/foo")
-          connection.should_receive(:get).with("/relationship/42/properties/bar")
-          subject.get("42", "foo", "bar")
+          subject.connection.should_receive(:get).with("/relationship/42/properties/foo")
+          subject.connection.should_receive(:get).with("/relationship/42/properties/bar")
+          subject.get_relationship_properties("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" }
+          subject.connection.stub(:get).and_return("baz", "qux")
+          subject.get_relationship_properties("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
+          subject.connection.stub(:get).and_return(nil, nil)
+          subject.get_relationship_properties("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" }
+          subject.connection.stub(:get).and_return("baz", nil)
+          subject.get_relationship_properties("42", "foo", "bar").should == { "foo" => "baz" }
         end
 
       end
@@ -63,14 +62,14 @@ module Neography
       context "removing properties" do
 
         it "removes all properties" do
-          connection.should_receive(:delete).with("/relationship/42/properties")
-          subject.remove("42")
+          subject.connection.should_receive(:delete).with("/relationship/42/properties")
+          subject.remove_relationship_properties("42")
         end
 
         it "removes multiple properties" do
-          connection.should_receive(:delete).with("/relationship/42/properties/foo")
-          connection.should_receive(:delete).with("/relationship/42/properties/bar")
-          subject.remove("42", "foo", "bar")
+          subject.connection.should_receive(:delete).with("/relationship/42/properties/foo")
+          subject.connection.should_receive(:delete).with("/relationship/42/properties/bar")
+          subject.remove_relationship_properties("42", "foo", "bar")
         end
 
       end