ruby-ladybug 0.1.0

data/spec/ladybug/connection_spec.rb

@@ -0,0 +1,36 @@
+# -*- ruby -*-
+
+require_relative '../spec_helper'
+
+require 'ladybug/connection'
+
+
+RSpec.describe( Ladybug::Connection ) do
+
+	let( :db ) { Ladybug.database }
+
+
+	it "can set the maximum number of threads for execution" do
+		connection = db.connect
+
+		expect {
+			connection.max_num_threads_for_exec += 1
+		}.to change { connection.max_num_threads_for_exec }.by( 1 )
+	end
+
+
+	it "shows the number of threads used for execution when inspected" do
+		connection = db.connect
+
+		expect( connection.inspect ).to match( /threads:\d+/i )
+	end
+
+
+	it "knows what database it's a connection for" do
+		connection = db.connect
+
+		expect( connection.database ).to eq( db )
+	end
+
+end
+

data/spec/ladybug/database_spec.rb

@@ -0,0 +1,57 @@
+# -*- ruby -*-
+
+require_relative '../spec_helper'
+
+require 'ladybug/database'
+
+
+RSpec.describe( Ladybug::Database ) do
+
+	let( :spec_tmpdir ) do
+		path = tmpfile_pathname()
+		path.mkpath
+		return path
+	end
+
+	let( :db_path ) { spec_tmpdir + 'spec_db' }
+
+
+	after( :each ) do
+		GC.start
+	end
+
+	it "can be created in-memory" do
+		instance = described_class.new( '' )
+		expect( instance ).to be_a( described_class )
+	end
+
+
+	it "can be created read-only from an existing on-disk database" do
+		_original = described_class.new( db_path.to_s )
+
+		ro = described_class.new( db_path.to_s, read_only: true )
+		expect( ro ).to be_read_only
+	end
+
+
+	it "can be created without auto-checkpointing" do
+		instance = described_class.new( db_path.to_s, auto_checkpoint: false )
+		expect( instance ).not_to be_auto_checkpointing
+	end
+
+
+	it "can be created without compression" do
+		instance = described_class.new( db_path.to_s, enable_compression: false )
+		expect( instance ).not_to be_compression_enabled
+	end
+
+
+	it "can create a connection to itself" do
+		instance = described_class.new( db_path.to_s, enable_compression: false )
+
+		result = instance.connect
+
+		expect( result ).to be_a( Ladybug::Connection )
+	end
+
+end

data/spec/ladybug/prepared_statement_spec.rb

@@ -0,0 +1,91 @@
+# -*- ruby -*-
+
+require_relative '../spec_helper'
+
+require 'ladybug/prepared_statement'
+
+
+RSpec.describe( Ladybug::PreparedStatement ) do
+
+	let( :db ) { Ladybug.database }
+	let( :connection ) { db.connect }
+
+	let( :schema ) { load_test_data( 'demo-db/schema.cypher' ) }
+	let( :copy_statements ) { load_test_data( 'demo-db/copy.cypher' ) }
+
+
+	def setup_demo_db
+		connection.run( schema )
+		connection.run( copy_statements )
+	end
+
+
+	before( :each ) do
+		setup_demo_db()
+	end
+
+
+	#
+	# Specs
+	#
+
+	it "can be created via a connection and a query string" do
+		statement = described_class.new( connection, <<~END_OF_QUERY )
+			MATCH (u:User)
+		    WHERE u.age > $min_age and u.age < $max_age
+		    RETURN u.name
+		END_OF_QUERY
+
+		expect( statement ).to be_a( described_class )
+		expect( statement ).to be_success
+		expect( statement.connection ).to be( connection )
+	end
+
+
+	it "errors if executed before its variables are bound" do
+		statement = described_class.new( connection, <<~END_OF_QUERY )
+			MATCH (u:User)
+		    WHERE u.age > $min_age and u.age < $max_age
+		    RETURN u.name
+		END_OF_QUERY
+
+		expect {
+			statement.execute
+		}.to raise_error( Ladybug::QueryError, /parameter \w+ not found/i )
+	end
+
+
+	it "can be executed if all of its variables are bound" do
+		statement = described_class.new( connection, <<~END_OF_QUERY )
+		MATCH (u:User)
+		WHERE u.age >= $min_age and u.age <= $max_age
+		RETURN u.name
+		END_OF_QUERY
+
+		result = statement.execute( min_age: 40, max_age: 50 )
+
+		expect( result.num_tuples ).to eq( 2 )
+
+		result.finish
+	end
+
+
+	it "can be reused" do
+		statement = described_class.new( connection, <<~END_OF_QUERY )
+		MATCH (u:User)
+		WHERE u.age >= $min_age and u.age <= $max_age
+		RETURN u.name
+		END_OF_QUERY
+
+		result = statement.execute( min_age: 40, max_age: 50 )
+		expect( result ).to be_success
+		expect( result.num_tuples ).to eq( 2 )
+		result.finish
+
+		result = statement.execute( min_age: 5, max_age: 90 )
+		expect( result ).to be_success
+		expect( result.num_tuples ).to eq( 4 )
+		result.finish
+	end
+
+end

