neography 1.5.0 → 1.5.1

data/spec/integration/node_path_spec.rb

@@ -21,8 +21,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.all_paths_to(mary).incoming(:friends).depth(4).nodes.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_true}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be false}
       end
     end
 
@@ -30,8 +30,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.all_paths_to(mary).incoming(:friends).depth(4).rels.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_false}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be true}
       end
     end
 
@@ -41,9 +41,9 @@ describe Neography::NodePath do
       johnathan.all_paths_to(mary).incoming(:friends).depth(4).each do |path|
         path.each_with_index do  |n,i| 
           if i.even?
-            n.is_a?(Neography::Node).should be_true
+            expect(n.is_a?(Neography::Node)).to be true
           else
-            n.is_a?(Neography::Relationship).should be_true 
+            expect(n.is_a?(Neography::Relationship)).to be true 
           end
         end
       end
@@ -55,8 +55,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).nodes.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_true}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be false}
       end
     end
 
@@ -64,8 +64,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).rels.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_false}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be true}
       end
     end
 
@@ -75,9 +75,9 @@ describe Neography::NodePath do
       johnathan.all_simple_paths_to(mary).incoming(:friends).depth(4).each do |path|
         path.each_with_index do  |n,i| 
           if i.even?
-            n.is_a?(Neography::Node).should be_true
+            expect(n.is_a?(Neography::Node)).to be true
           else
-            n.is_a?(Neography::Relationship).should be_true 
+            expect(n.is_a?(Neography::Relationship)).to be true 
           end
         end
       end
@@ -89,8 +89,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.all_shortest_paths_to(mary).incoming(:friends).depth(4).nodes.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_true}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be false}
       end
     end
 
@@ -98,8 +98,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.all_shortest_paths_to(mary).incoming(:friends).depth(4).rels.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_false}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be true}
       end
     end
 
@@ -109,9 +109,9 @@ describe Neography::NodePath do
       johnathan.all_shortest_paths_to(mary).incoming(:friends).depth(4).each do |path|
         path.each_with_index do  |n,i| 
           if i.even?
-            n.is_a?(Neography::Node).should be_true
+            expect(n.is_a?(Neography::Node)).to be true
           else
-            n.is_a?(Neography::Relationship).should be_true 
+            expect(n.is_a?(Neography::Relationship)).to be true 
           end
         end
       end
@@ -123,8 +123,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.path_to(mary).incoming(:friends).depth(4).nodes.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_true}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be false}
       end
     end
 
@@ -132,8 +132,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.path_to(mary).incoming(:friends).depth(4).rels.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_false}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be true}
       end
     end
 
@@ -143,9 +143,9 @@ describe Neography::NodePath do
       johnathan.path_to(mary).incoming(:friends).depth(4).each do |path|
         path.each_with_index do  |n,i| 
           if i.even?
-            n.is_a?(Neography::Node).should be_true
+            expect(n.is_a?(Neography::Node)).to be true
           else
-            n.is_a?(Neography::Relationship).should be_true 
+            expect(n.is_a?(Neography::Relationship)).to be true 
           end
         end
       end
@@ -157,8 +157,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.simple_path_to(mary).incoming(:friends).depth(4).nodes.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_true}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be false}
       end
     end
 
@@ -166,8 +166,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.simple_path_to(mary).incoming(:friends).depth(4).rels.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_false}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be true}
       end
     end
 
@@ -177,9 +177,9 @@ describe Neography::NodePath do
       johnathan.simple_path_to(mary).incoming(:friends).depth(4).each do |path|
         path.each_with_index do  |n,i| 
           if i.even?
-            n.is_a?(Neography::Node).should be_true
+            expect(n.is_a?(Neography::Node)).to be true
           else
-            n.is_a?(Neography::Relationship).should be_true 
+            expect(n.is_a?(Neography::Relationship)).to be true 
           end
         end
       end
@@ -191,8 +191,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.shortest_path_to(mary).incoming(:friends).depth(4).nodes.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_true}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_false}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be true}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be false}
       end
     end
 
@@ -200,8 +200,8 @@ describe Neography::NodePath do
       johnathan, mark, phill, mary = create_nodes
 
       johnathan.shortest_path_to(mary).incoming(:friends).depth(4).rels.each do |path|
