neography 1.5.0 → 1.5.1

data/spec/integration/rest_path_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, {"since" => '10-1-2005', "met" => "college"})
       path = @neo.get_path(new_node1, new_node2, {"type"=> "friends", "direction" => "out"})
-      path["start"].should == new_node1["self"]
-      path["end"].should == new_node2["self"]
-      path["nodes"].should == [new_node1["self"], new_node2["self"]]
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node2["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"]])
     end
 
     it "can get the shortest path between two nodes" do
@@ -28,9 +28,9 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node4, new_node5)
       @neo.create_relationship("friends", new_node3, new_node5)
       path = @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=3, algorithm="shortestPath")
-      path["start"].should == new_node1["self"]
-      path["end"].should == new_node5["self"]
-      path["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]]
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node5["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]])
     end
 
     it "can get the shortest weighted path between two nodes" do
@@ -50,9 +50,9 @@ describe Neography::Rest do
       @neo.set_relationship_properties(rel4_5, {:weight => 1})
       @neo.set_relationship_properties(rel3_5, {:weight => 3})
       path = @neo.get_shortest_weighted_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"})
-      path.first["start"].should == new_node1["self"]
-      path.first["end"].should == new_node5["self"]
-      path.first["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]]
+      expect(path.first["start"]).to eq(new_node1["self"])
+      expect(path.first["end"]).to eq(new_node5["self"])
+      expect(path.first["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]])
     end
 
     it "can get a simple path between two nodes" do
@@ -67,9 +67,9 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node4, new_node5)
       @neo.create_relationship("friends", new_node3, new_node5)
       path = @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=3, algorithm="simplePaths")
-      path["start"].should == new_node1["self"]
-      path["end"].should == new_node5["self"]
-      path["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]]
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node5["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node5["self"]])
     end
 
     it "fails to get a path between two nodes 3 nodes apart when using max depth of 2" do
@@ -101,9 +101,9 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node3, new_node4)
       @neo.create_relationship("friends", new_node4, new_node5)
       path = @neo.get_path(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="shortestPath")
-      path["start"].should == new_node1["self"]
-      path["end"].should == new_node5["self"]
-      path["nodes"].should == [new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]]
+      expect(path["start"]).to eq(new_node1["self"])
+      expect(path["end"]).to eq(new_node5["self"])
+      expect(path["nodes"]).to eq([new_node1["self"], new_node2["self"], new_node3["self"], new_node4["self"], new_node5["self"]])
     end
   end
 
@@ -121,13 +121,13 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node4, new_node5)
       @neo.create_relationship("friends", new_node3, new_node5)
       paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="shortestPath")
-      paths.length.should == 2
-      paths[0]["length"].should == 2
-      paths[0]["start"].should == new_node1["self"]
-      paths[0]["end"].should == new_node5["self"]
-      paths[1]["length"].should == 2
-      paths[1]["start"].should == new_node1["self"]
-      paths[1]["end"].should == new_node5["self"]
+      expect(paths.length).to eq(2)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(2)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])
     end
 
     it "can get all paths between two nodes" do
@@ -143,16 +143,16 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node4, new_node5)
       @neo.create_relationship("friends", new_node3, new_node5)
       paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="allPaths")
-      paths.length.should == 3
-      paths[0]["length"].should == 2
-      paths[0]["start"].should == new_node1["self"]
-      paths[0]["end"].should == new_node5["self"]
-      paths[1]["length"].should == 3
-      paths[1]["start"].should == new_node1["self"]
-      paths[1]["end"].should == new_node5["self"]
-      paths[2]["length"].should == 2
-      paths[2]["start"].should == new_node1["self"]
-      paths[2]["end"].should == new_node5["self"]
+      expect(paths.length).to eq(3)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(3)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])
+      expect(paths[2]["length"]).to eq(2)
+      expect(paths[2]["start"]).to eq(new_node1["self"])
+      expect(paths[2]["end"]).to eq(new_node5["self"])
     end
 
     it "can get all simple paths between two nodes" do
@@ -169,16 +169,16 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node4, new_node5)
       @neo.create_relationship("friends", new_node3, new_node5)
       paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=4, algorithm="allSimplePaths")
