neography 1.5.0 → 1.5.1

data/spec/integration/rest_relationship_types_spec.rb

@@ -11,8 +11,8 @@ describe Neography::Rest do
       new_node2 = @neo.create_node
       new_relationship = @neo.create_relationship("friends", new_node1, new_node2)
       rel_types = @neo.list_relationship_types
-      rel_types.should_not be_nil
-      rel_types.should include("friends")
+      expect(rel_types).not_to be_nil
+      expect(rel_types).to include("friends")
     end
   end
 end

data/spec/integration/rest_schema_index_spec.rb

@@ -8,8 +8,8 @@ describe Neography::Rest do
   describe "create a schema index" do
     it "can create a schema index" do
       si = @neo.create_schema_index("person", ["name"]) 
-      si.should_not be_nil
-      si["property_keys"].should include("name")
+      expect(si).not_to be_nil
+      expect(si["property_keys"]).to include("name")
     end
     
   end
@@ -17,16 +17,16 @@ describe Neography::Rest do
   describe "list schema indexes" do
     it "can get a listing of node indexes" do
       si = @neo.get_schema_index("person")
-      si.should_not be_nil
-      si.first["label"].should include("person")
-      si.first["property_keys"].should include("name")
+      expect(si).not_to be_nil
+      expect(si.first["label"]).to include("person")
+      expect(si.first["property_keys"]).to include("name")
     end
   end
   
   describe "drop schema indexes" do
     it "can drop an existing schema index" do
       si = @neo.delete_schema_index("person", "name")
-      si.should be_nil
+      expect(si).to be_nil
     end
   end
 end

data/spec/integration/rest_spatial_spec.rb

@@ -8,51 +8,51 @@ describe Neography::Rest do
   describe "find the spatial plugin" do
     it "can get a description of the spatial plugin" do
       si = @neo.get_spatial
-      si.should_not be_nil
-      si["graphdb"]["addEditableLayer"].should_not be_nil
+      expect(si).not_to be_nil
+      expect(si["graphdb"]["addEditableLayer"]).not_to be_nil
     end
   end
 
   describe "add a point layer" do
     it "can add a simple point layer" do
       pl = @neo.add_point_layer("restaurants") 
-      pl.should_not be_nil
-      pl.first["data"]["layer"].should == "restaurants"
-      pl.first["data"]["geomencoder_config"].should == "lon:lat"
+      expect(pl).not_to be_nil
+      expect(pl.first["data"]["layer"]).to eq("restaurants")
+      expect(pl.first["data"]["geomencoder_config"]).to eq("lon:lat")
     end
 
     it "can add a simple point layer with lat and long" do
       pl = @neo.add_point_layer("coffee_shops", "latitude", "longitude") 
-      pl.should_not be_nil
-      pl.first["data"]["layer"].should == "coffee_shops"
-      pl.first["data"]["geomencoder_config"].should == "longitude:latitude"
+      expect(pl).not_to be_nil
+      expect(pl.first["data"]["layer"]).to eq("coffee_shops")
+      expect(pl.first["data"]["geomencoder_config"]).to eq("longitude:latitude")
     end
   end
 
   describe "add an editable layer" do
     it "can add an editable layer" do
       el = @neo.add_editable_layer("zipcodes", "WKT", "wkt") 
-      el.should_not be_nil
-      el.first["data"]["layer"].should == "zipcodes"
-      el.first["data"]["geomencoder_config"].should == "wkt"
+      expect(el).not_to be_nil
+      expect(el.first["data"]["layer"]).to eq("zipcodes")
+      expect(el.first["data"]["geomencoder_config"]).to eq("wkt")
     end
   end
 
   describe "get a spatial layer" do
     it "can get a layer" do
       sl = @neo.get_layer("restaurants")
-      sl.should_not be_nil
-      sl.first["data"]["layer"].should == "restaurants"
+      expect(sl).not_to be_nil
+      expect(sl.first["data"]["layer"]).to eq("restaurants")
     end
   end
 
   describe "create a spatial index" do
     it "can create a spatial index" do
       index = @neo.create_spatial_index("restaurants")
-      index["provider"].should == "spatial"
-      index["geometry_type"].should == "point"
-      index["lat"].should == "lat"
-      index["lon"].should == "lon"
+      expect(index["provider"]).to eq("spatial")
+      expect(index["geometry_type"]).to eq("point")
+      expect(index["lat"]).to eq("lat")
+      expect(index["lon"]).to eq("lon")
     end
   end
 
@@ -60,8 +60,8 @@ describe Neography::Rest do
     it "can add a geometry" do
       geometry = "LINESTRING (15.2 60.1, 15.3 60.1)"
       geo = @neo.add_geometry_to_layer("zipcodes", geometry)