-         path.map{|n| n.is_a?(Neography::Node).should be_false}
-         path.map{|n| n.is_a?(Neography::Relationship).should be_true}
+         path.map{|n| expect(n.is_a?(Neography::Node)).to be false}
+         path.map{|n| expect(n.is_a?(Neography::Relationship)).to be true}
       end
     end
 
@@ -211,9 +211,9 @@ describe Neography::NodePath do
       johnathan.shortest_path_to(mary).incoming(:friends).depth(4).each do |path|
         path.each_with_index do  |n,i| 
           if i.even?
-            n.is_a?(Neography::Node).should be_true
+            expect(n.is_a?(Neography::Node)).to be true
           else
-            n.is_a?(Neography::Relationship).should be_true 
+            expect(n.is_a?(Neography::Relationship)).to be true 
           end
         end
       end

data/spec/integration/node_relationship_spec.rb

@@ -38,7 +38,7 @@ describe Neography::NodeRelationship do
       a.outgoing(:friends) << other_node
 
       # then
-      a.outgoing(:friends).first.should == other_node
+      expect(a.outgoing(:friends).first).to eq(other_node)
     end
 
     it "#outgoing(:friends) << b << c creates an outgoing relationship of type :friends" do
@@ -50,46 +50,46 @@ describe Neography::NodeRelationship do
       a.outgoing(:friends) << b << c
 
       # then
-      a.outgoing(:friends).should include(b,c)
+      expect(a.outgoing(:friends)).to include(b,c)
     end
 
     it "#outgoing returns all incoming nodes of any type" do
       a,b,c,d,e,f = create_nodes
 
-      b.outgoing.should include(c,f,d)
-      [*b.outgoing].size.should == 4 #c is related by both work and friends
+      expect(b.outgoing).to include(c,f,d)
+      expect([*b.outgoing].size).to eq(4) #c is related by both work and friends
     end
 
     it "#outgoing(type) should only return outgoing nodes of the given type of depth one" do
       a,b,c,d = create_nodes
-      b.outgoing(:work).should include(c,d)
-      [*b.outgoing(:work)].size.should == 2
+      expect(b.outgoing(:work)).to include(c,d)
+      expect([*b.outgoing(:work)].size).to eq(2)
     end
 
     it "#outgoing(type1).outgoing(type2) should return outgoing nodes of the given types" do
       a,b,c,d,e,f = create_nodes
       nodes = b.outgoing(:work).outgoing(:friends)
      
-      nodes.should include(c,d,f)
-      nodes.size.should == 4 #c is related by both work and friends
+      expect(nodes).to include(c,d,f)
+      expect(nodes.size).to eq(4) #c is related by both work and friends
     end
 
     it "#outgoing(type).depth(4) should only return outgoing nodes of the given type and depth" do
       a,b,c,d,e = create_nodes
-      [*b.outgoing(:work).depth(4)].size.should == 3
-      b.outgoing(:work).depth(4).should include(c,d,e)
+      expect([*b.outgoing(:work).depth(4)].size).to eq(3)
+      expect(b.outgoing(:work).depth(4)).to include(c,d,e)
     end
 
     it "#outgoing(type).depth(4).include_start_node should also include the start node" do
       a,b,c,d,e = create_nodes
-      [*b.outgoing(:work).depth(4).include_start_node].size.should == 4
-      b.outgoing(:work).depth(4).include_start_node.should include(b,c,d,e)
+      expect([*b.outgoing(:work).depth(4).include_start_node].size).to eq(4)
+      expect(b.outgoing(:work).depth(4).include_start_node).to include(b,c,d,e)
     end
 
     it "#outgoing(type).depth(:all) should traverse at any depth" do
       a,b,c,d,e = create_nodes
-      [*b.outgoing(:work).depth(:all)].size.should == 3
-      b.outgoing(:work).depth(:all).should include(c,d,e)
+      expect([*b.outgoing(:work).depth(:all)].size).to eq(3)
+      expect(b.outgoing(:work).depth(:all)).to include(c,d,e)
     end
   end
 
