neography 1.5.0 → 1.5.1

data/spec/integration/rest_labels_spec.rb

@@ -9,7 +9,7 @@ describe Neography::Rest do
     it "can get the labels of the database" do
       @neo.set_label(0, "Person")
       labels = @neo.list_labels
-      labels.should include("Person")
+      expect(labels).to include("Person")
     end
   end
 
@@ -18,7 +18,7 @@ describe Neography::Rest do
       new_node = @neo.create_node
       @neo.add_label(new_node, "Person")
       labels = @neo.get_node_labels(new_node)
-      labels.should == ["Person"]
+      expect(labels).to eq(["Person"])
     end
 
     it "can add another label to a node" do
@@ -27,7 +27,7 @@ describe Neography::Rest do
       @neo.add_label(new_node_id, "Actor")
       @neo.add_label(new_node_id, "Director")
       labels = @neo.get_node_labels(new_node_id)
-      labels.should == ["Actor", "Director"]
+      expect(labels).to eq(["Actor", "Director"])
     end
 
     it "can add multiple labels to a node" do
@@ -35,7 +35,7 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.add_label(new_node_id, ["Actor", "Director"])
       labels = @neo.get_node_labels(new_node_id)
-      labels.should == ["Actor", "Director"]
+      expect(labels).to eq(["Actor", "Director"])
     end
   end
 
@@ -45,7 +45,7 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.set_label(new_node_id, "Person")
       labels = @neo.get_node_labels(new_node_id)
-      labels.should == ["Person"]
+      expect(labels).to eq(["Person"])
     end
 
     it "can set a label to a node that already had a label" do
@@ -53,7 +53,7 @@ describe Neography::Rest do
       @neo.add_label(new_node, "Actor")
       @neo.set_label(new_node, "Director")
       labels = @neo.get_node_labels(new_node)
-      labels.should == ["Director"]
+      expect(labels).to eq(["Director"])
     end
 
     it "can set multiple labels to a node" do
@@ -61,7 +61,7 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.set_label(new_node_id, ["Actor", "Director"])
       labels = @neo.get_node_labels(new_node_id)
-      labels.should == ["Actor", "Director"]
+      expect(labels).to eq(["Actor", "Director"])
     end
   end
 
@@ -71,7 +71,7 @@ describe Neography::Rest do
       @neo.set_label(new_node, ["Actor", "Director"])
       @neo.delete_label(new_node, "Actor")
       labels = @neo.get_node_labels(new_node)
-      labels.should == ["Director"]
+      expect(labels).to eq(["Director"])
     end
 
     it "can delete a label from a node that doesn't have one" do
@@ -79,7 +79,7 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.delete_label(new_node_id, "Actor")
       labels = @neo.get_node_labels(new_node_id)
-      labels.should == []
+      expect(labels).to eq([])
     end
 
     it "cannot delete a label from a node that doesn't exist" do
@@ -97,12 +97,12 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.set_label(new_node_id, ["Actor", "Director"])
       nodes = @neo.get_nodes_labeled("Actor")
-      nodes.last["self"].split('/').last.should == new_node_id
+      expect(nodes.last["self"].split('/').last).to eq(new_node_id)
     end
 
     it "returns an empty array on non-existing label" do
       nodes = @neo.get_nodes_labeled("do_not_exist")
-      nodes.should == []
+      expect(nodes).to eq([])
     end
   end
 
@@ -112,7 +112,7 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.set_label(new_node_id, "clown")
       nodes = @neo.find_nodes_labeled("clown", { :name => "max" })
-      nodes.last["self"].split('/').last.should == new_node_id
+      expect(nodes.last["self"].split('/').last).to eq(new_node_id)
     end
 
     it "returns an empty array on non-existing label property" do
@@ -120,7 +120,7 @@ describe Neography::Rest do
       new_node_id = new_node["self"].split('/').last
       @neo.set_label(new_node_id, "clown")
       nodes = @neo.find_nodes_labeled("clown", { :name => "does_not_exist" })
-      nodes.should == []
+      expect(nodes).to eq([])
     end
 
   end

data/spec/integration/rest_node_spec.rb

@@ -10,33 +10,33 @@ describe Neography::Rest do
   describe "get_root" do
     it "can get the root node", :reference => true do
       root_node = @neo.get_root
-      root_node.should have_key("self")
-      root_node["self"].split('/').last.should == "0"
+      expect(root_node).to have_key("self")
+      expect(root_node["self"].split('/').last).to eq("0")
     end
   end
 
   describe "create_node" do
     it "can create an empty node" do
       new_node = @neo.create_node
