neography 1.3.14 → 1.4.0

data/spec/unit/rest/node_indexes_spec.rb

@@ -4,12 +4,11 @@ module Neography
   class Rest
     describe NodeIndexes do
 
-      let(:connection) { double(:configuration => "http://configuration") }
-      subject { NodeIndexes.new(connection) }
+      subject { Neography::Rest.new }
 
       it "lists all indexes" do
-        connection.should_receive(:get).with("/index/node")
-        subject.list
+        subject.connection.should_receive(:get).with("/index/node")
+        subject.list_node_indexes
       end
 
       it "creates a node index" do
@@ -20,13 +19,13 @@ module Neography
           },
           "name" => "some_index"
         }
-        connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
-        subject.create("some_index", "some_type", "some_provider")
+        subject.connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
+        subject.create_node_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_node_index("some_index", "some_type", "some_provider").should == "foo"
       end
 
       it "creates an auto-index" do
@@ -37,8 +36,8 @@ module Neography
           },
           "name" => "node_auto_index"
         }
-        connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
-        subject.create_auto("some_type", "some_provider")
+        subject.connection.should_receive(:post).with("/index/node", json_match(:body, expected_body))
+        subject.create_node_auto_index("some_type", "some_provider")
       end
 
       it "creates a unique node in an index" do
@@ -47,8 +46,8 @@ module Neography
           "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")
+        subject.connection.should_receive(:post).with("/index/node/some_index?unique", json_match(:body, expected_body))
+        subject.create_unique_node("some_index", "key", "value", "properties")
       end
 
       it "gets or creates a unique node in an index" do
@@ -57,83 +56,83 @@ module Neography
           "key" => "key",
           "value" => "value"
         }
-        connection.should_receive(:post).with("/index/node/some_index?uniqueness=get_or_create", json_match(:body, expected_body))
-        subject.get_or_create_unique("some_index", "key", "value", "properties")
+        subject.connection.should_receive(:post).with("/index/node/some_index?uniqueness=get_or_create", json_match(:body, expected_body))
+        subject.get_or_create_unique_node("some_index", "key", "value", "properties")
       end
 
       it "adds a node to an index" do
         expected_body = {
-          "uri" => "http://configuration/node/42",
+          "uri" => "http://localhost:7474/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")
+        subject.connection.should_receive(:post).with("/index/node/some_index", json_match(:body, expected_body))
+        subject.add_node_to_index("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")
+        subject.connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        subject.get_node_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_node_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/node/some_index/some_key/some_value")
-        subject.find("some_index", "some_key", "some_value")
+        subject.connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        subject.find_node_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/node/some_index?query=some_query")
-        subject.find("some_index", "some_query")
+        subject.connection.should_receive(:get).with("/index/node/some_index?query=some_query")
+        subject.find_node_index("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")
+        subject.connection.should_receive(:get).with("/index/node/some_index/some_key/some_value")
+        subject.find_node_index_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")
+        subject.connection.should_receive(:get).with("/index/node/some_index?query=some_query")
+        subject.find_node_index_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")
+        subject.connection.should_receive(:delete).with("/index/node/some_index/42")
+        subject.remove_node_from_index("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")
+        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/42")
+        subject.remove_node_from_index("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")
+        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/some_value/42")
+        subject.remove_node_from_index("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")
+        subject.connection.should_receive(:delete).with("/index/node/some_index/42")
+        subject.remove_node_index_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")
+        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/42")
+        subject.remove_node_index_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")
+        subject.connection.should_receive(:delete).with("/index/node/some_index/some_key/some_value/42")
+        subject.remove_node_index_by_value("some_index", "42", "some_key", "some_value")
       end
 
       it "drops an index" do
-        connection.should_receive(:delete).with("/index/node/some_index")
-        subject.drop("some_index")
+        subject.connection.should_receive(:delete).with("/index/node/some_index")
+        subject.drop_node_index("some_index")
       end
 
     end

data/spec/unit/rest/node_paths_spec.rb

@@ -4,53 +4,50 @@ module Neography
   class Rest
     describe NodePaths do
 
-      let(:connection) { double(:configuration => "http://configuration") }
-      subject { NodePaths.new(connection) }
+      subject { Neography::Rest.new }
 
       it "gets a shortest path between two nodes" do
         expected_body = {
-          "to"            => "http://configuration/node/43",
+          "to"            => "http://localhost:7474/node/43",
           "relationships" => "relationships",
           "max_depth"     => 3,
           "algorithm"     => "shortestPath"
         }
 
-        connection.should_receive(:post).with("/node/42/path", json_match(:body, expected_body))
+        subject.connection.should_receive(:post).with("/node/42/path", json_match(:body, expected_body))
 