@@ -102,7 +102,7 @@ describe Neography::NodeRelationship do
       a.incoming(:friends) << other_node
 
       # then
-      a.incoming(:friends).first.should == other_node
+      expect(a.incoming(:friends).first).to eq(other_node)
     end
 
     it "#incoming(:friends) << b << c creates an incoming relationship of type :friends" do
@@ -114,26 +114,26 @@ describe Neography::NodeRelationship do
       a.incoming(:friends) << b << c
 
       # then
-      a.incoming(:friends).should include(b,c)
+      expect(a.incoming(:friends)).to include(b,c)
     end
 
     it "#incoming returns all incoming nodes of any type" do
       a,b,c,d,e,f = create_nodes
 
-      b.incoming.should include(a)
-      [*b.incoming].size.should == 1
+      expect(b.incoming).to include(a)
+      expect([*b.incoming].size).to eq(1)
     end
 
     it "#incoming(type).depth(2) should only return outgoing nodes of the given type and depth" do
       a,b,c,d,e = create_nodes
-      [*e.incoming(:work).depth(2)].size.should == 2
-      e.incoming(:work).depth(2).should include(b,d)
+      expect([*e.incoming(:work).depth(2)].size).to eq(2)
+      expect(e.incoming(:work).depth(2)).to include(b,d)
     end
 
     it "#incoming(type) should only return incoming nodes of the given type of depth one" do
       a,b,c,d = create_nodes
-      c.incoming(:work).should include(b)
-      [*c.incoming(:work)].size.should == 1
+      expect(c.incoming(:work)).to include(b)
+      expect([*c.incoming(:work)].size).to eq(1)
     end
   end
 
@@ -144,37 +144,37 @@ describe Neography::NodeRelationship do
 
       # when
       a.both(:friends) << other_node
-      a.incoming(:friends).first.should == other_node
-      a.outgoing(:friends).first.should == other_node
+      expect(a.incoming(:friends).first).to eq(other_node)
+      expect(a.outgoing(:friends).first).to eq(other_node)
     end
 
     it "#both returns all incoming and outgoing nodes of any type" do
       a,b,c,d,e,f = create_nodes
 
-      b.both.should include(a,c,d,f)
-      [*b.both].size.should == 5 #c is related by both work and friends
-      b.incoming.should include(a)
-      b.outgoing.should include(c)
+      expect(b.both).to include(a,c,d,f)
+      expect([*b.both].size).to eq(5) #c is related by both work and friends
+      expect(b.incoming).to include(a)
+      expect(b.outgoing).to include(c)
     end
 
     it "#both returns an empty array for unconnected nodes" do
       a = Neography::Node.create
-      a.both.size.should == 0
+      expect(a.both.size).to eq(0)
     end
 
     it "#both(type) should return both incoming and outgoing nodes of the given type of depth one" do
       a,b,c,d,e,f = create_nodes
 
-      b.both(:friends).should include(a,c,f)
-      [*b.both(:friends)].size.should == 3
+      expect(b.both(:friends)).to include(a,c,f)
+      expect([*b.both(:friends)].size).to eq(3)
     end
 
     it "#outgoing and #incoming can be combined to traverse several relationship types" do
       a,b,c,d,e = create_nodes
       nodes = [*b.incoming(:friends).outgoing(:work)]
 
-      nodes.should include(a,c,d)
-      nodes.should_not include(b,e)
+      expect(nodes).to include(a,c,d)
+      expect(nodes).not_to include(b,e)
     end
   end
 
@@ -182,22 +182,22 @@ describe Neography::NodeRelationship do
   describe "prune" do
     it "#prune, if it returns true the traversal will be stop for that path" do
       a, b, c, d, e = create_nodes
-      [*b.outgoing(:work).depth(4)].size.should == 3
-      b.outgoing(:work).depth(4).should include(c,d,e)
+      expect([*b.outgoing(:work).depth(4)].size).to eq(3)
+      expect(b.outgoing(:work).depth(4)).to include(c,d,e)
 
