redisgraph 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbcd7f55a9dd3006c0f4a050171da9987e753f75fd20a99a9e22a1a7094c370b
-  data.tar.gz: 3b0094755a897bb7d8c8ddaed7a97ac741efb59cbd36983d67caa5a743142b3b
+  metadata.gz: 732b9f9b3c2faa832739c1be5ef607e5f84621351244a604c9addd4b54957410
+  data.tar.gz: 37374c73ca02f5e59b29bba44b77405b460a743fca092fc6172cf67a46a3dc53
 SHA512:
-  metadata.gz: 22b67bea86caecf0c5dc9822a96395f452d3043dc79975b6c6c0e05d02cdb0e7523d65500f5c3ce4bacd56f7b81b25a556c50707db25c02e5bab007ead7dae34
-  data.tar.gz: 8152ef37023f1ecc2dc3bf4688c3a4e21b3a56bad16af9dcdfaaf11f2f671fe754cedcd81b9d68d9e62f01643535d5594dad52750f947d870676dfe51431e44f
+  metadata.gz: 1e79f75391e9c6160f60ec6dfa053804011e17441f64368badfb6974412c40b548f06e8c050d0364722681dc98bb093b41d1f664684c04548d9c5ca6f490e1e6
+  data.tar.gz: fb4e0d21066b7331f9f149e96b4bb02d1987ddce2d5ad4b02c710734f8b9bbae1a250dbd7aa2de07598fbfe79de3e004fff51b37ef42006f91eea71e5816f729

data/.circleci/config.yml

@@ -0,0 +1,54 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.4.1-node-browsers
+
+      - image: redislabs/redisgraph:edge
+        port: 6379:6379
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "Gemfile" }}
+            # fallback to using the latest cache if no exact match is found
+            - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile" }}
+
+      # run tests!
+      - run:
+          name: run tests
+          command: bundle exec rspec
+
+workflows:
+  version: 2
+  commit:
+    jobs:
+      - build
+  nightly:
+    triggers:
+      - schedule:
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - build

data/.gitignore

