neography-calamitates 1.2.3.1

data/spec/unit/rest/labels_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeLabels do
+
+      let(:connection) { double }
+      subject { NodeLabels.new(connection) }
+
+      it "list node labels" do
+        connection.should_receive(:get).with("/labels")
+        subject.list
+      end
+
+      it "get labels for node" do
+        connection.should_receive(:get).with("/node/0/labels")
+        subject.get(0)
+      end
+
+      it "get nodes for labels" do
+        connection.should_receive(:get).with("/label/person/nodes")
+        subject.get_nodes("person")
+      end
+
+      it "find nodes for labels and property" do
+        connection.should_receive(:get).with("/label/person/nodes?name=%22max%22")
+        subject.find_nodes("person", {:name => "max"})
+      end
+
+      it "can add a label to a node" do
+        options = {
+          :body    => '["Actor"]',
+          :headers => json_content_type
+        }
+        connection.should_receive(:post).with("/node/0/labels", options)
+        subject.add(0, ["Actor"])
+      end
+
+      it "can add labels to a node" do
+        options = {
+          :body    => '["Actor","Director"]',
+          :headers => json_content_type
+        }
+        connection.should_receive(:post).with("/node/0/labels", options)
+        subject.add(0, ["Actor", "Director"])
+      end
+
+      it "can set a label to a node" do
+        options = {
+          :body    => '["Actor"]',
+          :headers => json_content_type
+        }
+        connection.should_receive(:put).with("/node/0/labels", options)
+        subject.set(0, ["Actor"])
+      end
+
+      it "can add labels to a node" do
+        options = {
+          :body    => '["Actor","Director"]',
+          :headers => json_content_type
+        }
+        connection.should_receive(:put).with("/node/0/labels", options)
+        subject.set(0, ["Actor", "Director"])
+      end
+      
+      it "can delete a label from a node" do
+        connection.should_receive(:delete).with("/node/0/labels/Actor")
+        subject.delete(0,"Actor")
+      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) { double }
+      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,141 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeIndexes do
+
+      let(:connection) { double(: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 "gets or 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?uniqueness=get_or_create", json_match(:body, expected_body))
+        subject.get_or_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
+
+      it "drops an index" do
+        connection.should_receive(:delete).with("/index/node/some_index")
+        subject.drop("some_index")
+      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) { double(: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) { double }
+      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

data/spec/unit/rest/node_relationships_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeRelationships do
+
+      let(:connection) { double(:configuration => "http://configuration") }
+      subject { NodeRelationships.new(connection) }
+
+      it "creates a relationship" do
+        body_hash = { "type" => "some_type",
+          "to" => "http://configuration/node/43",
+          "data" => {"foo"=>"bar","baz"=>"qux"}
+        }
+        connection.should_receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
+
+        subject.create("some_type", "42", "43", {:foo => "bar", :baz => "qux"})
+      end
+
+      it "returns the post results" do
+        connection.stub(:post).and_return("foo")
+
+        subject.create("some_type", "42", "43", {}).should == "foo"
+      end
+
+      it "gets relationships" do
+        connection.should_receive(:get).with("/node/42/relationships/all")
+        subject.get("42")
+      end
+
+      it "gets relationships with direction" do
+        connection.should_receive(:get).with("/node/42/relationships/in")
+        subject.get("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")
+      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"])
+      end
+
+      it "returns nil if no relationships were found" do
+        connection.stub(:get).and_return(nil)
+        subject.get("42", :in).should be_nil
+      end
+
+      it "returns nil if no relationships were found by type" do
+        connection.stub(:get).and_return(nil)
+        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
+
+      end
+
+    end
+  end
+end