-      new_node.should_not be_nil
+      expect(new_node).not_to be_nil
     end
 
     it "can create a node with one property" do
       new_node = @neo.create_node("name" => "Max")
-      new_node["data"]["name"].should == "Max"
+      expect(new_node["data"]["name"]).to eq("Max")
     end
 
     it "can create a node with nil properties" do
       new_node = @neo.create_node("name" => "Max", "age" => nil )
-      new_node["data"]["name"].should == "Max"
-      new_node["data"]["age"].should be_nil
+      expect(new_node["data"]["name"]).to eq("Max")
+      expect(new_node["data"]["age"]).to be_nil
     end
 
 
     it "can create a node with more than one property" do
       new_node = @neo.create_node("age" => 31, "name" => "Max")
-      new_node["data"]["name"].should == "Max"
-      new_node["data"]["age"].should == 31
+      expect(new_node["data"]["name"]).to eq("Max")
+      expect(new_node["data"]["age"]).to eq(31)
     end
 
     it "can create a unique node with more than one property" do
@@ -45,13 +45,13 @@ describe Neography::Rest do
       value = generate_text
       @neo.create_node_index(index_name)
       new_node = @neo.create_unique_node(index_name, key, value, {"age" => 31, "name" => "Max"})
-      new_node["data"]["name"].should == "Max"
-      new_node["data"]["age"].should == 31
+      expect(new_node["data"]["name"]).to eq("Max")
+      expect(new_node["data"]["age"]).to eq(31)
       new_node_id = new_node["self"].split('/').last
       existing_node = @neo.create_unique_node(index_name, key, value, {"age" => 39, "name" => "Thomas"})
-      existing_node["self"].split('/').last.should == new_node_id
-      existing_node["data"]["name"].should == "Max"
-      existing_node["data"]["age"].should == 31
+      expect(existing_node["self"].split('/').last).to eq(new_node_id)
+      expect(existing_node["data"]["name"]).to eq("Max")
+      expect(existing_node["data"]["age"]).to eq(31)
     end
 
   end
@@ -61,9 +61,9 @@ describe Neography::Rest do
       new_node = @neo.create_node
       new_node[:id] = new_node["self"].split('/').last
       existing_node = @neo.get_node(new_node)
-      existing_node.should_not be_nil
-      existing_node.should have_key("self")
-      existing_node["self"].split('/').last.should == new_node[:id]
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("self")
+      expect(existing_node["self"].split('/').last).to eq(new_node[:id])
     end
 
     it "raises an error if it tries to get a node that does not exist" do
@@ -78,10 +78,10 @@ describe Neography::Rest do
       new_node = @neo.create_node("name" => "Ateísmo Sureño")
       new_node[:id] = new_node["self"].split('/').last
       existing_node = @neo.get_node(new_node)
-      existing_node.should_not be_nil
-      existing_node.should have_key("self")
-      existing_node["self"].split('/').last.should == new_node[:id]
-      existing_node["data"]["name"].should == "Ateísmo Sureño"
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("self")
+      expect(existing_node["self"].split('/').last).to eq(new_node[:id])
+      expect(existing_node["data"]["name"]).to eq("Ateísmo Sureño")
     end
   end
 
@@ -90,8 +90,8 @@ describe Neography::Rest do
       new_node = @neo.create_node
       @neo.set_node_properties(new_node, {"weight" => 200, "eyes" => "brown"})
       existing_node = @neo.get_node(new_node)
-      existing_node["data"]["weight"].should == 200
-      existing_node["data"]["eyes"].should == "brown"
+      expect(existing_node["data"]["weight"]).to eq(200)
+      expect(existing_node["data"]["eyes"]).to eq("brown")
     end
 
     it "it fails to set properties on a node that does not exist" do
@@ -109,9 +109,9 @@ describe Neography::Rest do
       @neo.set_node_properties(new_node, {"weight" => 200, "eyes" => "brown", "hair" => "black"})
       @neo.reset_node_properties(new_node, {"weight" => 190, "eyes" => "blue"})
       existing_node = @neo.get_node(new_node)
-      existing_node["data"]["weight"].should == 190
-      existing_node["data"]["eyes"].should == "blue"
-      existing_node["data"]["hair"].should be_nil
+      expect(existing_node["data"]["weight"]).to eq(190)
+      expect(existing_node["data"]["eyes"]).to eq("blue")
+      expect(existing_node["data"]["hair"]).to be_nil
     end
 
     it "it fails to reset properties on a node that does not exist" do