-      [*b.outgoing(:work).prune("position.endNode().getProperty('name') == 'd';")].size.should == 2
-      b.outgoing(:work).prune("position.endNode().getProperty('name') == 'd';").should include(c,d)
+      expect([*b.outgoing(:work).prune("position.endNode().getProperty('name') == 'd';")].size).to eq(2)
+      expect(b.outgoing(:work).prune("position.endNode().getProperty('name') == 'd';")).to include(c,d)
     end
   end
 
   describe "filter" do
     it "#filter, if it returns true the node will be included in the return results" do
       a, b, c, d, e = create_nodes
-      [*b.outgoing(:work).depth(4)].size.should == 3
-      b.outgoing(:work).depth(4).should include(c,d,e)
+      expect([*b.outgoing(:work).depth(4)].size).to eq(3)
+      expect(b.outgoing(:work).depth(4)).to include(c,d,e)
 
-      [*b.outgoing(:work).depth(4).filter("position.length() == 2;")].size.should == 1
-      b.outgoing(:work).depth(4).filter("position.length() == 2;").should include(e)
+      expect([*b.outgoing(:work).depth(4).filter("position.length() == 2;")].size).to eq(1)
+      expect(b.outgoing(:work).depth(4).filter("position.length() == 2;")).to include(e)
     end
   end
 
@@ -209,8 +209,8 @@ describe Neography::NodeRelationship do
       r1 = Neography::Relationship.create(:friend, a, b)
       Neography::Relationship.create(:friend, a, c)
 
-      a.rels.to_other(b).size.should == 1
-      a.rels.to_other(b).should include(r1)
+      expect(a.rels.to_other(b).size).to eq(1)
+      expect(a.rels.to_other(b)).to include(r1)
     end
 
     it "#rels returns an RelationshipTraverser which provides a method for deleting all the relationships" do
@@ -220,11 +220,11 @@ describe Neography::NodeRelationship do
       r1 = Neography::Relationship.create(:friend, a, b)
       r2 = Neography::Relationship.create(:friend, a, c)
 
-      a.rel?(:friend).should be_true
+      expect(a.rel?(:friend)).to be true
       a.rels.del
-      a.rel?(:friend).should be_false
-      r1.exist?.should be_false
-      r2.exist?.should be_false
+      expect(a.rel?(:friend)).to be false
+      expect(r1.exist?).to be false
+      expect(r2.exist?).to be false
     end
 
     it "#rels returns an RelationshipTraverser with methods #del and #to_other which can be combined to only delete a subset of the relationships" do
@@ -233,19 +233,19 @@ describe Neography::NodeRelationship do
       c = Neography::Node.create
       r1 = Neography::Relationship.create(:friend, a, b)
       r2 = Neography::Relationship.create(:friend, a, c)
-      r1.exist?.should be_true
-      r2.exist?.should be_true
+      expect(r1.exist?).to be true
+      expect(r2.exist?).to be true
       a.rels.to_other(c).del
-      r1.exist?.should be_true
-      r2.exist?.should be_false
+      expect(r1.exist?).to be true
+      expect(r2.exist?).to be false
     end
 
  it "#rels should return both incoming and outgoing relationship of any type of depth one" do
       a,b,c,d,e,f = create_nodes
-      b.rels.size.should == 5
+      expect(b.rels.size).to eq(5)
       nodes = b.rels.collect{|r| r.other_node(b)}
-      nodes.should include(a,c,d,f)
-      nodes.should_not include(e)
+      expect(nodes).to include(a,c,d,f)
+      expect(nodes).not_to include(e)
     end
 
     it "#rels(:friends) should return both incoming and outgoing relationships of given type of depth one" do
@@ -256,10 +256,10 @@ describe Neography::NodeRelationship do
       rels = [*b.rels(:friends)]
 
       # then
-      rels.size.should == 3
+      expect(rels.size).to eq(3)
       nodes = rels.collect{|r| r.end_node}
-      nodes.should include(b,c,f)
-      nodes.should_not include(a,d,e)
+      expect(nodes).to include(b,c,f)
+      expect(nodes).not_to include(a,d,e)
     end
 
     it "#rels(:friends).outgoing should return only outgoing relationships of given type of depth one" do
@@ -270,10 +270,10 @@ describe Neography::NodeRelationship do
       rels = [*b.rels(:friends).outgoing]
 
       # then
