redgraph 0.1.0 → 0.2.0

data/lib/redgraph/util.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Redgraph
+  module Util
+    def properties_to_string(hash)
+      return if hash.empty?
+      "{" +
+      hash.map {|k,v| "#{k}:#{escape_value(v)}" }.join(", ") +
+      "}"
+    end
+
+    def escape_value(x)
+      case x
+      when Integer then x
+      when NilClass then "''"
+      else
+        '"' + x.gsub('"', '\"') + '"'
+      end
+    end
+  end
+end

data/lib/redgraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Redgraph
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/redgraph.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0")
@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "redis", "~> 4"
+  spec.add_dependency "activesupport", ">= 3.0.0"
 end

data/test/graph_edge_methods_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class GraphEdgeMethodsTest < Minitest::Test
+  include TestHelpers
+
+  def setup
+    @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  def test_find_edge
+    quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
+    edge = @graph.edges.first
+
+    assert_equal('FRIEND_OF', edge.type)
+    assert_equal(1980, edge.properties["since"])
+    assert_equal(@al, edge.src)
+    assert_equal(@john, edge.dest)
+  end
+
+  def test_find_all_edges
+    marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
+    film = quick_add_node(label: 'film', properties: {name: "The Godfather"})
+    quick_add_edge(type: 'ACTOR_IN', src: marlon, dest: film, properties: {role: 'Don Vito'})
+    quick_add_edge(type: 'ACTOR_IN', src: @al,    dest: film, properties: {role: 'Michael'})
+
+    edges = @graph.edges
+    assert_equal(2, edges.size)
+  end
+
+  def test_count_edges
+    marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
+    film = quick_add_node(label: 'film', properties: {name: "The Godfather"})
+    quick_add_edge(type: 'ACTOR_IN', src: marlon, dest: film, properties: {role: 'Don Vito'})
+    quick_add_edge(type: 'ACTOR_IN', src: @al,    dest: film, properties: {role: 'Michael'})
+
+    assert_equal(2, @graph.count_edges)
+  end
+
+  def test_filter_edges
+    marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
+    film = quick_add_node(label: 'film', properties: {name: "The Godfather"})
+    other_film = quick_add_node(label: 'film', properties: {name: "Carlito's Way"})
+    e_donvito = quick_add_edge(type: 'ACTOR_IN', src: marlon, dest: film, properties: {role: 'Don Vito'})
+    e_michael = quick_add_edge(type: 'ACTOR_IN', src: @al, dest: film, properties: {role: 'Michael'})
+    e_carlito = quick_add_edge(type: 'ACTOR_IN', src: @al, dest: other_film, properties: {role: 'Carlito'})
+    quick_add_edge(type: 'FRIEND_OF', src: @al, dest: marlon, properties: {since: 1980})
+
+    edges = @graph.edges(type: "FRIEND_OF")
+    assert_equal(1, edges.size)
+
+    edges = @graph.edges(type: "ACTOR_IN")
+    assert_equal(3, edges.size)
+
+    edges = @graph.edges(type: "ACTOR_IN", limit: 2)
+    assert_equal(2, edges.size)
+
+    edges = @graph.edges(type: "ACTOR_IN", skip: 2, limit: 10)
+    assert_equal(1, edges.size)
+
+    edges = @graph.edges(properties: {role: "Carlito"})
+    assert_equal([e_carlito], edges)
+
+    edges = @graph.edges(src: marlon)
+    assert_equal([e_donvito], edges)
+
+    edges = @graph.edges(type: 'ACTOR_IN', dest: film)
+    assert_equal(2, edges.size)
+    assert_includes(edges, e_donvito)
+    assert_includes(edges, e_michael)
+
+    edges = @graph.edges(src: @al, dest: marlon)
+    assert_equal(1, edges.size)
+    edge = edges[0]
+    assert_equal('FRIEND_OF', edge.type)
+    assert_equal(1980, edge.properties["since"])
+  end
+
+  def test_order_edges
+    marlon = quick_add_node(label: 'actor', properties: {name: "Marlon Brando"})
+
+    e1 = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: marlon, properties: {since: 1980})
+    e2 = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 2000})
+    e3 = quick_add_edge(type: 'FRIEND_OF', src: marlon, dest: @john, properties: {since: 1990})
+
+    edges = @graph.edges(type: 'FRIEND_OF', order: "edge.since ASC")
+    assert_equal([e1, e3, e2], edges)
+
+    edges = @graph.edges(type: 'FRIEND_OF', order: "edge.since DESC")
+    assert_equal([e2, e3, e1], edges)
+  end
+end

data/test/graph_manipulation_test.rb

@@ -3,6 +3,8 @@
 require "test_helper"
 
 class GraphManipulationTest < Minitest::Test
+  include TestHelpers
+
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
   end
@@ -17,6 +19,35 @@ class GraphManipulationTest < Minitest::Test
     assert_predicate result, :persisted?
   end
 