-      geo.should_not be_nil
-      geo.first["data"]["wkt"].should == geometry
+      expect(geo).not_to be_nil
+      expect(geo.first["data"]["wkt"]).to eq(geometry)
     end
   end
 
@@ -69,12 +69,12 @@ describe Neography::Rest do
     it "can update a geometry" do
       geometry = "LINESTRING (15.2 60.1, 15.3 60.1)"
       geo = @neo.add_geometry_to_layer("zipcodes", geometry)
-      geo.should_not be_nil
-      geo.first["data"]["wkt"].should == geometry
+      expect(geo).not_to be_nil
+      expect(geo.first["data"]["wkt"]).to eq(geometry)
       geometry = "LINESTRING (14.7 60.1, 15.3 60.1)"
       existing_geo = @neo.edit_geometry_from_layer("zipcodes", geometry, geo)
-      existing_geo.first["data"]["wkt"].should == geometry
-      existing_geo.first["self"].split('/').last.to_i.should ==  geo.first["self"].split('/').last.to_i 
+      expect(existing_geo.first["data"]["wkt"]).to eq(geometry)
+      expect(existing_geo.first["self"].split('/').last.to_i).to eq(geo.first["self"].split('/').last.to_i) 
     end
   end
 
@@ -82,14 +82,14 @@ describe Neography::Rest do
     it "can add a node to a simple point layer" do
       properties = {:name => "Max's Restaurant", :lat => 41.8819, :lon => 87.6278}
       node = @neo.create_node(properties)
-      node.should_not be_nil
+      expect(node).not_to be_nil
       added = @neo.add_node_to_layer("restaurants", node)
-      added.first["data"]["lat"].should == properties[:lat]
-      added.first["data"]["lon"].should == properties[:lon]
+      expect(added.first["data"]["lat"]).to eq(properties[:lat])
+      expect(added.first["data"]["lon"]).to eq(properties[:lon])
 
       added = @neo.add_node_to_index("restaurants", "dummy", "dummy", node)
-      added["data"]["lat"].should == properties[:lat]
-      added["data"]["lon"].should == properties[:lon]
+      expect(added["data"]["lat"]).to eq(properties[:lat])
+      expect(added["data"]["lon"]).to eq(properties[:lon])
     end
   end
   
@@ -97,10 +97,10 @@ describe Neography::Rest do
     it "can find a geometry in a bounding box" do
       properties = {:name => "Max's Restaurant", :lat => 41.8819, :lon => 87.6278}
       node = @neo.find_geometries_in_bbox("restaurants", 87.5, 87.7, 41.7, 41.9)
-      node.should_not be_empty
-      node.first["data"]["lat"].should == properties[:lat]
-      node.first["data"]["lon"].should == properties[:lon]
-      node.first["data"]["name"].should == "Max's Restaurant"
+      expect(node).not_to be_empty
+      expect(node.first["data"]["lat"]).to eq(properties[:lat])
+      expect(node.first["data"]["lon"]).to eq(properties[:lon])
+      expect(node.first["data"]["name"]).to eq("Max's Restaurant")
     end
     
     it "can find a geometry in a bounding box using cypher" do
@@ -109,9 +109,9 @@ describe Neography::Rest do
       node = @neo.create_node(properties)
       added = @neo.add_node_to_index("geombbcypher", "dummy", "dummy", node)
       existing_node = @neo.execute_query("start node = node:geombbcypher('bbox:[15.0,15.3,60.0,60.2]') return node")
-      existing_node.should_not be_empty
-      existing_node["data"][0][0]["data"]["lat"].should == properties[:lat]
-      existing_node["data"][0][0]["data"]["lon"].should == properties[:lon]
+      expect(existing_node).not_to be_empty
+      expect(existing_node["data"][0][0]["data"]["lat"]).to eq(properties[:lat])
+      expect(existing_node["data"][0][0]["data"]["lon"]).to eq(properties[:lon])
     end
 
     it "can find a geometry in a bounding box using cypher two" do
@@ -120,9 +120,9 @@ describe Neography::Rest do
       node = @neo.create_node(properties)
       added = @neo.add_node_to_spatial_index("geombbcypher2", node)
       existing_node = @neo.execute_query("start node = node:geombbcypher2('bbox:[15.0,15.3,60.0,60.2]') return node")
-      existing_node.should_not be_empty
-      existing_node["data"][0][0]["data"]["lat"].should == properties[:lat]
-      existing_node["data"][0][0]["data"]["lon"].should == properties[:lon]
+      expect(existing_node).not_to be_empty
+      expect(existing_node["data"][0][0]["data"]["lat"]).to eq(properties[:lat])
+      expect(existing_node["data"][0][0]["data"]["lon"]).to eq(properties[:lon])
     end
 
   end
