neography-down 1.6.4

data/spec/unit/rest/batch_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Batch do
+
+      subject { Neography::Rest.new }
+
+      it "gets nodes" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/node/foo" },
+          { "id" => 1, "method" => "GET", "to" => "/node/bar" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:get_node, "foo"], [:get_node, "bar"]
+      end
+
+      it "gets nodes without symbol" do
+        expected_body = [
+          { "id" => 0, "method" => "GET", "to" => "/node/foo" },
+          { "id" => 1, "method" => "GET", "to" => "/node/bar" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch ["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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:reset_node_properties, "index1", { "key1" => "value1" } ],
+                        [:reset_node_properties, "index2", { "key2" => "value2" } ]
+      end
+
+      it "adds a node label" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "{0}/labels", "body" => "foo" },
+          { "id" => 1, "method" => "POST", "to" => "{0}/labels", "body" => "bar" },
+        ]
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:add_label, "{0}", "foo"],
+                        [:add_label, "{0}", "bar"]
+      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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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", "properties" => "properties" } },
+          { "id" => 1, "method" => "POST", "to" => "/index/relationship/index2?unique", "body" => { "key" => "key2", "value" => "value2", "type" => "type2", "start" => "{0}", "end" => "{1}", "properties" => "properties" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:create_unique_relationship, "index1", "key1", "value1", "type1", "node1", "node2","properties"  ],
+                        [:create_unique_relationship, "index2", "key2", "value2", "type2", "{0}", "{1}", "properties" ]
+      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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [: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" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:reset_relationship_properties, "index1", { "key1" => "value1" } ],
+                        [:reset_relationship_properties, "{0}", { "key2" => "value2" } ]
+      end
+
+      it "batchs scripts" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/ext/GremlinPlugin/graphdb/execute_script", "body" => { "script" => "script1", "params" => "params1" } },
+          { "id" => 1, "method" => "POST", "to" => "/ext/GremlinPlugin/graphdb/execute_script", "body" => { "script" => "script2", "params" => "params2" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:execute_script, "script1", "params1"],
+                        [:execute_script, "script2", "params2"]
+      end
+
+      it "batchs queries" do
+        expected_body = [
+          { "id" => 0, "method" => "POST", "to" => "/cypher", "body" => { "query" => "query1", "params" => "params1" } },
+          { "id" => 1, "method" => "POST", "to" => "/cypher", "body" => { "query" => "query2" } }
+        ]
+
+        expect(subject.connection).to receive(:post).with("/batch", json_match(:body, expected_body))
+        subject.batch [:execute_query, "query1", "params1"],
+                        [:execute_query, "query2" ]
+      end
+
+    end
+  end
+end
+

data/spec/unit/rest/clean_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Clean do
+
+      subject { Neography::Rest.new }
+
+      it "cleans the database" do
+        expect(subject.connection).to receive(:delete).with("/cleandb/secret-key")
+        subject.clean_database("yes_i_really_want_to_clean_the_database")
+      end
+
+    end
+  end
+end

data/spec/unit/rest/constraints_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Constraints do
+
+      subject { Neography::Rest.new }
+
+      it "list constraints" do
+        expect(subject.connection).to receive(:get).with("/schema/constraint/")
+        subject.get_constraints
+      end
+
+      it "get constraints for a label" do
+        expect(subject.connection).to receive(:get).with("/schema/constraint/label")
+        subject.get_constraints("label")
+      end
+
+      it "create a unique constraint for a label" do
+        options = {
+            :body    => '{"property_keys":["property"]}',
+            :headers => json_content_type
+          }
+        expect(subject.connection).to receive(:post).with("/schema/constraint/label/uniqueness/", options)
+        subject.create_unique_constraint("label", "property")
+      end
+      
+      it "get unique constraints for a label" do
+        expect(subject.connection).to receive(:get).with("/schema/constraint/label/uniqueness/")
+        subject.get_uniqueness("label")
+      end
+
+      it "get a specific unique constraint for a label" do
+        expect(subject.connection).to receive(:get).with("/schema/constraint/label/uniqueness/property")
+        subject.get_unique_constraint("label", "property")
+      end
+      
+      it "can delete a constraint for a label" do
+        expect(subject.connection).to receive(:delete).with("/schema/constraint/label/uniqueness/property")
+        subject.drop_constraint("label","property")
+      end
+      
+    end
+  end
+end  

data/spec/unit/rest/cypher_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Cypher do
+
+      subject { Neography::Rest.new }
+
+      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;charset=UTF-8"}
+        }
+        expect(subject.connection).to receive(:post).with("/cypher", options)
+        subject.execute_query("SOME QUERY", { :foo => "bar", :baz => "qux" })
+      end
+
+    end
+  end
+end

data/spec/unit/rest/extensions_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Extensions do
+
+      subject { Neography::Rest.new }
+
+      it "executes an extensions get query" do
+        path = "/unmanaged_extension/test"
+
+        expect(subject.connection).to receive(:get).with(path)
+        subject.get_extension("/unmanaged_extension/test")
+      end
+
+      it "executes an extensions post query" do
+        path = "/unmanaged_extension/test"
+        options = {
+          :body=>"{\"foo\":\"bar\",\"baz\":\"qux\"}",
+          :headers=>{"Content-Type"=>"application/json", "Accept"=>"application/json;stream=true"}
+        }
+        expect(subject.connection).to receive(:post).with(path, options)
+        subject.post_extension("/unmanaged_extension/test", { :foo => "bar", :baz => "qux" })
+      end
+
+    end
+  end
+end

data/spec/unit/rest/gremlin_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Gremlin do
+
+      subject { Neography::Rest.new }
+
+      it "executes a gremlin script" do
+        options = {
+          :body=>"{\"script\":\"SOME SCRIPT\",\"params\":{\"foo\":\"bar\",\"baz\":\"qux\"}}",
+          :headers=>{"Content-Type"=>"application/json"}
+        }
+        expect(subject.connection).to receive(:post).with("/ext/GremlinPlugin/graphdb/execute_script", options)
+        subject.execute_script("SOME SCRIPT", { :foo => "bar", :baz => "qux" })
+      end
+
+      it "returns nil if script result is null" do
+        allow(subject.connection).to receive(:post).and_return("null")
+        expect(subject.execute_script("", {})).to be_nil
+      end
+
+    end
+  end
+end

data/spec/unit/rest/helpers_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Helpers do
+
+      subject { Neography::Rest.new }
+
+      context "directions" do
+
+        [ :incoming, "incoming", :in, "in" ].each do |direction|
+          it "parses 'in' direction" do
+            expect(subject.parse_direction(direction)).to eq("in")
+          end
+        end
+
+        [ :outgoing, "outgoing", :out, "out" ].each do |direction|
+          it "parses 'out' direction" do
+            expect(subject.parse_direction(direction)).to eq("out")
+          end
+        end
+
+        it "parses 'all' direction by default" do
+          expect(subject.parse_direction("foo")).to eq("all")
+        end
+
+      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
+              expect(subject.send(:parse_order, order)).to eq("breadth first")
+            end
+          end
+
+          it "parses depth first by default" do
+            expect(subject.send(:parse_order, "foo")).to eq("depth first")
+          end
+        end
+
+        context "uniqueness" do
+          [ :nodeglobal, "node global", "nodeglobal", "node_global" ].each do |order|
+            it "parses node global" do
+              expect(subject.send(:parse_uniqueness, order)).to eq("node global")
+            end
+          end
+
+          [ :nodepath, "node path", "nodepath", "node_path" ].each do |order|
+            it "parses node path" do
+              expect(subject.send(:parse_uniqueness, order)).to eq("node path")
+            end
+          end
+
+          [ :noderecent, "node recent", "noderecent", "node_recent" ].each do |order|
+            it "parses node recent" do
+              expect(subject.send(:parse_uniqueness, order)).to eq("node recent")
+            end
+          end
+
+          [ :relationshipglobal, "relationship global", "relationshipglobal", "relationship_global" ].each do |order|
+            it "parses relationship global" do
+              expect(subject.send(:parse_uniqueness, order)).to eq("relationship global")
+            end
+          end
+
+          [ :relationshippath, "relationship path", "relationshippath", "relationship_path" ].each do |order|
+            it "parses relationship path" do
+              expect(subject.send(:parse_uniqueness, order)).to eq("relationship path")
+            end
+          end
+
+          [ :relationshiprecent, "relationship recent", "relationshiprecent", "relationship_recent" ].each do |order|
+            it "parses relationship recent" do
+              expect(subject.send(:parse_uniqueness, order)).to eq("relationship recent")
+            end
+          end
+
+          it "parses none by default" do
+            expect(subject.send(:parse_uniqueness, "foo")).to eq("none")
+          end
+        end
+
+        context "depth" do
+          it "parses nil as nil" do
+            expect(subject.send(:parse_depth, nil)).to be_nil
+          end
+          it "parses 0 as 1" do
+            expect(subject.send(:parse_depth, "0")).to eq(1)
+          end
+          it "parses integers" do
+            expect(subject.send(:parse_depth, "42")).to eq(42)
+          end
+        end
+
+        context "type" do
+          [ :relationship, "relationship", :relationships, "relationships" ].each do |type|
+            it "parses relationship" do
+              expect(subject.send(:parse_type, type)).to eq("relationship")
+            end
+          end
+          [ :path, "path", :paths, "paths" ].each do |type|
+            it "parses path" do
+              expect(subject.send(:parse_type, type)).to eq("path")
+            end
+          end
+          [ :fullpath, "fullpath", :fullpaths, "fullpaths" ].each do |type|
+            it "parses fullpath" do
+              expect(subject.send(:parse_type, type)).to eq("fullpath")
+            end
+          end
+
+          it "parses node by default" do
+            expect(subject.send(:parse_type, "foo")).to eq("node")
+          end
+        end
+      end      
+
+
+    end
+  end
+end