-      paths.length.should == 3
-      paths[0]["length"].should == 2
-      paths[0]["start"].should == new_node1["self"]
-      paths[0]["end"].should == new_node5["self"]
-      paths[1]["length"].should == 3
-      paths[1]["start"].should == new_node1["self"]
-      paths[1]["end"].should == new_node5["self"]
-      paths[2]["length"].should == 2
-      paths[2]["start"].should == new_node1["self"]
-      paths[2]["end"].should == new_node5["self"]
+      expect(paths.length).to eq(3)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(3)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])
+      expect(paths[2]["length"]).to eq(2)
+      expect(paths[2]["start"]).to eq(new_node1["self"])
+      expect(paths[2]["end"]).to eq(new_node5["self"])
     end
 
     it "can get paths between two nodes of max depth 2" do
@@ -194,13 +194,13 @@ describe Neography::Rest do
       @neo.create_relationship("friends", new_node4, new_node5)
       @neo.create_relationship("friends", new_node3, new_node5)
       paths = @neo.get_paths(new_node1, new_node5, {"type"=> "friends", "direction" => "out"}, depth=2, algorithm="allPaths")
-      paths.length.should == 2
-      paths[0]["length"].should == 2
-      paths[0]["start"].should == new_node1["self"]
-      paths[0]["end"].should == new_node5["self"]
-      paths[1]["length"].should == 2
-      paths[1]["start"].should == new_node1["self"]
-      paths[1]["end"].should == new_node5["self"]    end
+      expect(paths.length).to eq(2)
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(2)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])    end
 
     it "can get paths between two nodes of a specific relationship" do
       new_node1 = @neo.create_node
@@ -217,12 +217,12 @@ describe Neography::Rest do
       @neo.create_relationship("classmates", new_node1, new_node3)
       @neo.create_relationship("classmates", new_node3, new_node5)
       paths = @neo.get_paths(new_node1, new_node5, {"type"=> "classmates", "direction" => "out"}, depth=4, algorithm="allPaths")
-      paths[0]["length"].should == 2
-      paths[0]["start"].should == new_node1["self"]
-      paths[0]["end"].should == new_node5["self"]
-      paths[1]["length"].should == 2
-      paths[1]["start"].should == new_node1["self"]
-      paths[1]["end"].should == new_node5["self"]    
+      expect(paths[0]["length"]).to eq(2)
+      expect(paths[0]["start"]).to eq(new_node1["self"])
+      expect(paths[0]["end"]).to eq(new_node5["self"])
+      expect(paths[1]["length"]).to eq(2)
+      expect(paths[1]["start"]).to eq(new_node1["self"])
+      expect(paths[1]["end"]).to eq(new_node5["self"])    
     end
 
   end

data/spec/integration/rest_plugin_spec.rb

@@ -10,47 +10,47 @@ describe Neography::Rest do
   describe "execute gremlin script" do
     it "can get the root node id", :gremlin => true do
       root_node = @neo.execute_script("g.v(0)")
-      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
 
     it "can get the a node", :gremlin => true do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       existing_node = @neo.execute_script("g.v(#{id})")
-      existing_node.should_not be_nil
-      existing_node.should have_key("self")
-      existing_node["self"].split('/').last.should == id
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("self")
+      expect(existing_node["self"].split('/').last).to eq(id)
     end
 
     it "can get the a node with a variable", :gremlin => true do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       existing_node = @neo.execute_script("g.v(id)", {:id => id.to_i})
-      existing_node.should_not be_nil
-      existing_node.should have_key("self")
-      existing_node["self"].split('/').last.should == id
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("self")
+      expect(existing_node["self"].split('/').last).to eq(id)
     end
   end
 
   describe "execute cypher query" do
     it "can get the root node id" do
       root_node = @neo.execute_query("start n=node(0) return n")
-      root_node.should have_key("data")
-      root_node.should have_key("columns")
-      root_node["data"][0][0].should have_key("self")
-      root_node["data"][0][0]["self"].split('/').last.should == "0"
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
     end
 
     it "can get the a node" do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       existing_node = @neo.execute_query("start n=node(#{id}) return n")
-      existing_node.should_not be_nil
-      existing_node.should have_key("data")
-      existing_node.should have_key("columns")
-      existing_node["data"][0][0].should have_key("self")
-      existing_node["data"][0][0]["self"].split('/').last.should == id
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
     end
 
     it "can perform a range query" do