@@ -131,10 +131,10 @@ describe Neography::Rest do
     it "can find a geometry within distance" do
       properties = {:name => "Max's Restaurant", :lat => 41.8819, :lon => 87.6278}
       node = @neo.find_geometries_within_distance("restaurants", 87.627, 41.881, 10)
-      node.should_not be_empty
-      node.first["data"]["lat"].should == properties[:lat]
-      node.first["data"]["lon"].should == properties[:lon]
-      node.first["data"]["name"].should == "Max's Restaurant"
+      expect(node).not_to be_empty
+      expect(node.first["data"]["lat"]).to eq(properties[:lat])
+      expect(node.first["data"]["lon"]).to eq(properties[:lon])
+      expect(node.first["data"]["name"]).to eq("Max's Restaurant")
     end
 
     it "can find a geometry within distance using cypher" do
@@ -143,10 +143,10 @@ describe Neography::Rest do
       node = @neo.create_node(properties)
       added = @neo.add_node_to_index("geowdcypher", "dummy", "dummy", node)
       existing_node = @neo.execute_query("start n = node:geowdcypher({bbox}) return n", {:bbox => "withinDistance:[60.0,15.0,100.0]"})
-      existing_node.should_not be_empty
-      existing_node.should_not be_empty
-      existing_node["data"][0][0]["data"]["lat"].should == properties[:lat]
-      existing_node["data"][0][0]["data"]["lon"].should == properties[:lon]
+      expect(existing_node).not_to be_empty
+      expect(existing_node).not_to be_empty
+      expect(existing_node["data"][0][0]["data"]["lat"]).to eq(properties[:lat])
+      expect(existing_node["data"][0][0]["data"]["lon"]).to eq(properties[:lon])
     end
 
     it "can find a geometry within distance using cypher 2"  do
@@ -155,10 +155,10 @@ describe Neography::Rest do
       node = @neo.create_node(properties)
       added = @neo.add_node_to_spatial_index("geowdcypher2", node)
       existing_node = @neo.execute_query("start n = node:geowdcypher2({bbox}) return n", {:bbox => "withinDistance:[60.0,15.0,100.0]"})
-      existing_node.should_not be_empty
-      existing_node.should_not be_empty
-      existing_node["data"][0][0]["data"]["lat"].should == properties[:lat]
-      existing_node["data"][0][0]["data"]["lon"].should == properties[:lon]
+      expect(existing_node).not_to be_empty
+      expect(existing_node).not_to be_empty
+      expect(existing_node["data"][0][0]["data"]["lat"]).to eq(properties[:lat])
+      expect(existing_node["data"][0][0]["data"]["lon"]).to eq(properties[:lon])
     end
 
   end

data/spec/integration/rest_transaction_spec.rb

@@ -8,26 +8,26 @@ describe Neography::Rest do
   describe "start a transaction" do
     it "can start a transaction" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
     end
 
     it "can start a transaction with statements" do
       tx = @neo.begin_transaction("start n=node(0) return n")
-      tx.should have_key("transaction")
-      tx.should have_key("results")
-      tx["results"].should_not be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx).to have_key("results")
+      expect(tx["results"]).not_to be_empty
     end
 
     it "can start a transaction with statements and represent them as a graph" do
       tx = @neo.begin_transaction(["CREATE ( bike:Bike { weight: 10 } ) CREATE ( frontWheel:Wheel { spokes: 3 } ) CREATE ( backWheel:Wheel { spokes: 32 } ) CREATE p1 = bike -[:HAS { position: 1 } ]-> frontWheel CREATE p2 = bike -[:HAS { position: 2 } ]-> backWheel RETURN bike, p1, p2", 
                                  ["row", "graph", "rest"]])
-      tx.should have_key("transaction")
-      tx.should have_key("results")
-      tx["results"].should_not be_empty
-      tx["results"].first["data"].first["row"].should_not be_empty
-      tx["results"].first["data"].first["graph"].should_not be_empty
-      tx["results"].first["data"].first["rest"].should_not be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx).to have_key("results")
+      expect(tx["results"]).not_to be_empty
+      expect(tx["results"].first["data"].first["row"]).not_to be_empty
+      expect(tx["results"].first["data"].first["graph"]).not_to be_empty
+      expect(tx["results"].first["data"].first["rest"]).not_to be_empty
     end
 
 