@@ -127,27 +127,27 @@ describe Neography::Rest do
     it "can get all of a node's properties" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
       node_properties = @neo.get_node_properties(new_node)
-      node_properties["weight"].should == 200
-      node_properties["eyes"].should == "brown"
+      expect(node_properties["weight"]).to eq(200)
+      expect(node_properties["eyes"]).to eq("brown")
     end
 
     it "can get some of a node's properties" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown", "height" => "2m")
       node_properties = @neo.get_node_properties(new_node, ["weight", "height"])
-      node_properties["weight"].should == 200
-      node_properties["height"].should == "2m"
-      node_properties["eyes"].should be_nil
+      expect(node_properties["weight"]).to eq(200)
+      expect(node_properties["height"]).to eq("2m")
+      expect(node_properties["eyes"]).to be_nil
     end
 
     it "returns nil if it gets the properties on a node that does not have any" do
       new_node = @neo.create_node
-      @neo.get_node_properties(new_node).should be_nil
+      expect(@neo.get_node_properties(new_node)).to be_nil
     end
 
     it "raises error if it tries to get some of the properties on a node that does not have any" do
       new_node = @neo.create_node
       expect {
-        @neo.get_node_properties(new_node, ["weight", "height"]).should be_nil
+        expect(@neo.get_node_properties(new_node, ["weight", "height"])).to be_nil
       }.to raise_error Neography::NoSuchPropertyException
     end
 