data/spec/ladybug/query_summary_spec.rb

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+require_relative '../spec_helper'
+
+require 'ladybug/query_summary'
+
+
+RSpec.describe( Ladybug::QuerySummary ) do
+
+	CREATE_TABLE_STATEMENTS = [
+		'CREATE NODE TABLE User(name STRING, age INT64, PRIMARY KEY (name))',
+		'CREATE NODE TABLE City(name STRING, population INT64, PRIMARY KEY (name))',
+	]
+
+
+	let( :db ) { Ladybug.database }
+	let( :connection ) { db.connect }
+
+
+	it "can return a summary of its query's timing" do
+		connection.query( CREATE_TABLE_STATEMENTS.first ) do |result|
+			summary = result.query_summary
+
+			expect( summary ).to be_a( described_class )
+			expect( summary.compiling_time ).to be_a( Float ).and( be > 0.0 )
+			expect( summary.execution_time ).to be_a( Float ).and( be > 0.0 )
+		end
+	end
+
+end

data/spec/ladybug/result_spec.rb

@@ -0,0 +1,225 @@
+# -*- ruby -*-
+
+require_relative '../spec_helper'
+
+require 'ladybug/result'
+
+
+RSpec.describe( Ladybug::Result ) do
+
+	let( :db ) { Ladybug.database }
+	let( :connection ) { db.connect }
+
+	let( :schema ) { load_test_data( 'demo-db/schema.cypher' ) }
+	let( :copy_statements ) { load_test_data( 'demo-db/copy.cypher' ) }
+
+
+	def setup_demo_db
+		connection.run( schema )
+		connection.run( copy_statements )
+	end
+
+
+	#
+	# Specs
+	#
+
+	describe "query constructor" do
+
+		it "can be created via a simple query" do
+			result = described_class.from_query( connection, schema.each_line.first )
+
+			expect( result ).to be_a( described_class )
+			expect( result ).to be_success
+
+			result.finish
+		end
+
+
+		it "automatically finishes the result when run with a block" do
+			block_result = nil
+
+			described_class.from_query( connection, schema.each_line.first ) do |result|
+				block_result = result
+				expect( result ).to be_a( described_class )
+				expect( result ).to be_success
+			end
+
+			expect( block_result ).to be_finished
+		end
+
+
+		it "can return a summary of its query's timing" do
+			result = described_class.from_query( connection, schema.each_line.first )
+			summary = result.query_summary
+
+			expect( summary ).to be_a( Ladybug::QuerySummary )
+
+			result.finish
+		end
+
+
+		it "can return the error message if there was a problem with the query" do
+			expect {
+				described_class.from_query( connection, "FOOBANGLE NERFRIDER" )
+			}.to raise_error( Ladybug::QueryError, /parser exception/i )
+		end
+
+
+		it "can iterate over result tuples" do
+			setup_demo_db()
+
+			result = described_class.from_query( connection, <<~END_OF_QUERY )
+				MATCH ( a:User )-[ f:Follows ]->( b:User )
+			    RETURN a.name, b.name, f.since;
+			END_OF_QUERY
+
+			expect( result ).to be_a( described_class )
+			expect( result ).to be_success
+			expect( result.num_columns ).to eq( 3 )
+			expect( result.column_names ).to eq([ "a.name", "b.name", "f.since" ])
+			expect( result.to_a ).to eq([
+				{ "a.name" => "Adam", "b.name" => "Karissa", "f.since" => 2020 },
+				{ "a.name" => "Adam", "b.name" => "Zhang", "f.since" => 2020 },
+				{ "a.name" => "Karissa", "b.name" => "Zhang", "f.since" => 2021 },
+				{ "a.name" => "Zhang", "b.name" => "Noura", "f.since" => 2022 }
+			])
+
+			result.finish
+		end
+
+
+		it "handles a #next after it finishes iteration over the current set" do
+			setup_demo_db()
+
+			result = described_class.from_query( connection, <<~END_OF_QUERY )
+				MATCH ( a:User )-[ f:Follows ]->( b:User )
+			    RETURN a.name, b.name, f.since;
+			END_OF_QUERY
+
+			result.tuples # Iterate over all tuples
+
+			expect( result.next ).to be_nil
+
+			result.finish
+		end
+
+
+		it "can fetch individual result tuples via the index operator" do
+			setup_demo_db()
+
+			result = described_class.from_query( connection, <<~END_OF_QUERY )
+				MATCH ( a:User )-[ f:Follows ]->( b:User )
+			    RETURN a.name, b.name, f.since;
+			END_OF_QUERY
+
+			tuples = result.to_a
+
+			expect( result[0] ).to eq( tuples[0] )
+			expect( result[1] ).to eq( tuples[1] )
+			expect( result[2] ).to eq( tuples[2] )
+			expect( result[3] ).to eq( tuples[3] )
+
+			result.finish
+		end
+
+
+		it "can iterate over result sets" do
+			result = described_class.from_query( connection, <<~END_QUERY )
+				return 1;
+				return 2;
+				return 3;
+			END_QUERY
+
+			rval = result.each_set.flat_map do |subset|
+				subset.to_a
+			end
+
+			expect( rval ).to eq([
+				{ "1" => 1 },
+				{ "2" => 2 },
+				{ "3" => 3 },
+			])
+
+			result.finish
+		end
+
+
+		it "also finishes successive results if they've been fetched when the first one is finished" do
+			result = described_class.from_query( connection, <<~END_QUERY )
+				return 1;
+				return 2;
+				return 3;
+			END_QUERY
+
+			second_result = result.next_set
+
+			result.finish
+
+			expect( second_result ).to be_finished
+		end
+
+
+		it "errors if it's used after being finished" do
+			result = described_class.from_query( connection, "return 1;" )
+			result.finish
+
+			expect( result ).to be_finished
+
+			expect {
+				result.get_next_values
+			}.to raise_error( Ladybug::FinishedError )
+		end
+
+	end
+
+
+	describe "prepared statement constructor" do
+
+		before( :each ) do
+			setup_demo_db()
+		end
+
+
+		it "can be created via a prepared statement" do
+			statement = Ladybug::PreparedStatement.new( connection, <<~END_OF_QUERY )
+				MATCH (u:User)
+			    WHERE u.age > $min_age and u.age < $max_age
+			    RETURN u.name
+			END_OF_QUERY
+			statement.bind( min_age: 32, max_age: 46 )
+
+			result = described_class.from_prepared_statement( statement )
+
+			expect( result ).to be_a( described_class )
+			expect( result ).to be_success
+
+			result.finish
+		end
+
+
+		it "is automatically finished if constructed with a block" do
+			statement = Ladybug::PreparedStatement.new( connection, <<~END_OF_QUERY )
+				MATCH (u:User)
+			    WHERE u.age > $min_age and u.age < $max_age
+			    RETURN u.name
+			END_OF_QUERY
+			statement.bind( min_age: 32, max_age: 46 )
+
+			block_result = nil
+			rval = described_class.from_prepared_statement( statement ) do |result|
+				block_result = result
+				expect( result ).to be_a( described_class )
+				expect( result ).to be_success
+
+				result.first['u.name']
+			end
+
+			expect( block_result ).to be_finished
+			expect( rval ).to eq( "Karissa" )
+		end
+
+	end
+
+
+end