neography-down 1.6.4

data/spec/unit/rest/node_relationships_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeRelationships do
+
+      subject { Neography::Rest.new }
+
+      it "creates a relationship" do
+        body_hash = { "type" => "some_type",
+          "to" => "http://localhost:7474/node/43",
+          "data" => {"foo"=>"bar","baz"=>"qux"}
+        }
+        expect(subject.connection).to receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
+
+        subject.create_relationship("some_type", "42", "43", {:foo => "bar", :baz => "qux"})
+      end
+
+      it "returns the post results" do
+        allow(subject.connection).to receive(:post).and_return("foo")
+
+        expect(subject.create_relationship("some_type", "42", "43", {})).to eq("foo")
+      end
+
+      it "gets relationships" do
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/all")
+        subject.get_node_relationships("42")
+      end
+
+      it "gets relationships with direction" do
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/in")
+        subject.get_node_relationships("42", :in)
+      end
+
+      it "gets relationships with direction and type" do
+        expect(subject.connection).to receive(:get).with("/node/42/relationships/in/foo")
+        subject.get_node_relationships("42", :in, "foo")
+      end
+
+      it "gets relationships with direction and types" do
+        expect(subject.connection).to 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
+        allow(subject.connection).to receive(:get).and_return([])
+        expect(subject.get_node_relationships("42", :in)).to be_empty
+      end
+
+      it "returns empty array if no relationships were found by type" do
+        allow(subject.connection).to receive(:get).and_return([])
+        subject.get_node_relationships("42", :in, "foo")
+      end
+
+    end
+  end
+end

data/spec/unit/rest/node_traversal_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeTraversal do
+
+      subject { Neography::Rest.new }
+      
+      it "traverses" do
+        description = {
+          "order"           => :breadth,
+          "uniqueness"      => :nodeglobal,
+          "relationships"   => "relationships",
+          "prune evaluator" => "prune_evaluator",
+          "return filter"   => "return_filter",
+          "depth"           => 4
+        }
+
+        expected_body = {
+          "order"           => "breadth first",
+          "uniqueness"      => "node global",
+          "relationships"   => "relationships",
+          "prune_evaluator" => "prune_evaluator",
+          "return_filter"   => "return_filter",
+          "max_depth"       => 4
+        }
+
+        expect(subject.connection).to receive(:post).with("/node/42/traverse/relationship", json_match(:body, expected_body))
+
+        subject.traverse("42", :relationship, description)
+      end      
+
+    end
+  end
+end

