redgraph 0.1.1 → 0.2.1

data/test/graph_queries_test.rb

@@ -3,88 +3,43 @@
 require "test_helper"
 
 class GraphQueriesTest < 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"})
+    @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(@al.id)
-
-    refute_nil(node)
-    assert_equal("actor", node.label)
-    assert_equal("Al Pacino", node.properties["name"])
-    assert_equal(@al.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_find_node_by_wrong_id
-    node = @graph.find_node_by_id("-1")
-
-    assert_nil(node)
+  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_find_all_nodes
-    actors = @graph.nodes
-
-    assert_equal(2, actors.size)
-    assert_includes(actors, @al)
-    assert_includes(actors, @john)
+  def test_query_nodes
+    result = @graph.query("MATCH (n) RETURN n ORDER BY n.born")
+    assert_equal([[@al], [@john]], result)
   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)
+  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
 
-  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_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
-
-  private
-
-  def quick_add_node(label:, properties:)
-    @graph.add_node(Redgraph::Node.new(label: label, properties: properties))
+  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

data/test/node_model_class_methods_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelClassMethodsTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Actor
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  class MissingGraphActor
+    include Redgraph::NodeModel
+    attribute :name
+  end
+
+  # tests
+  #
+
+  def test_count
+    quick_add_node(label: 'actor', properties: {_type: Actor.name, name: "Al Pacino"})
+    quick_add_node(label: 'actor', properties: {_type: Actor.name, name: "John Travolta"})
+    assert_equal(2, Actor.count)
+    assert_equal(1, Actor.count(properties: {name: "Al Pacino"}))
+  end
+
+  def test_all
+    al = Actor.new(name: "Al Pacino").add_to_graph
+    john = Actor.new(name: "John Travolta").add_to_graph
+
+    items = Actor.all
+    assert_equal(2, items.size)
+    assert_includes(items, al)
+    assert_includes(items, john)
+
+    items = Actor.all(properties: {name: "Al Pacino"})
+    assert_equal(1, items.size)
+    assert_includes(items, al)
+  end
+
+  def test_find
+    al = quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    item = Actor.find(al.id)
+
+    assert_equal(Actor, item.class)
+    assert_predicate(item, :persisted?)
+    assert_equal(al.id, item.id)
+    assert_equal("Al Pacino", item.name)
+  end
+
+  def test_find_bad_id
+    quick_add_node(label: 'actor', properties: {name: "Al Pacino"})
+    item = Actor.find("-1")
+    assert_nil(item)
+  end
+
+  def test_create
+    assert_equal(0, Actor.count)
+
+    actor = Actor.create(name: "Harrison Ford")
+
+    assert_equal(1, Actor.count)
+    assert_predicate(actor, :persisted?)
+    assert_equal("Harrison Ford", actor.name)
+    assert_equal("actor", actor.label)
+
+    found = Actor.find(actor.id)
+    assert_equal("Harrison Ford", found.name)
+    assert_equal("actor", found.label)
+    assert_equal(Actor.name, found._type)
+  end
+
+  def test_create_with_missing_graph
+    assert_raises(Redgraph::MissingGraphError) do
+      MissingGraphActor.create(name: "Harrison Ford")
+    end
+  end
+end

data/test/node_model_labels_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelLabelsTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Actor
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  class Artist
+    include Redgraph::NodeModel
+    self.label = "_artist"
+  end
+
+  class Painter < Artist
+  end
+
+  class Pianist < Artist
+    self.label = "pianist"
+  end
+
+  # tests
+  #
+
+  def test_label
+    assert_equal("actor", Actor.label)
+  end
+
+  def test_custom_label
+    assert_equal("_artist", Artist.label)
+  end
+
+  def test_default_label_when_inherited
+    assert_equal("painter", Painter.label)
+  end
+
+  def test_custom_label_when_inherited
+    assert_equal("pianist", Pianist.label)
+  end
+end

data/test/node_model_persistence_test.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelPersistenceTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Film
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  # tests
+  #
+
+  def test_save_new
+    assert_equal(0, Film.count)
+
+    film = Film.new(name: "Star Wars")
+    film.save
+
+    assert_predicate(film, :persisted?)
+    assert_equal(1, Film.count)
+  end
+
+  def test_save_existing
+    film = Film.create(name: "Star Wars")
+    film.name = "Commando"
+    film.save
+
+    assert_equal(1, Film.count)
+    item = Film.find(film.id)
+    assert_equal("Commando", item.name)
+  end
+
+  def test_reload
+    film = Film.create(name: "Star Wars")
+    copy = Film.find(film.id)
+
+    assert_equal("Star Wars", copy.name)
+
+    film.name = "Commando"
+    film.save
+
+    assert_equal("Star Wars", copy.name)
+    assert_equal("Commando", copy.reload.name)
+  end
+
+  def test_destroy
+    film = Film.create(name: "Star Wars")
+    assert_equal(1, Film.count)
+    film.destroy
+    assert_predicate(film, :destroyed?)
+    assert_equal(0, Film.count)
+  end
+end