@@ -155,7 +155,7 @@ describe Neography::Rest do
       new_node = @neo.create_node
       fake_node = new_node["self"].split('/').last.to_i + 1000
       expect {
-        @neo.get_node_properties(fake_node).should be_nil
+        expect(@neo.get_node_properties(fake_node)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
     end
   end
@@ -164,14 +164,14 @@ describe Neography::Rest do
     it "can remove a node's properties" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
       @neo.remove_node_properties(new_node)
-      @neo.get_node_properties(new_node).should be_nil
+      expect(@neo.get_node_properties(new_node)).to be_nil
     end
 
     it "raises error if it fails to remove the properties of a node that does not exist" do
       new_node = @neo.create_node
       fake_node = new_node["self"].split('/').last.to_i + 1000
       expect {
-        @neo.remove_node_properties(fake_node).should be_nil
+        expect(@neo.remove_node_properties(fake_node)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
     end
 
@@ -179,23 +179,23 @@ describe Neography::Rest do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown")
       @neo.remove_node_properties(new_node, "weight")
       node_properties = @neo.get_node_properties(new_node)
-      node_properties["weight"].should be_nil
-      node_properties["eyes"].should == "brown"
+      expect(node_properties["weight"]).to be_nil
+      expect(node_properties["eyes"]).to eq("brown")
     end
 
     it "can remove more than one property" do
       new_node = @neo.create_node("weight" => 200, "eyes" => "brown", "height" => "2m")
       @neo.remove_node_properties(new_node, ["weight", "eyes"])
       node_properties = @neo.get_node_properties(new_node)
-      node_properties["weight"].should be_nil
-      node_properties["eyes"].should be_nil
+      expect(node_properties["weight"]).to be_nil
+      expect(node_properties["eyes"]).to be_nil
     end
   end
 
   describe "delete_node" do
     it "can delete an unrelated node" do
       new_node = @neo.create_node
-      @neo.delete_node(new_node).should be_nil
+      expect(@neo.delete_node(new_node)).to be_nil
       expect {
         @neo.get_node(new_node)
       }.to raise_error Neography::NodeNotFoundException
@@ -206,28 +206,28 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       @neo.create_relationship("friends", new_node1, new_node2)
       expect {
-        @neo.delete_node(new_node1).should be_nil
+        expect(@neo.delete_node(new_node1)).to be_nil
       }.to raise_error Neography::OperationFailureException
       existing_node = @neo.get_node(new_node1)
-      existing_node.should_not be_nil
+      expect(existing_node).not_to be_nil
     end
 
     it "raises error if it tries to delete a node that does not exist" do
       new_node = @neo.create_node
       fake_node = new_node["self"].split('/').last.to_i + 1000
       expect {
-        @neo.delete_node(fake_node).should be_nil
+        expect(@neo.delete_node(fake_node)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
     end
 
     it "raises error if it tries to delete a node that has already been deleted" do
       new_node = @neo.create_node
-      @neo.delete_node(new_node).should be_nil
+      expect(@neo.delete_node(new_node)).to be_nil
       expect {
         existing_node = @neo.get_node(new_node)
       }.to raise_error Neography::NodeNotFoundException
       expect {
-        @neo.delete_node(new_node).should be_nil
+        expect(@neo.delete_node(new_node)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
     end
   end
@@ -235,7 +235,7 @@ describe Neography::Rest do
   describe "delete_node!" do
     it "can delete an unrelated node" do
       new_node = @neo.create_node
-      @neo.delete_node!(new_node).should be_nil
+      expect(@neo.delete_node!(new_node)).to be_nil
       expect {
         existing_node = @neo.get_node(new_node)
       }.to raise_error Neography::NodeNotFoundException
@@ -245,7 +245,7 @@ describe Neography::Rest do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       @neo.create_relationship("friends", new_node1, new_node2)
-      @neo.delete_node!(new_node1).should be_nil
+      expect(@neo.delete_node!(new_node1)).to be_nil
       expect {
         existing_node = @neo.get_node(new_node1)
       }.to raise_error Neography::NodeNotFoundException
@@ -255,18 +255,18 @@ describe Neography::Rest do
       new_node = @neo.create_node
       fake_node = new_node["self"].split('/').last.to_i + 1000
       expect {
-        @neo.delete_node!(fake_node).should be_nil
+        expect(@neo.delete_node!(fake_node)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
     end
 
     it "raises error if it tries to delete a node that has already been deleted" do
       new_node = @neo.create_node
-      @neo.delete_node!(new_node).should be_nil
+      expect(@neo.delete_node!(new_node)).to be_nil
       expect {
         existing_node = @neo.get_node(new_node)
       }.to raise_error Neography::NodeNotFoundException
       expect {
-        @neo.delete_node!(new_node).should be_nil
+        expect(@neo.delete_node!(new_node)).to be_nil
       }.to raise_error Neography::NodeNotFoundException
     end
   end

data/spec/integration/rest_other_node_relationship_spec.rb

@@ -11,9 +11,9 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
       existing_relationships = @neo.get_node_relationships_to(new_node1, new_node2)
-      existing_relationships[0].should_not be_nil
-      existing_relationships[0].should have_key("self")
-      existing_relationships[0]["self"].should == new_relationship["self"]
+      expect(existing_relationships[0]).not_to be_nil
+      expect(existing_relationships[0]).to have_key("self")
+      expect(existing_relationships[0]["self"]).to eq(new_relationship["self"])
     end
 
     it "returns empty array if it tries to get a relationship that does not exist" do
@@ -22,7 +22,7 @@ describe Neography::Rest do
       new_node3 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
       existing_relationship = @neo.get_node_relationships_to(new_node1, new_node3)
-      existing_relationship.should be_empty
+      expect(existing_relationship).to be_empty
     end
   end
 
@@ -32,12 +32,12 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
       relationships = @neo.get_node_relationships_to(new_node1, new_node2)
-      relationships.should_not be_nil
-      relationships[0]["start"].should == new_node1["self"]
-      relationships[0]["end"].should == new_node2["self"]
-      relationships[0]["type"].should == "friends"
-      relationships[0]["data"]["met"].should == "college"
-      relationships[0]["data"]["since"].should == '10-1-2005'
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
     end
 
     it "can get a node's multiple relationships" do
@@ -47,17 +47,17 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
       new_relationship = @neo.create_relationship("enemies", new_node1, new_node2, {"since" => '10-2-2010', "met" => "work"})
       relationships = @neo.get_node_relationships_to(new_node1, new_node2)
-      relationships.should_not be_nil
-      relationships[0]["start"].should == new_node1["self"]
-      relationships[0]["end"].should == new_node2["self"]
-      relationships[0]["type"].should == "friends"
-      relationships[0]["data"]["met"].should == "college"
-      relationships[0]["data"]["since"].should == '10-1-2005'
-      relationships[1]["start"].should == new_node1["self"]
-      relationships[1]["end"].should == new_node2["self"]
-      relationships[1]["type"].should == "enemies"
-      relationships[1]["data"]["met"].should == "work"
-      relationships[1]["data"]["since"].should == '10-2-2010'
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+      expect(relationships[1]["start"]).to eq(new_node1["self"])
+      expect(relationships[1]["end"]).to eq(new_node2["self"])
+      expect(relationships[1]["type"]).to eq("enemies")
+      expect(relationships[1]["data"]["met"]).to eq("work")
+      expect(relationships[1]["data"]["since"]).to eq('10-2-2010')
     end
 
     it "can get all of a node's outgoing relationship" do
@@ -67,13 +67,13 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
       new_relationship = @neo.create_relationship("enemies", new_node2, new_node1, {"since" => '10-2-2010', "met" => "work"})
       relationships = @neo.get_node_relationships_to(new_node1, new_node2, "out")
-      relationships.should_not be_nil
-      relationships[0]["start"].should == new_node1["self"]
-      relationships[0]["end"].should == new_node2["self"]
-      relationships[0]["type"].should == "friends"
-      relationships[0]["data"]["met"].should == "college"
-      relationships[0]["data"]["since"].should == '10-1-2005'
-      relationships[1].should be_nil
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+      expect(relationships[1]).to be_nil
     end
 
     it "can get all of a node's incoming relationship" do
@@ -83,13 +83,13 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
       new_relationship = @neo.create_relationship("enemies", new_node3, new_node1, {"since" => '10-2-2010', "met" => "work"})
       relationships = @neo.get_node_relationships_to(new_node1, new_node3, "in")
-      relationships.should_not be_nil
-      relationships[0]["start"].should == new_node3["self"]
-      relationships[0]["end"].should == new_node1["self"]
-      relationships[0]["type"].should == "enemies"
-      relationships[0]["data"]["met"].should == "work"
-      relationships[0]["data"]["since"].should == '10-2-2010'
-      relationships[1].should be_nil
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node3["self"])
+      expect(relationships[0]["end"]).to eq(new_node1["self"])
+      expect(relationships[0]["type"]).to eq("enemies")
+      expect(relationships[0]["data"]["met"]).to eq("work")
+      expect(relationships[0]["data"]["since"]).to eq('10-2-2010')
+      expect(relationships[1]).to be_nil
     end
 
     it "can get a specific type of node relationships" do
@@ -99,13 +99,13 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2005', "met" => "college"})
       new_relationship = @neo.create_relationship("friends", new_node1, new_node3, {"since" => '10-2-2010', "met" => "work"})
       relationships = @neo.get_node_relationships_to(new_node1, new_node2, "all", "friends")
-      relationships.should_not be_nil
-      relationships[0]["start"].should == new_node1["self"]
-      relationships[0]["end"].should == new_node2["self"]
-      relationships[0]["type"].should == "friends"
-      relationships[0]["data"]["met"].should == "college"
-      relationships[0]["data"]["since"].should == '10-1-2005'
-      relationships[1].should be_nil
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node1["self"])
+      expect(relationships[0]["end"]).to eq(new_node2["self"])
+      expect(relationships[0]["type"]).to eq("friends")
+      expect(relationships[0]["data"]["met"]).to eq("college")
+      expect(relationships[0]["data"]["since"]).to eq('10-1-2005')
+      expect(relationships[1]).to be_nil
     end
 
     it "can get a specific type and direction of a node relationships" do
@@ -117,20 +117,20 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("enemies", new_node1, new_node3, {"since" => '10-2-2010', "met" => "work"})
       new_relationship = @neo.create_relationship("enemies", new_node4, new_node1, {"since" => '10-3-2010', "met" => "gym"})
       relationships = @neo.get_node_relationships_to(new_node1, new_node4, "in", "enemies")
-      relationships.should_not be_nil
-      relationships[0]["start"].should == new_node4["self"]
-      relationships[0]["end"].should == new_node1["self"]
-      relationships[0]["type"].should == "enemies"
-      relationships[0]["data"]["met"].should == "gym"
-      relationships[0]["data"]["since"].should == '10-3-2010'
-      relationships[1].should be_nil
+      expect(relationships).not_to be_nil
+      expect(relationships[0]["start"]).to eq(new_node4["self"])
+      expect(relationships[0]["end"]).to eq(new_node1["self"])
+      expect(relationships[0]["type"]).to eq("enemies")
+      expect(relationships[0]["data"]["met"]).to eq("gym")
+      expect(relationships[0]["data"]["since"]).to eq('10-3-2010')
+      expect(relationships[1]).to be_nil
     end
 
     it "returns nil if there are no relationships" do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       relationships = @neo.get_node_relationships_to(new_node1, new_node2)
-      relationships.should be_empty
+      expect(relationships).to be_empty
     end
   end