@@ -36,12 +36,12 @@ describe Neography::Rest do
   describe "keep a transaction" do
     it "can keep a transaction" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       sleep(1)
       existing_tx = @neo.keep_transaction(tx)
-      existing_tx.should have_key("transaction")
-      existing_tx["transaction"]["expires"].should > tx["transaction"]["expires"]
+      expect(existing_tx).to have_key("transaction")
+      expect(existing_tx["transaction"]["expires"]).to be > tx["transaction"]["expires"]
     end
   end
 
@@ -49,42 +49,42 @@ describe Neography::Rest do
   describe "add to a transaction" do
     it "can add to a transaction" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.in_transaction(tx, "start n=node(0) return n")
-      existing_tx.should have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should_not be_empty
+      expect(existing_tx).to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).not_to be_empty
     end
 
     it "can add to a transaction with parameters" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.in_transaction(tx, ["start n=node({id}) return n", {:id => 0}])
-      existing_tx.should have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should_not be_empty
+      expect(existing_tx).to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).not_to be_empty
     end    
 
     it "can add to a transaction with representation" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.in_transaction(tx, ["start n=node(0) return n", [:row,:rest]])
-      existing_tx.should have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should_not be_empty
+      expect(existing_tx).to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).not_to be_empty
     end    
 
     it "can add to a transaction with parameters and representation" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.in_transaction(tx, ["start n=node({id}) return n", {:id => 0}, [:row,:rest]])
-      existing_tx.should have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should_not be_empty
+      expect(existing_tx).to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).not_to be_empty
     end    
     
   end
@@ -92,52 +92,52 @@ describe Neography::Rest do
   describe "commit a transaction" do
     it "can commit an opened empty transaction" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.commit_transaction(tx)
-      existing_tx.should have_key("results")
-      existing_tx["results"].should be_empty
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).to be_empty
     end
 
     it "can commit an opened transaction" do
       tx = @neo.begin_transaction("start n=node(0) return n")
-      tx.should have_key("transaction")
-      tx["results"].should_not be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).not_to be_empty
       existing_tx = @neo.commit_transaction(tx)
-      existing_tx.should_not have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should be_empty
+      expect(existing_tx).not_to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).to be_empty
     end
     
     it "can commit an opened transaction with new statements" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.commit_transaction(tx, "start n=node(0) return n")
-      existing_tx.should_not have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should_not be_empty
+      expect(existing_tx).not_to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).not_to be_empty
     end
 
     it "can commit an new transaction right away" do
       tx = @neo.commit_transaction(["start n=node(0) return n"])
-      tx.should_not have_key("transaction")
-      tx.should have_key("results")
-      tx["results"].should_not be_empty
+      expect(tx).not_to have_key("transaction")
+      expect(tx).to have_key("results")
+      expect(tx["results"]).not_to be_empty
     end
     
     it "can commit an new transaction right away with parameters" do
       tx = @neo.commit_transaction(["start n=node({id}) return n", {:id => 0}])
-      tx.should_not have_key("transaction")
-      tx.should have_key("results")
-      tx["results"].should_not be_empty
+      expect(tx).not_to have_key("transaction")
+      expect(tx).to have_key("results")
+      expect(tx["results"]).not_to be_empty
     end
 
     it "can commit an new transaction right away without parameters" do
       tx = @neo.commit_transaction("start n=node(0) return n")
-      tx.should_not have_key("transaction")
-      tx.should have_key("results")
-      tx["results"].should_not be_empty
+      expect(tx).not_to have_key("transaction")
+      expect(tx).to have_key("results")
+      expect(tx["results"]).not_to be_empty
     end
     
   end
@@ -145,21 +145,21 @@ describe Neography::Rest do
   describe "rollback a transaction" do
     it "can rollback an opened empty transaction" do
       tx = @neo.begin_transaction
-      tx.should have_key("transaction")
-      tx["results"].should be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).to be_empty
       existing_tx = @neo.rollback_transaction(tx)
-      existing_tx.should have_key("results")
-      existing_tx["results"].should be_empty
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).to be_empty
     end
 
     it "can rollback an opened transaction" do
       tx = @neo.begin_transaction("start n=node(0) return n")
-      tx.should have_key("transaction")
-      tx["results"].should_not be_empty
+      expect(tx).to have_key("transaction")
+      expect(tx["results"]).not_to be_empty
       existing_tx = @neo.rollback_transaction(tx)
-      existing_tx.should_not have_key("transaction")
-      existing_tx.should have_key("results")
-      existing_tx["results"].should be_empty
+      expect(existing_tx).not_to have_key("transaction")
+      expect(existing_tx).to have_key("results")
+      expect(existing_tx["results"]).to be_empty
     end
   end