@@ -0,0 +1 @@
+coverage/*

data/Gemfile

@@ -4,4 +4,6 @@ gemspec
 
 gem 'redis', '~> 4'
 gem 'terminal-table', '~> 1', '>= 1.8'
+gem 'rspec'
+gem 'codecov', :require => false, :group => :test
 

data/README.md

@@ -1,6 +1,31 @@
+[![license](https://img.shields.io/github/license/RedisGraph/redisgraph-rb.svg)](https://github.com/RedisGraph/redisgraph-rb)
+[![CircleCI](https://circleci.com/gh/RedisGraph/redisgraph-rb/tree/master.svg?style=svg)](https://circleci.com/gh/RedisGraph/redisgraph-rb/tree/master)
+[![GitHub issues](https://img.shields.io/github/release/RedisGraph/redisgraph-rb.svg)](https://github.com/RedisGraph/redisgraph-rb/releases/latest)
+[![Codecov](https://codecov.io/gh/RedisGraph/redisgraph-rb/branch/master/graph/badge.svg)](https://codecov.io/gh/RedisGraph/redisgraph-rb)
+
+
 # redisgraph-rb
 
-`redisgraph-rb` is a Ruby gem client for the RedisGraph module. It relies on `redis-rb` for Redis connection management and provides support for graph QUERY, EXPLAIN, and DELETE commands.
+`redisgraph-rb` is a Ruby gem client for the [RedisGraph](https://github.com/RedisLabsModules/RedisGraph) module. It relies on `redis-rb` for Redis connection management and provides support for graph QUERY, EXPLAIN, and DELETE commands.
+
+## RedisGraph compatibility
+`redisgraph-rb` is currently compatible with RedisGraph versions >= 1.99 (module version: 19900)
+
+The result set structure introduced by RedisGraph 2.0 requires some modifications to this client. If you are interested in using this client with the latest RedisGraph, please inform us by commenting on [the corresponding issue](https://github.com/RedisGraph/redisgraph-rb/issues/1)!
+
+### Previous Version
+For RedisGraph versions >= 1.0 and < 2.0 (ie module version: 10202), instead use and refer to
+the redisgraph gem version ~> 1.0.0
+
+which corresponds to the following docker image
+`docker run -p 6379:6379 -it --rm redislabs/redisgraph:1.2.2`
+
+## Installation
+To install, run:
+
+`$ gem install redisgraph`
+
+Or include `redisgraph` as a dependency in your Gemfile.
 
 ## Usage
 ```
@@ -38,7 +63,13 @@ RedisGraph connects to an active Redis server, defaulting to `host: localhost, p
 These parameters are described fully in the documentation for https://github.com/redis/redis-rb
 
 ## Running tests
-A simple test suite is provided, and can be run with:
-`ruby test/test_suite.rb`
+To ensure prerequisites are installed, run the following:
+`bundle install`
+
 These tests expect a Redis server with the Graph module loaded to be available at localhost:6379
 
+The currently compatible version of the RedisGraph module may be run as follows:
+`docker run -p 6379:6379 -it --rm redislabs/redisgraph:2.0-edge`
+
+A simple test suite is provided, and can be run with:
+`rspec`

data/lib/redisgraph.rb

@@ -8,37 +8,73 @@ require_relative 'redisgraph/connection.rb'
 class RedisGraph
   attr_accessor :connection
   attr_accessor :graphname
+  attr_accessor :metadata
+
+  class Metadata
+    def initialize(opts = {})
+      @graphname = opts[:graphname]
+      @connection = opts[:connection]
+
+      # cache semantics around these labels, propertyKeys, and relationshipTypes
+      # defers first read and is invalidated when changed.
+      @labels_proc =  -> { call_procedure('db.labels') }
+      @property_keys_proc = -> { call_procedure('db.propertyKeys') }
+      @relationship_types_proc = -> { call_procedure('db.relationshipTypes') }
+    end
+
+    def invalidate
+      @labels = @property_key = @relationship_types
+    end
+
+    def labels
+      @labels ||= @labels_proc.call
+    end
+
+    def property_keys
+      @property_keys ||= @property_keys_proc.call
+    end
+
+    def relationship_types
+      @relationship_types ||= @relationship_types_proc.call
+    end
+
+    def call_procedure(procedure)
+      res = @connection.call("GRAPH.QUERY", @graphname, "CALL #{procedure}()")
+      res[1].flatten
+    rescue Redis::CommandError => e
+      raise CallError, e
+    end
+  end
 
   # The RedisGraph constructor instantiates a Redis connection
   # and validates that the graph module is loaded
   def initialize(graph, redis_options = {})
     @graphname = graph
     connect_to_server(redis_options)
+    @metadata = Metadata.new(graphname: @graphname,
+                             connection: @connection)
   end
 
   # Execute a command and return its parsed result
   def query(command)
-    begin
-    resp = @connection.call("GRAPH.QUERY", @graphname, command)
-    rescue Redis::CommandError => e
-      raise QueryError, e
-    end
-
-    QueryResult.new(resp)
+    resp = @connection.call("GRAPH.QUERY", @graphname, command, '--compact')
+    QueryResult.new(resp,
+                    metadata:   @metadata)
+  rescue Redis::CommandError => e
+    raise QueryError, e
   end
 
   # Return the execution plan for a given command
   def explain(command)
-    begin
-    resp = @connection.call("GRAPH.EXPLAIN", @graphname, command)
-    rescue Redis::CommandError => e
-      raise QueryError, e
-    end
+    @connection.call("GRAPH.EXPLAIN", @graphname, command)
+  rescue Redis::CommandError => e
+    raise ExplainError, e
   end
 
   # Delete the graph and all associated keys
   def delete
-    resp = @connection.call("GRAPH.DELETE", @graphname)
+    @connection.call("GRAPH.DELETE", @graphname)
+  rescue Redis::CommandError => e
+    raise DeleteError, e
   end
 end
-

data/lib/redisgraph/connection.rb

@@ -1,16 +1,19 @@
 class RedisGraph
   def connect_to_server(options)
     @connection = Redis.new(options)
-    self.verify_module()
+    @module_version = module_version()
+    raise ServerError, "RedisGraph module not loaded." if @module_version.nil?
+    raise ServerError, "RedisGraph module incompatible, expecting >= 1.99." if @module_version < 19900
   end
 
   # Ensure that the connected Redis server supports modules
   # and has loaded the RedisGraph module
-  def verify_module()
+  def module_version()
     redis_version = @connection.info["redis_version"]
     major_version = redis_version.split('.').first.to_i
     raise ServerError, "Redis 4.0 or greater required for RedisGraph support." unless major_version >= 4
-    resp = @connection.call("MODULE", "LIST")
-    raise ServerError, "RedisGraph module not loaded." unless resp.first && resp.first.include?("graph")
+    modules = @connection.call("MODULE", "LIST")
+    module_graph = modules.detect { |_name_key, name, _ver_key, _ver| name == 'graph' }
+    module_graph[3] if module_graph
   end
 end

data/lib/redisgraph/errors.rb

@@ -1,10 +1,10 @@
 class RedisGraph
-  class RedisGraphError < RuntimeError
-  end
+  class RedisGraphError < RuntimeError; end
 
-  class ServerError < RedisGraphError
-  end
+  class ServerError < RedisGraphError; end
 
-  class QueryError < RedisGraphError
-  end
+  class CallError < RedisGraphError; end
+  class QueryError < RedisGraphError; end
+  class ExplainError < RedisGraphError; end
+  class DeleteError < RedisGraphError; end
 end

data/lib/redisgraph/query_result.rb

@@ -3,6 +3,23 @@ class QueryResult
   attr_accessor :resultset
   attr_accessor :stats
 
+  def initialize(response, opts = {})
+    # The response for any query is expected to be a nested array.
+    # If compact (RedisGraph protocol v2)
+    # The resultset is an array w/ three elements:
+    # 0] Node/Edge key names w/ the ordinal position used in [1]
+    #    en lieu of the name to compact the result set.
+    # 1] Node/Edge key/value pairs as an array w/ two elements:
+    #  0] node/edge name id from [0]
+    #  1..matches] node/edge values
+    # 2] Statistics as an array of strings
+
+    @metadata = opts[:metadata]
+
+    @resultset = parse_resultset(response)
+    @stats = parse_stats(response)
+  end
+
   def print_resultset
     pretty = Terminal::Table.new headings: columns do |t|
       resultset.each { |record| t << record }
@@ -11,49 +28,111 @@ class QueryResult
   end
 
   def parse_resultset(response)
+    # In the v2 protocol, CREATE does not contain an empty row preceding statistics
+    return unless response.length > 1
+
     # Any non-empty result set will have multiple rows (arrays)
-    return nil unless response[0].length > 1
-    # First row is return elements / properties
-    @columns = response[0].shift
-    # Subsequent rows are records
-    @resultset = response[0]
+
+
+    # First row is header describing the returned records, corresponding
+    # precisely in order and naming to the RETURN clause of the query.
+    header = response[0]
+    @columns = header.map { |(_type, name)| name }
+
+    # Second row is the actual data returned by the query
+    # note handling for encountering an id for propertyKey that is out of
+    # the cached set.
+    data = response[1].map do |row|
+      i = -1
+      header.reduce([]) do |agg, (type, _it)|
+        i += 1
+        el = row[i]
+
+        case type
+        when 1 # scalar
+          agg << map_scalar(el[0], el[1])
+        when 2 # node
+          props = el[2]
+          agg << props.sort_by { |prop| prop[0] }.map { |prop| map_prop(prop) }
+        when 3 # relation
+          props = el[4]
+          agg << props.sort_by { |prop| prop[0] }.map { |prop| map_prop(prop) }
+        end
+
+        agg
+      end
+    end
+
+    data
+  end
+
+  def map_scalar(type, val)
+    map_func = case type
+               when 1 # null
+                 return nil
+               when 2 # string
+                 :to_s
+               when 3 # integer
+                 :to_i
+               when 4 # boolean
+                 # no :to_b
+                 return val == "true"
+               when 5 # double
+                 :to_f
+               # TODO: when in the distro packages and docker images,
+               #   the following _should_ work
+               # when 6 # array
+               #   val.map { |it| map_scalar(it[0], it[1]) }
+               end
+    val.send(map_func)
+  end
+
+  def map_prop(prop)
+    # maximally a single @metadata.invalidate should occur
+
+    property_keys = @metadata.property_keys
+    prop_index = prop[0]
+    if prop_index > property_keys.length
+      @metadata.invalidate
+      property_keys = @metadata.property_keys
+    end
+    { property_keys[prop_index] => map_scalar(prop[1], prop[2]) }
   end
 
   # Read metrics about internal query handling
   def parse_stats(response)
-    return nil unless response[1]
+    # In the v2 protocol, CREATE does not contain an empty row preceding statistics
+    stats_offset = response.length == 1 ? 0 : 2
 
+    return nil unless response[stats_offset]
+
+    parse_stats_row(response[stats_offset])
+  end
+
+  def parse_stats_row(response_row)
     stats = {}
 
-    response[1].each do |stat|
+    response_row.each do |stat|
       line = stat.split(': ')
-      val = line[1].split(' ')[0]
+      val = line[1].split(' ')[0].to_i
 
       case line[0]
       when /^Labels added/
-        stats[:labels_added] = val.to_i
+        stats[:labels_added] = val
       when /^Nodes created/
-        stats[:nodes_created] = val.to_i
+        stats[:nodes_created] = val
       when /^Nodes deleted/
-        stats[:nodes_deleted] = val.to_i
+        stats[:nodes_deleted] = val
       when /^Relationships deleted/
-        stats[:relationships_deleted] = val.to_i
+        stats[:relationships_deleted] = val
       when /^Properties set/
-        stats[:properties_set] = val.to_i
+        stats[:properties_set] = val
       when /^Relationships created/
-        stats[:relationships_created] = val.to_i
+        stats[:relationships_created] = val
       when /^Query internal execution time/
-        stats[:internal_execution_time] = val.to_f
+        stats[:internal_execution_time] = val
       end
     end
     stats
   end
-
-  def initialize(response)
-    # The response for any query is expected to be a nested array.
-    # The only top-level values will be the result set and the statistics.
-    @resultset = parse_resultset(response)
-    @stats = parse_stats(response)
-  end
 end
-

data/lib/redisgraph/version.rb

@@ -1,3 +1,3 @@
 class RedisGraph
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/spec/helper.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'codecov'
+SimpleCov.formatter = SimpleCov::Formatter::Codecov

data/spec/redisgraph_quickstart_spec.rb

@@ -0,0 +1,73 @@
+require 'helper.rb'
+
+require_relative '../lib/redisgraph.rb'
+
+# based on queries extracted from
+describe RedisGraph do
+  before(:all) do
+    begin
+      @r = RedisGraph.new("#{described_class}_test")
+      create_graph
+    rescue Redis::BaseError => e
+      $stderr.puts(e)
+      exit 1
+    end
+  end
+
+  after(:all) do
+    @r.delete if @r
+  end
+
+  def create_graph()
+    q = "CREATE (:Rider {name:'Valentino Rossi'})-[:rides]->(:Team {name:'Yamaha'})," \
+      "(:Rider {name:'Dani Pedrosa'})-[:rides]->(:Team {name:'Honda'})," \
+      "(:Rider {name:'Andrea Dovizioso'})-[:rides]->(:Team {name:'Ducati'})"
+
+    res = @r.query(q)
+
+    expect(res.resultset).to be_nil
+    stats = res.stats
+    expect(stats).to include(:internal_execution_time)
+    stats.delete(:internal_execution_time)
+    expect(stats).to eq({
+      labels_added:          2,
+      nodes_created:         6,
+      properties_set:        6,
+      relationships_created: 3
+    })
+  end
+
+  context 'quickstart' do
+    it 'should query relations, with a predicate' do
+      q = "MATCH (r:Rider)-[:rides]->(t:Team) WHERE t.name = 'Yamaha' RETURN r.name, t.name"
+
+      res = @r.query(q)
+
+      expect(res.columns).to eq(["r.name", "t.name"])
+      expect(res.resultset).to eq([["Valentino Rossi", "Yamaha"]])
+    end
+
+    # not in the quickstart, but demonstrates multiple rows
+    it 'should query relations, without a predicate' do
+      q = "MATCH (r:Rider)-[:rides]->(t:Team) RETURN r.name, t.name ORDER BY r.name"
+
+      res = @r.query(q)
+
+      expect(res.columns).to eq(["r.name", "t.name"])
+      expect(res.resultset).to eq([
+        ["Andrea Dovizioso", "Ducati"],
+        ["Dani Pedrosa", "Honda"],
+        ["Valentino Rossi", "Yamaha"]
+      ])
+    end
+
+    it 'should query relations, with an aggregate function' do
+      q = "MATCH (r:Rider)-[:rides]->(t:Team {name:'Ducati'}) RETURN count(r)"
+
+      res = @r.query(q)
+
+      expect(res.columns).to eq(["count(r)"])
+      expect(res.resultset).to eq([[1]])
+    end
+  end
+end

data/spec/redisgraph_spec.rb

@@ -0,0 +1,79 @@
+require 'helper.rb'
+
+require_relative '../lib/redisgraph.rb'
+
+describe RedisGraph do
+  # TODO it would be nice to have something like DisposableRedis
+  # Connect to a Redis server on localhost:6379
+  before(:all) do
+    begin
+      @r = RedisGraph.new("#{described_class}_test")
+      create_graph
+    rescue Redis::BaseError => e
+      $stderr.puts(e)
+    end
+  end
+
+  # Ensure that the graph "rubytest" does not exist
+  after(:all) do
+    @r.delete if @r
+  end
+
+  def create_graph()
+    q = """CREATE (t:node {name: 'src'})"""
+
+    res = @r.query(q)
+    expect(res.resultset).to be_nil
+
+    plan = @r.explain(q)
+    expect(plan).to include("Create")
+
+    expect(res.stats[:labels_added]).to eq(1)
+    expect(res.stats[:nodes_created]).to eq(1)
+    expect(res.stats[:properties_set]).to eq(1)
+  end
+
+  # Test functions - each validates one or more EXPLAIN and QUERY calls
+
+  context "bare return" do
+    it "should map values properly" do
+      q = """UNWIND [1, 1.5, null, 'strval', true, false] AS a RETURN a"""
+      res = @r.query(q)
+      expect(res.resultset).to eq([[1], [1.5], [nil], ["strval"], [true], [false]])
+    end
+  end
+
+  context "nodes" do
+    it "should delete nodes properly" do
+      q = """MATCH (t:node) WHERE t.name = 'src' DELETE t"""
+      plan = @r.explain(q)
+      expect(plan).to include("Delete")
+      res = @r.query(q)
+      expect(res.resultset).to be_nil
+      expect(res.stats[:nodes_deleted]).to eq(1)
+    end
+  end
+
+  context "edges" do
+    it "should create edges properly" do
+      q = "CREATE (p:node {name: 'src1', color: 'cyan'})-[:edge { weight: 7.8 }]->(:node {name: 'dest1', color: 'magenta'})," \
+        " (:node {name: 'src2'})-[:edge { weight: 12 }]->(q:node_type_2 {name: 'dest2'})"
+      plan = @r.explain(q)
+      expect(plan).to include("Create")
+      res = @r.query(q)
+      expect(res.resultset).to be_nil
+      expect(res.stats[:nodes_created]).to eq(4)
+      expect(res.stats[:properties_set]).to eq(8)
+      expect(res.stats[:relationships_created]).to eq(2)
+    end
+
+    it "should traverse edges properly" do
+      q = """MATCH (a)-[e:edge]->(b:node) RETURN a.name, b, e"""
+      plan = @r.explain(q)
+      expect(plan.detect { |row| row.include?("Traverse") }).to_not be_nil
+      res = @r.query(q)
+      expect(res.columns).to eq(["a.name", "b", "e"])
+      expect(res.resultset).to eq([["src1", [{"name"=>"dest1"}, {"color"=>"magenta"}], [{"weight"=>7.8}]]])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redisgraph
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Redis Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-13 00:00:00.000000000 Z
+date: 2019-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -51,6 +51,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
@@ -60,7 +62,9 @@ files:
 - lib/redisgraph/query_result.rb
 - lib/redisgraph/version.rb
 - redisgraph.gemspec
-- test/test_suite.rb
+- spec/helper.rb
+- spec/redisgraph_quickstart_spec.rb
+- spec/redisgraph_spec.rb
 homepage: https://github.com/redislabs/redisgraph-rb
 licenses:
 - BSD-3-Clause

data/test/test_suite.rb

@@ -1,89 +0,0 @@
-require_relative '../lib/redisgraph.rb'
-require "test/unit"
-include Test::Unit::Assertions
-
-# Helper functions
-# TODO it would be nice to have something like DisposableRedis
-
-# Connect to a Redis server on localhost:6379
-def connect_test
-  begin
-  @r = RedisGraph.new("rubytest")
-  rescue Redis::BaseError => e
-    puts e
-    puts "RedisGraph tests require that a Redis server with the graph module loaded be running on localhost:6379"
-    exit 1
-  end
-end
-
-# Ensure that the graph "rubytest" does not exist
-def delete_graph
-  @r.delete
-end
-
-# Test functions - each validates one or more EXPLAIN and QUERY calls
-
-def validate_node_creation
-  query_str = """CREATE (t:node {name: 'src'})"""
-  x = @r.query(query_str)
-  plan = @r.explain(query_str)
-  assert(plan =~ /Create/)
-  assert(x.resultset.nil?)
-  assert(x.stats[:labels_added] == 1)
-  assert(x.stats[:nodes_created] == 1)
-  assert(x.stats[:properties_set] == 1)
-  puts "Create node - PASSED"
-end
-
-def validate_node_deletion
-  query_str = """MATCH (t:node) WHERE t.name = 'src' DELETE t"""
-  plan = @r.explain(query_str)
-  assert(plan =~ /Delete/)
-  x = @r.query(query_str)
-  assert(x.resultset.nil?)
-  assert(x.stats[:nodes_deleted] == 1)
-  query_str = """MATCH (t:node) WHERE t.name = 'src' RETURN t"""
-  assert(x.resultset.nil?)
-  puts "Delete node - PASSED"
-end
-
-def validate_edge_creation
-  query_str = """CREATE (p:node {name: 'src1'})-[:edge]->(:node {name: 'dest1'}), (:node {name: 'src2'})-[:edge]->(q:node_type_2 {name: 'dest2'})"""
-  plan = @r.explain(query_str)
-  assert(plan =~ /Create/)
-  x = @r.query(query_str)
-  assert(x.resultset.nil?)
-  assert(x.stats[:nodes_created] == 4)
-  assert(x.stats[:properties_set] == 4)
-  assert(x.stats[:relationships_created] == 2)
-  puts "Add edges - PASSED"
-end
-
-def validate_edge_traversal
-  query_str = """MATCH (a)-[:edge]->(b:node) RETURN a, b"""
-  plan = @r.explain(query_str)
-  assert(plan.include?("Traverse"))
-  x = @r.query(query_str)
-  assert(x.resultset)
-  assert(x.columns.length == 2)
-  assert(x.resultset.length == 1)
-  assert(x.resultset[0] == ["src1", "dest1"])
-  puts "Traverse edge - PASSED"
-end
-
-def test_suite
-  puts "Running RedisGraph tests..."
-  connect_test
-  delete_graph # Clear the graph
-
-  # Test basic functionalities
-  validate_node_creation
-  validate_node_deletion
-  validate_edge_creation
-  validate_edge_traversal
-
-  delete_graph # Clear the graph again
-  puts "RedisGraph tests passed!"
-end
-
-test_suite