-        subject.get("42", "43", "relationships", 3, "shortestPath")
+        subject.get_path("42", "43", "relationships", 3, "shortestPath")
       end
 
       it "gets all shortest paths between two nodes" do
         expected_body = {
-          "to"            => "http://configuration/node/43",
+          "to"            => "http://localhost:7474/node/43",
           "relationships" => "relationships",
           "max_depth"     => 3,
           "algorithm"     => "shortestPath"
         }
 
-        connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
+        subject.connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
 
-        subject.get_all("42", "43", "relationships", 3, "shortestPath")
+        subject.get_paths("42", "43", "relationships", 3, "shortestPath")
       end
 
       it "gets all shortest weighted paths between two nodes" do
         expected_body = {
-          "to"            => "http://configuration/node/43",
+          "to"            => "http://localhost:7474/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.connection.should_receive(:post).with("/node/42/paths", json_match(:body, expected_body))
 
-        subject.shortest_weighted("42", "43", "relationships", "cost", 3, "shortestPath")
+        subject.get_shortest_weighted_path("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"

data/spec/unit/rest/node_properties_spec.rb

@@ -4,8 +4,7 @@ module Neography
   class Rest
     describe NodeProperties do
 
-      let(:connection) { double }
-      subject { NodeProperties.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("/node/42/properties/foo", options1)
-        connection.should_receive(:put).with("/node/42/properties/baz", options2)
-        subject.set("42", {:foo => "bar", :baz => "qux"})
+        subject.connection.should_receive(:put).with("/node/42/properties/foo", options1)
+        subject.connection.should_receive(:put).with("/node/42/properties/baz", options2)
+        subject.set_node_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("/node/42/properties", options)
-        subject.reset("42", {:foo => "bar"})
+        subject.connection.should_receive(:put).with("/node/42/properties", options)
+        subject.reset_node_properties("42", {:foo => "bar"})
       end
 
       context "getting properties" do
 
         it "gets all properties" do
-          connection.should_receive(:get).with("/node/42/properties")
-          subject.get("42")
+          subject.connection.should_receive(:get).with("/node/42/properties")
+          subject.get_node_properties("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")
+          subject.connection.should_receive(:get).with("/node/42/properties/foo")
+          subject.connection.should_receive(:get).with("/node/42/properties/bar")
+          subject.get_node_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_node_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_node_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_node_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("/node/42/properties")
-          subject.remove("42")
+          subject.connection.should_receive(:delete).with("/node/42/properties")
+          subject.remove_node_properties("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")
+          subject.connection.should_receive(:delete).with("/node/42/properties/foo")
+          subject.connection.should_receive(:delete).with("/node/42/properties/bar")
+          subject.remove_node_properties("42", "foo", "bar")
         end
 
       end

data/spec/unit/rest/node_relationships_spec.rb

@@ -4,73 +4,52 @@ module Neography
   class Rest
     describe NodeRelationships do
 
-      let(:connection) { double(:configuration => "http://configuration") }
-      subject { NodeRelationships.new(connection) }
+      subject { Neography::Rest.new }
 
       it "creates a relationship" do
         body_hash = { "type" => "some_type",
-          "to" => "http://configuration/node/43",
+          "to" => "http://localhost:7474/node/43",
           "data" => {"foo"=>"bar","baz"=>"qux"}
         }
-        connection.should_receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
+        subject.connection.should_receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
 
-        subject.create("some_type", "42", "43", {:foo => "bar", :baz => "qux"})
+        subject.create_relationship("some_type", "42", "43", {:foo => "bar", :baz => "qux"})
       end
 
       it "returns the post results" do
-        connection.stub(:post).and_return("foo")
+        subject.connection.stub(:post).and_return("foo")
 
-        subject.create("some_type", "42", "43", {}).should == "foo"
+        subject.create_relationship("some_type", "42", "43", {}).should == "foo"
       end
 
       it "gets relationships" do
-        connection.should_receive(:get).with("/node/42/relationships/all")
-        subject.get("42")
+        subject.connection.should_receive(:get).with("/node/42/relationships/all")
+        subject.get_node_relationships("42")
       end
 
       it "gets relationships with direction" do
-        connection.should_receive(:get).with("/node/42/relationships/in")
-        subject.get("42", :in)
+        subject.connection.should_receive(:get).with("/node/42/relationships/in")
+        subject.get_node_relationships("42", :in)
       end
 
       it "gets relationships with direction and type" do
-        connection.should_receive(:get).with("/node/42/relationships/in/foo")
-        subject.get("42", :in, "foo")
+        subject.connection.should_receive(:get).with("/node/42/relationships/in/foo")
+        subject.get_node_relationships("42", :in, "foo")
       end
 
       it "gets relationships with direction and types" do
-        connection.should_receive(:get).with("/node/42/relationships/in/foo%26bar")
-        subject.get("42", :in, ["foo", "bar"])
+        subject.connection.should_receive(:get).with("/node/42/relationships/in/foo%26bar")
+        subject.get_node_relationships("42", :in, ["foo", "bar"])
       end
 
       it "returns empty array if no relationships were found" do
-        connection.stub(:get).and_return([])
-        subject.get("42", :in).should be_empty
+        subject.connection.stub(:get).and_return([])
+        subject.get_node_relationships("42", :in).should be_empty
       end
 
       it "returns empty array if no relationships were found by type" do
-        connection.stub(:get).and_return([])
-        subject.get("42", :in, "foo")
-      end
-
-      context "directions" do
-
-        [ :incoming, "incoming", :in, "in" ].each do |direction|
-          it "parses 'in' direction" do
-            NodeRelationships.new(nil).parse_direction(direction).should == "in"
-          end
-        end
-
-        [ :outgoing, "outgoing", :out, "out" ].each do |direction|
-          it "parses 'out' direction" do
-            NodeRelationships.new(nil).parse_direction(direction).should == "out"
-          end
-        end
-
-        it "parses 'all' direction by default" do
-          NodeRelationships.new(nil).parse_direction("foo").should == "all"
-        end
-
+        subject.connection.stub(:get).and_return([])
+        subject.get_node_relationships("42", :in, "foo")
       end
 
     end

data/spec/unit/rest/node_traversal_spec.rb

@@ -4,9 +4,8 @@ module Neography
   class Rest
     describe NodeTraversal do
 
-      let(:connection) { double }
-      subject { NodeTraversal.new(connection) }
-
+      subject { Neography::Rest.new }
+      
       it "traverses" do
         description = {
           "order"           => :breadth,
@@ -26,102 +25,10 @@ module Neography
           "max_depth"       => 4
         }
 
-        connection.should_receive(:post).with("/node/42/traverse/relationship", json_match(:body, expected_body))
+        subject.connection.should_receive(:post).with("/node/42/traverse/relationship", json_match(:body, expected_body))
 
         subject.traverse("42", :relationship, description)
-      end
-
-      context "options" do
-        let(:traversal) { NodeTraversal.new(nil) }
-
-        context "order" do
-          [ :breadth, "breadth", "breadth first", "breadthFirst", :wide, "wide" ].each do |order|
-            it "parses breadth first" do
-              subject.send(:get_order, order).should == "breadth first"
-            end
-          end
-
-          it "parses depth first by default" do
-            subject.send(:get_order, "foo").should == "depth first"
-          end
-        end
-
-        context "uniqueness" do
-          [ :nodeglobal, "node global", "nodeglobal", "node_global" ].each do |order|
-            it "parses node global" do
-              subject.send(:get_uniqueness, order).should == "node global"
-            end
-          end
-
-          [ :nodepath, "node path", "nodepath", "node_path" ].each do |order|
-            it "parses node path" do
-              subject.send(:get_uniqueness, order).should == "node path"
-            end
-          end
-
-          [ :noderecent, "node recent", "noderecent", "node_recent" ].each do |order|
-            it "parses node recent" do
-              subject.send(:get_uniqueness, order).should == "node recent"
-            end
-          end
-
-          [ :relationshipglobal, "relationship global", "relationshipglobal", "relationship_global" ].each do |order|
-            it "parses relationship global" do
-              subject.send(:get_uniqueness, order).should == "relationship global"
-            end
-          end
-
-          [ :relationshippath, "relationship path", "relationshippath", "relationship_path" ].each do |order|
-            it "parses relationship path" do
-              subject.send(:get_uniqueness, order).should == "relationship path"
-            end
-          end
-
-          [ :relationshiprecent, "relationship recent", "relationshiprecent", "relationship_recent" ].each do |order|
-            it "parses relationship recent" do
-              subject.send(:get_uniqueness, order).should == "relationship recent"
-            end
-          end
-
-          it "parses none by default" do
-            subject.send(:get_uniqueness, "foo").should == "none"
-          end
-        end
-
-        context "depth" do
-          it "parses nil as nil" do
-            subject.send(:get_depth, nil).should be_nil
-          end
-          it "parses 0 as 1" do
-            subject.send(:get_depth, "0").should == 1
-          end
-          it "parses integers" do
-            subject.send(:get_depth, "42").should == 42
-          end
-        end
-
-        context "type" do
-          [ :relationship, "relationship", :relationships, "relationships" ].each do |type|
-            it "parses relationship" do
-              subject.send(:get_type, type).should == "relationship"
-            end
-          end
-          [ :path, "path", :paths, "paths" ].each do |type|
-            it "parses path" do
-              subject.send(:get_type, type).should == "path"
-            end
-          end
-          [ :fullpath, "fullpath", :fullpaths, "fullpaths" ].each do |type|
-            it "parses fullpath" do
-              subject.send(:get_type, type).should == "fullpath"
-            end
-          end
-
-          it "parses node by default" do
-            subject.send(:get_type, "foo").should == "node"
-          end
-        end
-      end
+      end      
 
     end
   end