@@ -60,14 +60,14 @@ describe Neography::Rest do
       @neo.create_node_index(name, "fulltext","lucene")
       @neo.add_node_to_index(name, "number", 3, new_node) 
       existing_node = @neo.find_node_index(name, "number:[1 TO 5]")
-      existing_node.first["self"].should == new_node["self"]
-      existing_node.first.should_not be_nil
-      existing_node.first["data"]["number"].should == 3
+      expect(existing_node.first["self"]).to eq(new_node["self"])
+      expect(existing_node.first).not_to be_nil
+      expect(existing_node.first["data"]["number"]).to eq(3)
       existing_node = @neo.execute_query("start n=node:#{name}(\"number:[1 TO 5]\") return n")
-      existing_node.should have_key("data")
-      existing_node.should have_key("columns")
-      existing_node["data"][0][0].should have_key("self")
-      existing_node["data"][0][0]["self"].split('/').last.should == id
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
     end
 
     it "can perform a range query with a term" do
@@ -78,15 +78,15 @@ describe Neography::Rest do
       @neo.add_node_to_index(name, "number", 3, new_node) 
       @neo.add_node_to_index(name, "name", "max", new_node) 
       existing_node = @neo.find_node_index(name, "name:max AND number:[1 TO 5]")
-      existing_node.first["self"].should == new_node["self"]
-      existing_node.first.should_not be_nil
-      existing_node.first["data"]["number"].should == 3
-      existing_node.first["data"]["name"].should == "Max"
+      expect(existing_node.first["self"]).to eq(new_node["self"])
+      expect(existing_node.first).not_to be_nil
+      expect(existing_node.first["data"]["number"]).to eq(3)
+      expect(existing_node.first["data"]["name"]).to eq("Max")
       existing_node = @neo.execute_query("start n=node:#{name}(\"name:max AND number:[1 TO 5]\") return n")
-      existing_node.should have_key("data")
-      existing_node.should have_key("columns")
-      existing_node["data"][0][0].should have_key("self")
-      existing_node["data"][0][0]["self"].split('/').last.should == id
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
     end
 
 
@@ -94,50 +94,50 @@ describe Neography::Rest do
       new_node = @neo.create_node("name" => "Ateísmo Sureño")
       id = new_node["self"].split('/').last
       existing_node = @neo.execute_query("start n=node(#{id}) return n")
-      existing_node.should_not be_nil
-      existing_node.should have_key("data")
-      existing_node.should have_key("columns")
-      existing_node["data"][0][0]["self"].split('/').last.should == id
-      existing_node["data"][0][0]["data"]["name"].should == "Ateísmo Sureño"
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
+      expect(existing_node["data"][0][0]["data"]["name"]).to eq("Ateísmo Sureño")
     end
 
     it "can get the a node with a variable" do
       new_node = @neo.create_node
       id = new_node["self"].split('/').last
       existing_node = @neo.execute_query("start n=node({id}) return n", {:id => id.to_i})
-      existing_node.should_not be_nil
-      existing_node.should have_key("data")
-      existing_node.should have_key("columns")
-      existing_node["data"][0][0].should have_key("self")
-      existing_node["data"][0][0]["self"].split('/').last.should == id
+      expect(existing_node).not_to be_nil
+      expect(existing_node).to have_key("data")
+      expect(existing_node).to have_key("columns")
+      expect(existing_node["data"][0][0]).to have_key("self")
+      expect(existing_node["data"][0][0]["self"].split('/').last).to eq(id)
     end
 
     it "can get the stats of a cypher query" do
       root_node = @neo.execute_query("start n=node(0) return n", nil, {:stats => true})
-      root_node.should have_key("data")
-      root_node.should have_key("columns")
-      root_node.should have_key("stats")
-      root_node["data"][0][0].should have_key("self")
-      root_node["data"][0][0]["self"].split('/').last.should == "0"
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node).to have_key("stats")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
     end
 
     it "can get the profile of a cypher query" do
       root_node = @neo.execute_query("start n=node(0) return n", nil, {:profile => true})