data/spec/unit/rest/nodes_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Nodes do
+
+      subject { Neography::Rest.new }
+
+      context "get nodes" do
+        it "gets single nodes" do
+          expect(subject.connection).to receive(:get).with("/node/42")
+          subject.get_node("42")
+        end
+
+        it "gets multiple nodes" do
+          expect(subject.connection).to receive(:get).with("/node/42")
+          expect(subject.connection).to receive(:get).with("/node/43")
+          subject.get_nodes("42", "43")
+        end
+
+        it "returns multiple nodes in an array" do
+          allow(subject.connection).to receive(:get).and_return("foo", "bar")
+          expect(subject.get_nodes("42", "43")).to eq([ "foo", "bar" ])
+        end
+
+        it "gets the root node" do
+          allow(subject.connection).to receive(:get).with("/").and_return({ "reference_node" => "42" })
+          expect(subject.connection).to receive(:get).with("/node/42")
+          subject.get_root
+        end
+
+        it "returns the root node" do
+          allow(subject.connection).to receive(:get).and_return({ "reference_node" => "42" }, "foo")
+          expect(subject.get_root).to eq("foo")
+        end
+      end
+
+      context "create nodes" do
+
+        it "creates with attributes" do
+          options = {
+            :body    => '{"foo":"bar","baz":"qux"}',
+            :headers => json_content_type
+          }
+          expect(subject.connection).to receive(:post).with("/node", options)
+          subject.create_node_with_attributes({:foo => "bar", :baz => "qux"})
+        end
+
+        it "returns the created node" do
+          allow(subject.connection).to receive(:post).and_return("foo")
+          expect(subject.create_node_with_attributes({})).to eq("foo")
+        end
+
+        it "creates with attributes using #create method" do
+          options = {
+            :body    => '{"foo":"bar","baz":"qux"}',
+            :headers => json_content_type
+          }
+          expect(subject.connection).to receive(:post).with("/node", options)
+          subject.create_node({:foo => "bar", :baz => "qux"})
+        end
+
+        it "creates empty nodes" do
+          expect(subject.connection).to receive(:post).with("/node")
+          subject.create_empty_node
+        end
+
+        it "returns an empty node" do
+          allow(subject.connection).to receive(:post).and_return("foo")
+          expect(subject.create_empty_node).to eq("foo")
+        end
+
+        it "creates empty nodes using #create method" do
+          expect(subject.connection).to receive(:post).with("/node")
+          subject.create_node
+        end
+
+      end
+
+      context "delete nodes" do
+
+        it "deletes a node" do
+          expect(subject.connection).to receive(:delete).with("/node/42")
+          subject.delete_node("42")
+        end
+
+      end
+
+      context "#create_multiple" do
+
+        it "creates multiple with attributes" do
+          options1 = {
+            :body    => '{"foo1":"bar1","baz1":"qux1"}',
+            :headers => json_content_type
+          }
+          options2 = {
+            :body    => '{"foo2":"bar2","baz2":"qux2"}',
+            :headers => json_content_type
+          }
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node", options2)
+
+          subject.create_nodes([
+            {:foo1 => "bar1", :baz1 => "qux1"},
+            {:foo2 => "bar2", :baz2 => "qux2"}
+          ])
+        end
+
+        it "returns multiple nodes with attributes in an array" do
+          allow(subject.connection).to receive(:post).and_return("foo", "bar")
+          expect(subject.create_nodes([{},{}])).to eq(["foo", "bar"])
+        end
+
+        # exotic?
+        it "creates multiple with and without attributes" do
+          options1 = {
+            :body    => '{"foo1":"bar1","baz1":"qux1"}',
+            :headers => json_content_type
+          }
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node")
+
+          subject.create_nodes([
+            {:foo1 => "bar1", :baz1 => "qux1"},
+            "not a hash" # ?
+          ])
+        end
+
+        it "creates multiple empty nodes" do
+          expect(subject.connection).to receive(:post).with("/node").twice
+          subject.create_nodes(2)
+        end
+
+        it "returns multiple empty nodes in an array" do
+          allow(subject.connection).to receive(:post).and_return("foo", "bar")
+          expect(subject.create_nodes(2)).to eq(["foo", "bar"])
+        end
+
+      end
+
+      context "#create_multiple_threaded" do
+
+        let(:connection) { double(:max_threads => 2) }
+
+        it "creates multiple with attributes" do
+          options1 = {
+            :body    => '{"foo1":"bar1","baz1":"qux1"}',
+            :headers => json_content_type
+          }
+          options2 = {
+            :body    => '{"foo2":"bar2","baz2":"qux2"}',
+            :headers => json_content_type
+          }
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node", options2)
+
+          subject.create_nodes_threaded([
+            {:foo1 => "bar1", :baz1 => "qux1"},
+            {:foo2 => "bar2", :baz2 => "qux2"}
+          ])
+        end
+
+        # exotic?
+        it "creates multiple with and without attributes" do
+          options1 = {
+            :body    => '{"foo1":"bar1","baz1":"qux1"}',
+            :headers => json_content_type
+          }
+          expect(subject.connection).to receive(:post).with("/node", options1)
+          expect(subject.connection).to receive(:post).with("/node")
+
+          subject.create_nodes_threaded([
+            {:foo1 => "bar1", :baz1 => "qux1"},
+            "not a hash" # ?
+          ])
+        end
+
+        it "creates multiple empty nodes" do
+          expect(subject.connection).to receive(:post).with("/node").twice
+          subject.create_nodes_threaded(2)
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/rest/relationship_auto_indexes_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe RelationshipAutoIndexes do
+
+      subject { Neography::Rest.new }
+
+      it "gets a relationship from an auto index" do
+        expect(subject.connection).to 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
+        allow(subject.connection).to receive(:get).and_return(nil)
+        expect(subject.get_relationship_auto_index("some_key", "some_value")).to be_nil
+      end
+
+      it "finds by key and value if value passed to #find_or_query" do
+        expect(subject.connection).to 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
+        expect(subject.connection).to receive(:get).with("/index/auto/relationship/?query=some_query")
+        subject.find_relationship_auto_index("some_query")
+      end
+
+      it "finds by key and value" do
+        expect(subject.connection).to 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
+        expect(subject.connection).to receive(:get).with("/index/auto/relationship/?query=some_query")
+        subject.find_relationship_auto_index("some_query")
+      end
+
+      it "gets the status" do
+        expect(subject.connection).to receive(:get).with("/index/auto/relationship/status")
+        subject.get_relationship_auto_index_status
+      end
+
+      it "sets the status" do
+        expect(subject.connection).to 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
+        expect(subject.connection).to receive(:get).with("/index/auto/relationship/properties")
+        subject.get_relationship_auto_index_properties
+      end
+
+      it "adds a property to an auto index" do
+        expect(subject.connection).to 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
+        expect(subject.connection).to receive(:delete).with("/index/auto/relationship/properties/foo")
+        subject.remove_relationship_auto_index_property("foo")
+      end
+
+    end
+  end
+end

data/spec/unit/rest/relationship_indexes_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe RelationshipIndexes do
+
+      subject { Neography::Rest.new }
+
+      it "lists all indexes" do
+        expect(subject.connection).to receive(:get).with("/index/relationship")
+        subject.list_relationship_indexes
+      end
+
+      it "creates a relationship index" do
+        expected_body = {
+          "config" => {
+            "type" => "some_type",
+            "provider" => "some_provider"
+          },
+          "name" => "some_index"
+        }
+        expect(subject.connection).to 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
+        allow(subject.connection).to receive(:post).and_return("foo")
+        expect(subject.create_relationship_index("some_index", "some_type", "some_provider")).to eq("foo")
+      end
+
+      it "creates an auto-index" do
+        expected_body = {
+          "config" => {
+            "type" => "some_type",
+            "provider" => "some_provider"
+          },
+          "name" => "relationship_auto_index"
+        }
+        expect(subject.connection).to 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
+        expected_body = {
+          "key"        => "key",
+          "value"      => "value",
+          "type"       => "type",
+          "start"      => "http://localhost:7474/node/42",
+          "end"        => "http://localhost:7474/node/43",
+          "properties" => "properties"
+        }
+        expect(subject.connection).to 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://localhost:7474/relationship/42",
+          "key" => "key",
+          "value" => "value"
+        }
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        allow(subject.connection).to receive(:get).and_return(nil)
+        expect(subject.get_relationship_index("some_index", "some_key", "some_value")).to be_nil
+      end
+
+      it "finds by key and value if both passed to #find" do
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to 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
+        expect(subject.connection).to receive(:delete).with("/index/relationship/some_index")
+        subject.drop_relationship_index("some_index")
+      end
+    end
+  end
+end