data/test/node_model_test.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class NodeModelTest < Minitest::Test
+  include TestHelpers
+
+  GRAPH = Redgraph::Graph.new("movies", url: $REDIS_URL)
+
+  def setup
+    @graph = GRAPH
+  end
+
+  def teardown
+    @graph.delete
+  end
+
+  # test classes
+  #
+
+  class Animal
+    include Redgraph::NodeModel
+    attribute :name
+    self.graph = "pippo"
+  end
+
+  class Dog < Animal
+  end
+
+  class Actor
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+  end
+
+  class Film
+    include Redgraph::NodeModel
+    self.graph = GRAPH
+    attribute :name
+    attribute :year
+  end
+
+  # tests
+  #
+
+  def test_graph_accessor
+    assert_equal("pippo", Animal.graph)
+    assert_equal("pippo", Animal.new.graph)
+  end
+
+  def test_class_inheritance
+    assert_equal("pippo", Dog.graph)
+    assert_equal("dog", Dog.label)
+    assert_equal([:id, :name], Dog.attribute_names)
+  end
+
+  def test_attribute_names
+    assert_equal([:id, :name, :year], Film.attribute_names)
+
+    film = Film.new(name: "Star Wars", year: 1977)
+    assert_equal("Star Wars", film.name)
+    assert_equal(1977, film.year)
+  end
+
+  def test_attributes
+    film = Film.new(name: "Star Wars", year: 1977)
+    assert_equal({id: nil, name: "Star Wars", year: 1977}, film.attributes)
+  end
+
+  def test_add_to_graph
+    assert_equal(0, Film.count)
+    film = Film.new(name: "Star Wars", year: 1977)
+    item = film.add_to_graph
+    assert_predicate(item, :persisted?)
+
+    assert_equal(1, Film.count)
+  end
+
+  def test_merge_into_graph
+    film = Film.new(name: "Star Wars", year: 1977)
+    item = film.add_to_graph(allow_duplicates: false)
+    assert_predicate(item, :persisted?)
+
+    assert_equal(1, Film.count)
+
+    film = Film.new(name: "Star Wars", year: 1977)
+    item = film.add_to_graph(allow_duplicates: false)
+    assert_predicate(item, :persisted?)
+
+    assert_equal(1, Film.count)
+  end
+
+  def test_add_relation
+    film = Film.new(name: "Star Wars", year: 1977).add_to_graph
+    actor = Actor.new(name: "Harrison Ford").add_to_graph
+    edge = actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"})
+
+    assert_predicate(edge, :persisted?)
+    assert_equal("ACTED_IN", edge.type)
+  end
+
+  def test_add_relation_with_duplicate_control
+    film = Film.new(name: "Star Wars", year: 1977).add_to_graph
+    actor = Actor.new(name: "Harrison Ford").add_to_graph
+
+    actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"}, allow_duplicates: true)
+    assert_equal(1, @graph.count_edges)
+
+    actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"}, allow_duplicates: true)
+    assert_equal(2, @graph.count_edges)
+
+    actor.add_relation(type: "ACTED_IN", node: film, properties: {role: "Han Solo"}, allow_duplicates: false)
+    assert_equal(2, @graph.count_edges)
+  end
+
+  def test_casting_query
+    Film.new(name: "Star Wars", year: 1977).add_to_graph
+    Actor.new(name: "Harrison Ford").add_to_graph
+
+    items = Film.query("MATCH (node) RETURN node ORDER BY node.name")
+    assert_equal(2, items.size)
+    assert_kind_of(Actor, items[0][0])
+    assert_kind_of(Film, items[1][0])
+  end
+
+  def test_casting_query_from_model
+    film = Film.create(name: "Star Wars", year: 1977)
+    Actor.create(name: "Harrison Ford")
+
+    items = film.query("MATCH (node) RETURN node ORDER BY node.name")
+    assert_equal(2, items.size)
+    assert_kind_of(Actor, items[0][0])
+    assert_kind_of(Film, items[1][0])
+  end
+
+end