-      root_node.should have_key("data")
-      root_node.should have_key("columns")
-      root_node.should have_key("plan")
-      root_node["data"][0][0].should have_key("self")
-      root_node["data"][0][0]["self"].split('/').last.should == "0"
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node).to have_key("plan")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
     end
 
     it "can get the stats and profile of a cypher query" do
       root_node = @neo.execute_query("start n=node(0) return n", nil, {:stats => true, :profile => true})
-      root_node.should have_key("data")
-      root_node.should have_key("columns")
-      root_node.should have_key("stats")
-      root_node.should have_key("plan")
-      root_node["data"][0][0].should have_key("self")
-      root_node["data"][0][0]["self"].split('/').last.should == "0"
+      expect(root_node).to have_key("data")
+      expect(root_node).to have_key("columns")
+      expect(root_node).to have_key("stats")
+      expect(root_node).to have_key("plan")
+      expect(root_node["data"][0][0]).to have_key("self")
+      expect(root_node["data"][0][0]["self"].split('/').last).to eq("0")
     end
 
 
@@ -147,7 +147,7 @@ describe Neography::Rest do
         @neo.execute_query("start n=node({id}) return n", {:id => 1})
       }.to raise_error(Neography::BadInputException)
       root_node = @neo.execute_query("start n=node({id}) return n", {:id => 0})
-      root_node.should_not be_nil
+      expect(root_node).not_to be_nil
     end
 
     it "throws an error for an invalid query" do

data/spec/integration/rest_relationship_spec.rb

@@ -10,8 +10,8 @@ describe Neography::Rest do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
-      new_relationship["start"].should_not be_nil
-      new_relationship["end"].should_not be_nil
+      expect(new_relationship["start"]).not_to be_nil
+      expect(new_relationship["end"]).not_to be_nil
     end
 
     it "can create a relationship with one property" do
@@ -20,15 +20,15 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_node2[:id] = new_node2["self"].split('/').last
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010'})
-      new_relationship["data"]["since"].should == '10-1-2010'
+      expect(new_relationship["data"]["since"]).to eq('10-1-2010')
     end
 
     it "can create a relationship with more than one property" do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
-      new_relationship["data"]["since"].should == '10-1-2010'
-      new_relationship["data"]["met"].should == "college"
+      expect(new_relationship["data"]["since"]).to eq('10-1-2010')
+      expect(new_relationship["data"]["met"]).to eq("college")
     end
 
     it "can create a unique node with more than one property" do
@@ -37,8 +37,8 @@ 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)
     end
 
     it "can create a unique relationship" do
@@ -48,7 +48,7 @@ describe Neography::Rest do
       new_node1 = @neo.create_node
       new_node2 = @neo.create_node
       new_relationship = @neo.create_unique_relationship(index_name, key, value, "friends", new_node1, new_node2)
-      new_relationship["data"][key].should == value
+      expect(new_relationship["data"][key]).to eq(value)
     end
 
   end
@@ -59,9 +59,9 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
       existing_relationship = @neo.get_relationship(new_relationship)
-      existing_relationship.should_not be_nil
-      existing_relationship.should have_key("self")
-      existing_relationship["self"].should == new_relationship["self"]
+      expect(existing_relationship).not_to be_nil
+      expect(existing_relationship).to have_key("self")
+      expect(existing_relationship["self"]).to eq(new_relationship["self"])
     end
 
     it "raises error if it tries to get a relationship that does not exist" do
@@ -83,9 +83,9 @@ describe Neography::Rest do
       @neo.set_relationship_properties(new_relationship, {"since" => '10-1-2010', "met" => "college"})
       @neo.set_relationship_properties(new_relationship, {"roommates" => "no"})
       relationship_properties = @neo.get_relationship_properties(new_relationship)
-      relationship_properties["since"].should == '10-1-2010'
-      relationship_properties["met"].should == "college"
-      relationship_properties["roommates"].should == "no"
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+      expect(relationship_properties["met"]).to eq("college")
+      expect(relationship_properties["roommates"]).to eq("no")
     end
 
     it "it fails to set properties on a relationship that does not exist" do
@@ -107,9 +107,9 @@ describe Neography::Rest do
       @neo.set_relationship_properties(new_relationship, {"since" => '10-1-2010', "met" => "college"})
       @neo.reset_relationship_properties(new_relationship, {"roommates" => "no"})
       relationship_properties = @neo.get_relationship_properties(new_relationship)