-      rels.size.should == 2
+      expect(rels.size).to eq(2)
       nodes = rels.collect{|r| r.end_node}
-      nodes.should include(c,f)
-      nodes.should_not include(a,b,d,e)
+      expect(nodes).to include(c,f)
+      expect(nodes).not_to include(a,b,d,e)
     end
 
 
@@ -285,10 +285,10 @@ describe Neography::NodeRelationship do
       rels = [*b.rels(:friends).incoming]
 
       # then
-      rels.size.should == 1
+      expect(rels.size).to eq(1)
       nodes = rels.collect{|r| r.start_node}
-      nodes.should include(a)
-      nodes.should_not include(b,c,d,e)
+      expect(nodes).to include(a)
+      expect(nodes).not_to include(b,c,d,e)
     end
 
     it "#rels(:friends,:work) should return both incoming and outgoing relationships of given types of depth one" do
@@ -299,10 +299,10 @@ describe Neography::NodeRelationship do
       rels = [*b.rels(:friends,:work)]
 
       # then
-      rels.size.should == 5
+      expect(rels.size).to eq(5)
       nodes = rels.collect{|r| r.other_node(b)}
-      nodes.should include(a,c,d,f)
-      nodes.should_not include(b,e)
+      expect(nodes).to include(a,c,d,f)
+      expect(nodes).not_to include(b,e)
     end
 
     it "#rels(:friends,:work).outgoing should return outgoing relationships of given types of depth one" do
@@ -313,10 +313,10 @@ describe Neography::NodeRelationship do
       rels = [*b.rels(:friends,:work).outgoing]
 
       # then
-      rels.size.should == 4
+      expect(rels.size).to eq(4)
       nodes = rels.collect{|r| r.other_node(b)}
-      nodes.should include(c,d,f)
-      nodes.should_not include(a,b,e)
+      expect(nodes).to include(c,d,f)
+      expect(nodes).not_to include(a,b,e)
     end
   end
 
@@ -325,13 +325,13 @@ describe Neography::NodeRelationship do
       a = Neography::Node.create
       b = Neography::Node.create
       rel = Neography::Relationship.create(:friend, a, b)
-      a.rel(:outgoing, :friend).should == rel
+      expect(a.rel(:outgoing, :friend)).to eq(rel)
     end
 
     it "#rel returns nil if there is no relationship" do
       a = Neography::Node.create
       b = Neography::Node.create
-      a.rel(:outgoing, :friend).should be_empty
+      expect(a.rel(:outgoing, :friend)).to be_empty
     end
 
     it "#rel should only return one relationship even if there are more" do
@@ -347,21 +347,21 @@ describe Neography::NodeRelationship do
   describe "rel?" do
     it "#rel? returns true if there are any relationships" do
       n1 = Neography::Node.create
-      n1.rel?.should be_false
+      expect(n1.rel?).to be false
       n1.outgoing(:foo) << Neography::Node.create
 
-      n1.rel?.should be_true
-      n1.rel?(:bar).should be_false
-      n1.rel?(:foo).should be_true
-      n1.rel?(:incoming, :foo).should be_false
-      n1.rel?(:outgoing, :foo).should be_true
-      n1.rel?(:foo, :incoming).should be_false
-      n1.rel?(:foo, :outgoing).should be_true
-      n1.rel?(:incoming).should be_false
-      n1.rel?(:outgoing).should be_true
-      n1.rel?(:both).should be_true
-      n1.rel?(:all).should be_true
-      n1.rel?.should be_true
+      expect(n1.rel?).to be true
+      expect(n1.rel?(:bar)).to be false
+      expect(n1.rel?(:foo)).to be true
+      expect(n1.rel?(:incoming, :foo)).to be false
+      expect(n1.rel?(:outgoing, :foo)).to be true
+      expect(n1.rel?(:foo, :incoming)).to be false
+      expect(n1.rel?(:foo, :outgoing)).to be true
+      expect(n1.rel?(:incoming)).to be false
+      expect(n1.rel?(:outgoing)).to be true
+      expect(n1.rel?(:both)).to be true
+      expect(n1.rel?(:all)).to be true
+      expect(n1.rel?).to be true
     end
   end