neography 0.0.31 → 1.0.0

data/spec/unit/rest/node_relationships_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeRelationships do
+
+      let(:connection) { stub(: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&bar")
+        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

data/spec/unit/rest/node_traversal_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe NodeTraversal do
+
+      let(:connection) { stub }
+      subject { NodeTraversal.new(connection) }
+
+      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
+        }
+
+        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

data/spec/unit/rest/nodes_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe Nodes do
+
+      let(:connection) { stub }
+      subject { Nodes.new(connection) }
+
+      context "get nodes" do
+        it "gets single nodes" do
+          connection.should_receive(:get).with("/node/42")
+          subject.get("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")
+        end
+
+        it "returns multiple nodes in an array" do
+          connection.stub(:get).and_return("foo", "bar")
+          subject.get_each("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
+        end
+
+        it "returns the root node" do
+          connection.stub(:get).and_return({ "reference_node" => "42" }, "foo")
+          subject.root.should == "foo"
+        end
+      end
+
+      context "create nodes" do
+
+        it "creates with attributes" do
+          options = {
+            :body    => '{"foo":"bar","baz":"qux"}',
+            :headers => json_content_type
+          }
+          connection.should_receive(:post).with("/node", options)
+          subject.create_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"
+        end
+
+        it "creates with attributes using #create method" do
+          options = {
+            :body    => '{"foo":"bar","baz":"qux"}',
+            :headers => json_content_type
+          }
+          connection.should_receive(:post).with("/node", options)
+          subject.create({:foo => "bar", :baz => "qux"})
+        end
+
+        it "creates empty nodes" do
+          connection.should_receive(:post).with("/node")
+          subject.create_empty
+        end
+
+        it "returns an empty node" do
+          connection.stub(:post).and_return("foo")
+          subject.create_empty.should == "foo"
+        end
+
+        it "creates empty nodes using #create method" do
+          connection.should_receive(:post).with("/node")
+          subject.create
+        end
+
+      end
+
+      context "delete nodes" do
+
+        it "deletes a node" do
+          connection.should_receive(:delete).with("/node/42")
+          subject.delete("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
+          }
+          connection.should_receive(:post).with("/node", options1)
+          connection.should_receive(:post).with("/node", options2)
+
+          subject.create_multiple([
+            {: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"]
+        end
+
+        # exotic?
+        it "creates multiple with and without attributes" do
+          options1 = {
+            :body    => '{"foo1":"bar1","baz1":"qux1"}',
+            :headers => json_content_type
+          }
+          connection.should_receive(:post).with("/node", options1)
+          connection.should_receive(:post).with("/node")
+
+          subject.create_multiple([
+            {: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)
+        end
+
+        it "returns multiple empty nodes in an array" do
+          connection.stub(:post).and_return("foo", "bar")
+          subject.create_multiple(2).should == ["foo", "bar"]
+        end
+
+      end
+
+      context "#create_multiple_threaded" do
+
+        let(:connection) { stub(: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
+          }
+          connection.should_receive(:post).with("/node", options1)
+          connection.should_receive(:post).with("/node", options2)
+
+          subject.create_multiple_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
+          }
+          connection.should_receive(:post).with("/node", options1)
+          connection.should_receive(:post).with("/node")
+
+          subject.create_multiple_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)
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/rest/paths_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+
+    class Dummy
+      extend Paths
+
+      add_path :one, "/node/:id"
+      add_path :two, "/node/:id/properties/:property"
+    end
+
+    describe Dummy do
+
+      context "instance methods" do
+
+        it { should respond_to(:one_path) }
+        it { should respond_to(:two_path) }
+
+        it "replaces a key" do
+          subject.one_path(:id => 42).should == "/node/42"
+        end
+
+        it "replaces multiple keys" do
+          subject.two_path(:id => 42, :property => "foo").should == "/node/42/properties/foo"
+        end
+
+        it "url encodes spaces" do
+          subject.one_path(:id => "with space").should == "/node/with%20space"
+        end
+
+        # URI.encode does not escape slashes (and rightly so), but should escape these keys
+        it "url encodes slashes" do
+          subject.one_path(:id => "with/slash").should == "/node/with%2Fslash"
+        end
+
+      end
+
+      context "class methods" do
+
+        subject { Dummy }
+
+        it { should respond_to(:one_path) }
+        it { should respond_to(:two_path) }
+
+        it "replaces a key" do
+          subject.one_path(:id => 42).should == "/node/42"
+        end
+
+        it "replaces multiple keys" do
+          subject.two_path(:id => 42, :property => "foo").should == "/node/42/properties/foo"
+        end
+
+        it "url encodes spaces" do
+          subject.one_path(:id => "with space").should == "/node/with%20space"
+        end
+
+        # URI.encode does not escape slashes (and rightly so), but should escape these keys
+        it "url encodes slashes" do
+          subject.one_path(:id => "with/slash").should == "/node/with%2Fslash"
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/spec/unit/rest/relationship_auto_indexes_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe RelationshipAutoIndexes do
+
+      let(:connection) { stub }
+      subject { RelationshipAutoIndexes.new(connection) }
+
+      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")
+      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/relationship/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/relationship/?query=some_query")
+        subject.find_or_query("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")
+      end
+
+      it "finds by query" do
+        connection.should_receive(:get).with("/index/auto/relationship/?query=some_query")
+        subject.query("some_query")
+      end
+
+      it "gets the status" do
+        connection.should_receive(:get).with("/index/auto/relationship/status")
+        subject.status
+      end
+
+      it "sets the status" do
+        connection.should_receive(:put).with("/index/auto/relationship/status", hash_match(:body, '"foo"'))
+        subject.status = "foo"
+      end
+
+      it "gets auto index properties" do
+        connection.should_receive(:get).with("/index/auto/relationship/properties")
+        subject.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")
+      end
+
+      it "removes a property from an auto index" do
+        connection.should_receive(:delete).with("/index/auto/relationship/properties/foo")
+        subject.remove_property("foo")
+      end
+
+    end
+  end
+end

data/spec/unit/rest/relationship_indexes_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+module Neography
+  class Rest
+    describe RelationshipIndexes do
+
+      let(:connection) { stub(:configuration => "http://configuration") }
+      subject { RelationshipIndexes.new(connection) }
+
+      it "lists all indexes" do
+        connection.should_receive(:get).with("/index/relationship")
+        subject.list
+      end
+
+      it "creates a relationship index" do
+        expected_body = {
+          "config" => {
+            "type" => "some_type",
+            "provider" => "some_provider"
+          },
+          "name" => "some_index"
+        }
+        connection.should_receive(:post).with("/index/relationship", 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" => "relationship_auto_index"
+        }
+        connection.should_receive(:post).with("/index/relationship", json_match(:body, expected_body))
+        subject.create_auto("some_type", "some_provider")
+      end
+
+      it "creates a unique relationship in an index" do
+        expected_body = {
+          "key"        => "key",
+          "value"      => "value",
+          "type"       => "type",
+          "start"      => "http://configuration/node/42",
+          "end"        => "http://configuration/node/43"
+        }
+        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")
+      end
+
+      it "adds a relationship to an index" do
+        expected_body = {
+          "uri" => "http://configuration/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")
+      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")
+      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/relationship/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/relationship/some_index?query=some_query")
+        subject.find("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")
+      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")
+      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")
+      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")
+      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")
+      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")
+      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")
+      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")
+      end
+
+    end
+  end
+end