-      relationship_properties["since"].should be_nil
-      relationship_properties["met"].should be_nil
-      relationship_properties["roommates"].should == "no"
+      expect(relationship_properties["since"]).to be_nil
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["roommates"]).to eq("no")
     end
 
     it "it fails to reset properties on a relationship that does not exist" do
@@ -129,8 +129,8 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
       relationship_properties = @neo.get_relationship_properties(new_relationship)
-      relationship_properties["since"].should == '10-1-2010'
-      relationship_properties["met"].should == "college"
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+      expect(relationship_properties["met"]).to eq("college")
     end
 
     it "can get some of a relationship's properties" do
@@ -138,9 +138,9 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college", "roommates" => "no"})
       relationship_properties = @neo.get_relationship_properties(new_relationship, ["since", "roommates"])
-      relationship_properties["since"].should == '10-1-2010'
-      relationship_properties["met"].should be_nil
-      relationship_properties["roommates"].should == "no"
+      expect(relationship_properties["since"]).to eq('10-1-2010')
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["roommates"]).to eq("no")
     end
 
     it "returns nil if it gets the properties on a relationship that does not have any" do
@@ -148,7 +148,7 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
       relationship_properties = @neo.get_relationship_properties(new_relationship)
-      relationship_properties.should be_nil
+      expect(relationship_properties).to be_nil
     end
 
     it "raises error if it tries to get some of the properties on a relationship that does not have any" do
@@ -177,7 +177,7 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
       @neo.remove_relationship_properties(new_relationship)
-      @neo.get_relationship_properties(new_relationship).should be_nil
+      expect(@neo.get_relationship_properties(new_relationship)).to be_nil
     end
 
     it "raises error if it fails to remove the properties of a relationship that does not exist" do
@@ -196,8 +196,8 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
       @neo.remove_relationship_properties(new_relationship, "met")
       relationship_properties = @neo.get_relationship_properties(new_relationship)
-      relationship_properties["met"].should be_nil
-      relationship_properties["since"].should == '10-1-2010'
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["since"]).to eq('10-1-2010')
     end
 
     it "can remove more than one relationship property" do
@@ -206,9 +206,9 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college", "roommates" => "no"})
       @neo.remove_relationship_properties(new_relationship, ["met", "since"])
       relationship_properties = @neo.get_relationship_properties(new_relationship)
-      relationship_properties["met"].should be_nil
-      relationship_properties["since"].should be_nil
-      relationship_properties["roommates"].should == "no"
+      expect(relationship_properties["met"]).to be_nil
+      expect(relationship_properties["since"]).to be_nil
+      expect(relationship_properties["roommates"]).to eq("no")
     end
   end
 
@@ -219,7 +219,7 @@ describe Neography::Rest do
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
       @neo.delete_relationship(new_relationship)
       relationships = @neo.get_node_relationships(new_node1)
-      relationships.should be_empty
+      expect(relationships).to be_empty
     end
 
     it "raises error if it tries to delete a relationship that does not exist" do
@@ -237,7 +237,7 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2, {"since" => '10-1-2010', "met" => "college"})
       existing_relationship = @neo.delete_relationship(new_relationship)
-      existing_relationship.should be_nil
+      expect(existing_relationship).to be_nil
       expect {
         existing_relationship = @neo.delete_relationship(new_relationship)
       }.to raise_error Neography::RelationshipNotFoundException
@@ -250,12 +250,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(new_node1)
-      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
@@ -265,17 +265,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_node3, {"since" => '10-2-2010', "met" => "work"})
       relationships = @neo.get_node_relationships(new_node1)
-      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_node3["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_node3["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 a node's outgoing relationship" do
@@ -285,13 +285,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(new_node1, "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 a node's incoming relationship" do
@@ -301,13 +301,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(new_node1, "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
@@ -317,13 +317,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_node1, new_node3, {"since" => '10-2-2010', "met" => "work"})
       relationships = @neo.get_node_relationships(new_node1, "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
@@ -335,19 +335,19 @@ 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(new_node1, "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
       relationships = @neo.get_node_relationships(new_node1)
-      relationships.should be_empty
+      expect(relationships).to be_empty
     end
   end