+  def test_add_node_with_special_chars
+    [
+      "apo'str",
+      "two''apos",
+      "Foø'bÆ®",
+      "aa\nbb",
+      'aaa "bbb" ccc'
+    ].each do |name|
+
+      node = Redgraph::Node.new(label: 'actor', properties: {name: name})
+      result = @graph.add_node(node)
+      assert_predicate result, :persisted?
+
+      item = @graph.find_node_by_id(node.id)
+
+      assert_equal(name, item.properties["name"])
+    end
+  end
+
+  def test_add_node_with_nil_value
+    node = Redgraph::Node.new(label: 'actor', properties: {name: nil})
+    result = @graph.add_node(node)
+    assert_predicate result, :persisted?
+
+    item = @graph.find_node_by_id(node.id)
+
+    assert_equal("", item.properties["name"])
+  end
+
   def test_add_edge
     actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
     @graph.add_node(actor)
@@ -29,4 +60,32 @@ class GraphManipulationTest < Minitest::Test
 
     assert_predicate result, :persisted?
   end
+
+  def test_merge_node
+    quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+
+    nodes = @graph.nodes(label: 'actor')
+    assert_equal(2, nodes.size)
+
+    @graph.merge_node(Redgraph::Node.new(label: 'actor', properties: {name: "Joe Pesci"}))
+    assert_equal(3, @graph.nodes(label: 'actor').size)
+
+    @graph.merge_node(Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"}))
+    assert_equal(3, @graph.nodes(label: 'actor').size)
+  end
+
+  def test_merge_edge
+    al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+
+    assert_equal(0, @graph.edges.size)
+
+    edge = Redgraph::Edge.new(type: 'FRIEND_OF', src: al, dest: john, properties: {since: 1990})
+    @graph.merge_edge(edge)
+    assert_equal(1, @graph.edges.size)
+
+    @graph.merge_edge(edge)
+    assert_equal(1, @graph.edges.size)
+  end
 end

data/test/graph_node_methods_test.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class GraphNodeMethodsTest < Minitest::Test
+  include TestHelpers
+
+  def setup
+    @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta"})
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  def test_find_node_by_id
+    node = @graph.find_node_by_id(@al.id)
+
+    refute_nil(node)
+    assert_equal("actor", node.label)
+    assert_equal("Al Pacino", node.properties["name"])
+    assert_equal(@al.id, node.id)
+  end
+
+  def test_find_node_by_wrong_id
+    node = @graph.find_node_by_id("-1")
+
+    assert_nil(node)
+  end
+
+  def test_find_all_nodes
+    actors = @graph.nodes
+
+    assert_equal(2, actors.size)
+    assert_includes(actors, @al)
+    assert_includes(actors, @john)
+  end
+
+  def test_find_all_nodes_by_label
+    film = quick_add_node(label: 'film', properties: {name: "Scarface"})
+
+    actors = @graph.nodes(label: 'actor')
+    assert_equal(2, actors.size)
+    assert_includes(actors, @al)
+    assert_includes(actors, @john)
+
+    films = @graph.nodes(label: 'film')
+    assert_equal(1, films.size)
+    assert_includes(films, film)
+  end
+
+  def test_find_all_nodes_by_property
+    scarface = quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
+    casino = quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
+    _mamma_mia = quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
+
+    dramas = @graph.nodes(properties: {genre: "drama"})
+
+    assert_equal(2, dramas.size)
+    assert_includes(dramas, scarface)
+    assert_includes(dramas, casino)
+  end
+
+  def test_order_nodes_by_property
+    scarface = quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
+    casino = quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
+    mamma_mia = quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
+
+    items = @graph.nodes(label: 'film', order: "node.name")
+    assert_equal([casino, mamma_mia, scarface], items)
+
+    items = @graph.nodes(label: 'film', order: "node.name ASC")
+    assert_equal([casino, mamma_mia, scarface], items)
+
+    items = @graph.nodes(label: 'film', order: "node.name DESC")
+    assert_equal([scarface, mamma_mia, casino], items)
+  end
+
+  def test_count_nodes
+    quick_add_node(label: 'film', properties: {name: "Scarface", genre: "drama"})
+    quick_add_node(label: 'film', properties: {name: "Casino", genre: "drama"})
+    quick_add_node(label: 'film', properties: {name: "Mamma Mia", genre: "musical"})
+
+
+    assert_equal(5, @graph.count_nodes)
+    assert_equal(3, @graph.count_nodes(label: 'film'))
+    assert_equal(2, @graph.count_nodes(properties: {genre: "drama"}))
+  end
+
+  def test_limit_nodes
+    10.times do |i|
+      quick_add_node(label: 'token', properties: {number: i})
+    end
+
+    items = @graph.nodes(label: 'token', limit: 5)
+    assert_equal(5, items.size)
+    assert_equal([0,1,2,3,4], items.map{|item| item.properties["number"]})
+  end
+
+  def test_skip_nodes
+    10.times do |i|
+      quick_add_node(label: 'token', properties: {number: i})
+    end
+
+    items = @graph.nodes(label: 'token', limit: 3, skip: 3)
+    assert_equal(3, items.size)
+    assert_equal([3,4,5], items.map{|item| item.properties["number"]})
+  end
+end

data/test/graph_queries_test.rb

@@ -3,56 +3,43 @@
 require "test_helper"
 
 class GraphQueriesTest < Minitest::Test
+  include TestHelpers
+
   def setup
     @graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
-    @actor = Redgraph::Node.new(label: 'actor', properties: {name: "Al Pacino"})
-    @graph.add_node(@actor)
 
-    @other_actor = Redgraph::Node.new(label: 'actor', properties: {name: "John Travolta"})
-    refute_nil(@actor.id)
+    @al = quick_add_node(label: 'actor', properties: {name: "Al Pacino", born: 1940})
+    @john = quick_add_node(label: 'actor', properties: {name: "John Travolta", born: 1954})
   end
 
   def teardown
     @graph.delete
   end
 
-  def test_find_node_by_id
-    node = @graph.find_node_by_id(@actor.id)
-
-    refute_nil(node)
-    assert_equal("actor", node.label)
-    assert_equal("Al Pacino", node.properties["name"])
-    assert_equal(@actor.id, node.id)
+  def test_query_string_attribute
+    result = @graph.query("MATCH (n) RETURN n.name ORDER BY n.name")
+    assert_equal([["Al Pacino"], ["John Travolta"]], result)
   end
 
-  def test_get_all_nodes
-    @graph.add_node(@other_actor)
-
-    actors = @graph.nodes
-
-    assert_equal(2, actors.size)
-    assert_includes(actors, @actor)
-    assert_includes(actors, @other_actor)
+  def test_query_string_and_number_attributes
+    result = @graph.query("MATCH (n) RETURN n.name, n.born ORDER BY n.born")
+    assert_equal([["Al Pacino", 1940], ["John Travolta", 1954]], result)
   end
 
-  def test_get_all_nodes_by_label
-    @graph.add_node(@other_actor)
-    film = Redgraph::Node.new(label: 'film', properties: {name: "Scarface"})
-    @graph.add_node(film)
-
-    actors = @graph.nodes(label: 'actor')
-    assert_equal(2, actors.size)
-    assert_includes(actors, @actor)
-    assert_includes(actors, @other_actor)
-
-    films = @graph.nodes(label: 'film')
-    assert_equal(1, films.size)
-    assert_includes(films, film)
+  def test_query_nodes
+    result = @graph.query("MATCH (n) RETURN n ORDER BY n.born")
+    assert_equal([[@al], [@john]], result)
   end
 
-  def test_find_node_by_wrong_id
-    node = @graph.find_node_by_id("-1")
+  def test_query_edge
+    edge = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
+    result = @graph.query("MATCH (src)-[edge]->(dest) RETURN edge")
+    assert_equal([[edge]], result)
+  end
 
-    assert_nil(node)
+  def test_query_node_and_edge
+    edge = quick_add_edge(type: 'FRIEND_OF', src: @al, dest: @john, properties: {since: 1980})
+    result = @graph.query("MATCH (src)-[edge:FRIEND_OF]->(dest) RETURN src, edge")
+    assert_equal([[@al, edge]], result)
   end
 end

data/test/graph_test.rb

@@ -12,11 +12,13 @@ class GraphTest < Minitest::Test
   end
 
   def test_list
+    skip unless graph_list_supported?
     list = @graph.list
     assert_includes(list, "foobar")
   end
 
   def test_delete
+    skip unless graph_list_supported?
     assert_includes(@graph.list, "foobar")
 
     @graph.delete
@@ -42,6 +44,19 @@ class GraphTest < Minitest::Test
     assert_equal(["name", "age"], @graph.properties)
   end
 
+  def test_relationship_types
+    @graph = create_sample_graph("foobar")
+
+    actor = Redgraph::Node.new(label: "actor", properties: {"name": "Harrison Ford"})
+    @graph.add_node(actor)
+    film = Redgraph::Node.new(label: "film", properties: {"name": "Star Wars"})
+    @graph.add_node(film)
+    edge = Redgraph::Edge.new(type: "ACTED_IN", src: actor, dest: film)
+    @graph.add_edge(edge)
+
+    assert_equal(["ACTED_IN"], @graph.relationship_types)
+  end
+
   private
 
   def create_sample_graph(name)
@@ -53,4 +68,15 @@ class GraphTest < Minitest::Test
     )
     graph
   end
+
+  # This command is only supported in the latest version
+  def graph_list_supported?
+    @graph.list
+  rescue Redis::CommandError => e
+    if e.message =~ /ERR unknown command `GRAPH.LIST`/
+      false
+    else
+      true
+    end
+  end
 end