sequelizer 0.1.4 → 0.2.0

data/test/lib/sequel/extensions/test_settable.rb

@@ -0,0 +1,109 @@
+require_relative '../../../test_helper'
+require 'sequel'
+require 'sequel/extensions/settable'
+
+class TestSettable < Minitest::Test
+
+  def test_should_register_extension
+    db = Sequel.mock(host: :sqlite)
+
+    assert_respond_to db, :extension
+    db.extension :settable
+
+    assert_respond_to db, :set
+  end
+
+  def test_set_with_single_option
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(search_path: 'public')
+
+    assert_equal(['SET search_path=public'], db.sqls)
+  end
+
+  def test_set_with_multiple_options
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(search_path: 'public', timezone: 'UTC')
+
+    expected_sqls = ['SET search_path=public', 'SET timezone=UTC']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_empty_hash
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set({})
+
+    assert_empty(db.sqls)
+  end
+
+  def test_set_with_no_arguments
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set
+
+    assert_empty(db.sqls)
+  end
+
+  def test_set_with_string_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(work_mem: '256MB', statement_timeout: '30s')
+
+    expected_sqls = ['SET work_mem=256MB', 'SET statement_timeout=30s']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_numeric_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(port: 5432, max_connections: 100)
+
+    expected_sqls = ['SET port=5432', 'SET max_connections=100']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_boolean_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(autocommit: true, log_statement: false)
+
+    expected_sqls = ['SET autocommit=true', 'SET log_statement=false']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_with_nil_values
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+    db.set(timezone: nil, search_path: nil)
+
+    expected_sqls = ['SET timezone=', 'SET search_path=']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+  def test_set_sql_private_method
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+
+    refute_respond_to db, :set_sql
+  end
+
+  def test_multiple_set_calls
+    db = Sequel.mock(host: :sqlite)
+    db.extension :settable
+
+    db.set(timezone: 'UTC')
+    db.set(search_path: 'public')
+
+    expected_sqls = ['SET timezone=UTC', 'SET search_path=public']
+
+    assert_equal expected_sqls, db.sqls
+  end
+
+end

data/test/lib/sequel/extensions/test_sql_recorder.rb

@@ -0,0 +1,231 @@
+require_relative '../../../test_helper'
+require 'sequel'
+require 'sequel/extensions/sql_recorder'
+
+class TestSqlRecorder < Minitest::Test
+
+  def setup
+    # Use mock database for these tests since we're not conflicting anymore
+    @db = Sequel.mock
+    @db.extension :sql_recorder
+  end
+
+  def test_extension_registration
+    assert_respond_to @db, :sql_recorder
+  end
+
+  def test_sql_recorder_initialized_as_empty_array
+    assert_instance_of Array, @db.sql_recorder
+    assert_empty @db.sql_recorder
+  end
+
+  def test_records_select_statements
+    @db[:users].all
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('SELECT * FROM users') || sql.include?('SELECT * FROM `users`')
+    end, 'Should record the SELECT statement')
+  end
+
+  def test_records_insert_statements
+    @db[:users].insert(name: 'John', email: 'john@example.com', age: 30)
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('INSERT INTO users') || sql.include?('INSERT INTO `users`')
+    end, 'Should record INSERT statement')
+    assert(@db.sql_recorder.any? { |sql| sql.include?('John') }, 'Should include the data')
+  end
+
+  def test_records_update_statements
+    @db[:users].where(id: 1).update(name: 'Jane')
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('UPDATE users SET') || sql.include?('UPDATE `users` SET')
+    end, 'Should record UPDATE statement')
+    assert(@db.sql_recorder.any? { |sql| sql.include?('Jane') }, 'Should include the updated data')
+  end
+
+  def test_records_delete_statements
+    @db[:users].where(id: 1).delete
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('DELETE FROM users') || sql.include?('DELETE FROM `users`')
+    end, 'Should record DELETE statement')
+  end
+
+  def test_records_multiple_sql_statements
+    initial_count = @db.sql_recorder.length
+
+    @db[:users].all
+    @db[:posts].where(id: 1).first
+    @db[:comments].count
+
+    assert_operator(@db.sql_recorder.length, :>=, initial_count + 3, 'Should record at least 3 more SQL statements')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('SELECT * FROM users') || sql.include?('SELECT * FROM `users`')
+    end, 'Should record users query')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('SELECT * FROM posts WHERE (id = 1)')
+    end, 'Should record posts query')
+    assert(@db.sql_recorder.any? do |sql|
+      sql.include?('SELECT count(*) AS count FROM comments')
+    end, 'Should record count query')
+  end
+
+  def test_sql_recorder_accumulates_across_multiple_operations
+    initial_count = @db.sql_recorder.length
+
+    @db[:users].all
+    count_after_first = @db.sql_recorder.length
+
+    assert_operator(count_after_first, :>, initial_count, 'Should record first query')
+
+    @db[:posts].first
+    count_after_second = @db.sql_recorder.length
+
+    assert_operator(count_after_second, :>, count_after_first, 'Should record second query')
+
+    @db[:comments].insert(text: 'Hello')
+    count_after_third = @db.sql_recorder.length
+
+    assert_operator(count_after_third, :>, count_after_second, 'Should record third query')
+  end
+
+  def test_sql_recorder_persists_until_manually_cleared
+    @db[:users].all
+    @db[:posts].all
+
+    assert_operator(@db.sql_recorder.length, :>=, 2, 'Should record multiple statements')
+
+    # Manually clear (this is how consumers would reset the log)
+    @db.sql_recorder.clear
+
+    assert_empty @db.sql_recorder
+
+    @db[:comments].all
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record new statements after clear')
+  end
+
+  def test_handles_complex_queries_with_joins
+    @db[:users].join(:posts, user_id: :id).where(Sequel[:users][:active] => true).all
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
+    recorded_sql = @db.sql_recorder.join(' ')
+
+    assert_includes(recorded_sql, 'SELECT', 'Should contain SELECT')
+    assert(recorded_sql.include?('FROM users') || recorded_sql.include?('FROM `users`'), 'Should contain FROM users')
+    assert_includes(recorded_sql, 'JOIN', 'Should contain JOIN')
+  end
+
+  def test_handles_queries_with_parameters
+    @db[:users].where(name: 'John', age: 25).all
+
+    assert_operator(@db.sql_recorder.length, :>=, 1, 'Should record at least one SQL statement')
+    recorded_sql = @db.sql_recorder.join(' ')
+
+    assert_includes(recorded_sql, 'John', 'Should include name parameter')
+    assert_includes(recorded_sql, '25', 'Should include age parameter')
+  end
+
+  def test_thread_safety_with_concurrent_queries
+    threads = []
+
+    10.times do |i|
+      threads << Thread.new do
+        @db[:table].where(id: i).first
+      end
+    end
+
+    threads.each(&:join)
+
+    # Should have recorded all 10 queries
+    assert_operator(@db.sql_recorder.length, :>=, 10, 'Should record at least 10 queries')
+    (0..9).each do |i|
+      assert(@db.sql_recorder.any? { |sql| sql.include?("WHERE (id = #{i})") }, "Should record query for id #{i}")
+    end
+  end
+
+  def test_module_extension_method_initializes_properly
+    # Test the self.extended method directly
+    fresh_db = Sequel.mock
+    fresh_db.extend(Sequel::SqlRecorder)
+    Sequel::SqlRecorder.extended(fresh_db)
+
+    assert_respond_to fresh_db, :sql_recorder
+    assert_instance_of Array, fresh_db.sql_recorder
+    assert_instance_of Mutex, fresh_db.instance_variable_get(:@sql_recorder_mutex)
+  end
+
+  def test_sql_recorder_mutex_is_initialized
+    assert_instance_of Mutex, @db.instance_variable_get(:@sql_recorder_mutex)
+  end
+
+  def test_extension_can_be_added_to_existing_database
+    plain_db = Sequel.mock
+
+    refute_respond_to plain_db, :sql_recorder
+
+    plain_db.extension :sql_recorder
+
+    assert_respond_to plain_db, :sql_recorder
+    assert_instance_of Array, plain_db.sql_recorder
+  end
+
+  def test_sql_recorder_does_not_conflict_with_mock_sqls
+    # Test that our sql_recorder doesn't interfere with mock's sqls
+    mock_db = Sequel.mock
+    mock_db.extension :sql_recorder
+
+    # Both should work independently
+    assert_respond_to mock_db, :sqls # Mock's built-in
+    assert_respond_to mock_db, :sql_recorder # Our extension
+
+    # Execute a query
+    mock_db[:test].all
+
+    # Both should record (though possibly differently)
+    assert_instance_of Array, mock_db.sqls
+    assert_instance_of Array, mock_db.sql_recorder
+  end
+
+  def test_database_extension_registration
+    # Test that the extension is properly registered with Sequel
+    # Check that we can load the extension without error
+    fresh_db = Sequel.mock
+    fresh_db.extension :sql_recorder
+
+    assert_respond_to fresh_db, :sql_recorder
+  end
+
+  def test_attr_reader_sql_recorder_works
+    # Directly test the attr_reader
+    assert_same @db.instance_variable_get(:@sql_recorder), @db.sql_recorder
+  end
+
+  def test_log_connection_yield_method_exists
+    assert_respond_to @db, :log_connection_yield
+    assert_includes Sequel::SqlRecorder.instance_methods, :log_connection_yield
+  end
+
+  def test_manual_sql_recording_functionality
+    # Test that we can manually record SQL using the method structure
+    test_sql = 'SELECT * FROM manual_test'
+
+    # Verify sql_recorder starts empty or with existing content
+    initial_count = @db.sql_recorder.length
+
+    # Manually add SQL using the same structure as log_connection_yield
+    @db.instance_variable_get(:@sql_recorder_mutex).synchronize do
+      @db.sql_recorder.push(test_sql)
+    end
+
+    assert_equal initial_count + 1, @db.sql_recorder.length
+    assert_includes @db.sql_recorder, test_sql
+  end
+
+end

data/test/lib/sequel/extensions/test_unionize.rb

@@ -0,0 +1,76 @@
+require_relative '../../../test_helper'
+require 'sequel'
+
+class TestUnionize < Minitest::Test
+
+  def test_should_unionize_a_single_dataset
+    db = Sequel.mock(host: :spark).extension(:unionize)
+    ds = db.unionize([db[:a]])
+
+    # No SQL should be executed
+    assert_empty(db.sqls)
+    # The SQL should be a single select
+    assert_equal('SELECT * FROM `a`', ds.sql)
+  end
+
+  def test_should_unionize_two_datasets
+    db = Sequel.mock(host: :spark).extension(:unionize)
+    ds = db.unionize([db[:a], db[:b]])
+
+    # No SQL should be executed
+    assert_empty(db.sqls)
+    # The SQL should be a single select
+    assert_equal('SELECT * FROM (SELECT * FROM `a` UNION SELECT * FROM `b`) AS `t1`', ds.sql)
+  end
+
+  def test_should_unionize_two_datasets_and_allow_all_option
+    db = Sequel.mock(host: :spark).extension(:unionize)
+    ds = db.unionize([db[:a], db[:b]], all: true)
+
+    # No SQL should be executed
+    assert_empty(db.sqls)
+    # The SQL should be a single select
+    assert_equal('SELECT * FROM (SELECT * FROM `a` UNION ALL SELECT * FROM `b`) AS `t1`', ds.sql)
+  end
+
+  def test_should_unionize_two_datasets_and_allow_from_self_option
+    db = Sequel.mock(host: :spark).extension(:unionize)
+    ds = db.unionize([db[:a], db[:b]], from_self: false)
+
+    # No SQL should be executed
+    assert_empty(db.sqls)
+    # The SQL should be a single select
+    assert_equal('SELECT * FROM `a` UNION SELECT * FROM `b`', ds.sql)
+  end
+
+  def test_should_unionize_four_datasets_as_sets_of_two
+    db = Sequel.mock(host: :spark).extension(:unionize)
+    ds = db.unionize([db[:a], db[:b], db[:c], db[:d]], chunk_size: 2, from_self: false)
+
+    # Two things should be created
+    assert_equal(
+      [
+        'CREATE TEMPORARY VIEW `temp_union_ac554bd85a4a6087511d4949f3a3c5a59c110cde` AS SELECT * FROM `a` UNION SELECT * FROM `b`',
+        'CREATE TEMPORARY VIEW `temp_union_1e7e77a914d0b30cd33511f372c48d537ad81084` AS SELECT * FROM `c` UNION SELECT * FROM `d`',
+      ], db.sqls
+    )
+    # The SQL should be a single select
+    assert_equal(
+      'SELECT * FROM `temp_union_ac554bd85a4a6087511d4949f3a3c5a59c110cde` UNION SELECT * FROM `temp_union_1e7e77a914d0b30cd33511f372c48d537ad81084`', ds.sql
+    )
+  end
+
+  def test_should_unionize_8_datasets_as_sets_of_two_then_another_two
+    db = Sequel.mock(host: :spark).extension(:unionize)
+    dses = %i[a b c d e f g h].map { |letter| db[letter] }
+    ds = db.unionize(dses, chunk_size: 2, from_self: false)
+
+    # Two things should be created
+    assert_equal(6, db.sqls.length)
+    # The SQL should be a single select
+    assert_equal(
+      'SELECT * FROM `temp_union_07a3e9f8f94e096301b62afd61b4315110ec0c3d` UNION SELECT * FROM `temp_union_ff3e49e7501c97ee5e69f112cc42bb7121f379f1`', ds.sql
+    )
+  end
+
+end

data/test/lib/sequel/extensions/test_usable.rb

@@ -3,10 +3,13 @@ require 'sequel'
 require 'sequel/extensions/usable'
 
 class TestUsable < Minitest::Test
+
   def test_should_call_use
     db = Sequel.mock(host: :sqlite)
     db.extension :usable
     db.use(:some_schema)
-    assert_equal(db.sqls, ["USE `some_schema`"])
+
+    assert_equal(['USE `some_schema`'], db.sqls)
   end
-end
+
+end

data/test/lib/sequelizer/test_connection_maker.rb

@@ -2,8 +2,9 @@ require_relative '../../test_helper'
 require 'sequelizer'
 
 class TestConnectionMaker < Minitest::Test
+
   def setup
-    @options = { 'adapter' => 'mock', "host" => "postgres" }
+    @options = { 'adapter' => 'mock', 'host' => 'postgres' }
   end
 
   def test_accepts_options_as_params
@@ -12,16 +13,12 @@ class TestConnectionMaker < Minitest::Test
     end
   end
 
-  def with_ignored_yaml_config(opts = {})
-  end
-
+  def with_ignored_yaml_config(opts = {}); end
 
-  def with_yaml_config(options = {})
+  def with_yaml_config(options = {}, &)
     yaml_config = Sequelizer::YamlConfig.new
     yaml_config.stub(:options, options) do
-      Sequelizer::YamlConfig.stub :new, yaml_config do
-        yield
-      end
+      Sequelizer::YamlConfig.stub(:new, yaml_config, &)
     end
   end
 
@@ -51,7 +48,8 @@ class TestConnectionMaker < Minitest::Test
       with_env_config do
         conn = Sequelizer::ConnectionMaker.new.connection
         conn.test_connection
-        assert_equal(["SET flim=flam"], conn.sqls)
+
+        assert_equal(['SET flim=flam'], conn.sqls)
       end
     end
   end
@@ -61,7 +59,8 @@ class TestConnectionMaker < Minitest::Test
       with_env_config do
         conn = Sequelizer::ConnectionMaker.new.connection
         conn.test_connection
-        assert_equal(["SET flim=flam"] * 2, conn.sqls)
+
+        assert_equal(['SET flim=flam'] * 2, conn.sqls)
       end
     end
   end
@@ -83,12 +82,13 @@ class TestConnectionMaker < Minitest::Test
   end
 
   def test_applies_configuration_to_connection
-    opts = @options.merge(postgres_db_opt_search_path: "searchy", impala_db_opt_search_path: "searchy2")
+    opts = @options.merge(postgres_db_opt_search_path: 'searchy', impala_db_opt_search_path: 'searchy2')
     with_yaml_config(opts) do
       conn = Sequelizer::ConnectionMaker.new.connection
       conn.test_connection
-      assert_equal({ search_path: "searchy" }, conn.db_opts.to_hash)
-      assert_equal(["SET search_path=searchy"], conn.db_opts.sql_statements)
+
+      assert_equal({ search_path: 'searchy' }, conn.db_opts.to_hash)
+      assert_equal(['SET search_path=searchy'], conn.db_opts.sql_statements)
     end
   end
 
@@ -96,16 +96,18 @@ class TestConnectionMaker < Minitest::Test
     Sequelizer::YamlConfig.stub :user_config_path, Pathname.new('/completely/made/up/path/that/does/not/exist') do
       conn = Sequelizer::ConnectionMaker.new(@options).connection
       conn.test_connection
-      assert_equal({}, conn.db_opts.to_hash)
-      assert_equal([], conn.db_opts.sql_statements)
+
+      assert_empty(conn.db_opts.to_hash)
+      assert_empty(conn.db_opts.sql_statements)
     end
   end
 
   def test_applies_quotes_when_necessary
     Sequelizer::YamlConfig.stub :user_config_path, Pathname.new('/completely/made/up/path/that/does/not/exist') do
-      @options.merge!(postgres_db_opt_search_path: "searchy,path")
+      @options.merge!(postgres_db_opt_search_path: 'searchy,path')
       conn = Sequelizer::ConnectionMaker.new(@options).connection
       conn.test_connection
+
       assert_equal({ search_path: "'searchy,path'" }, conn.db_opts.to_hash)
       assert_equal(["SET search_path='searchy,path'"], conn.db_opts.sql_statements)
     end
@@ -113,7 +115,9 @@ class TestConnectionMaker < Minitest::Test
 
   def test_applies_extensions
     with_yaml_config(@options.merge(extension_error_sql: 1)) do
-      assert Sequelizer::ConnectionMaker.new.connection.send(:instance_variable_get, "@loaded_extensions".to_sym).include?(:error_sql), "Extension wasn't set"
+      assert_includes Sequelizer::ConnectionMaker.new.connection.send(:instance_variable_get, :@loaded_extensions), :error_sql,
+                      "Extension wasn't set"
     end
   end
+
 end

data/test/lib/sequelizer/test_env_config.rb

@@ -1,8 +1,8 @@
 require_relative '../../test_helper'
 require 'sequelizer'
 
-
 class TestEnvConfig < Minitest::Test
+
   def setup
     @env_config = Sequelizer::EnvConfig.new
   end
@@ -17,18 +17,21 @@ class TestEnvConfig < Minitest::Test
   end
 
   def test_options_default_to_empty_hash
-    assert_equal(@env_config.options, {})
+    assert_empty(@env_config.options)
   end
 
   def test_converts_sequelizer_vars_to_options
     ENV['SEQUELIZER_ADAPTER'] = 'sqlite'
+
     assert_equal({ 'adapter' => 'sqlite' }, @env_config.options)
     ENV.delete('SEQUELIZER_ADAPTER')
   end
 
   def test_converts_db_opts_to_options
     ENV['POSTGRES_DB_OPT_HEY'] = 'there'
+
     assert_equal({ 'postgres_db_opt_hey' => 'there' }, @env_config.options)
     ENV.delete('POSTGRES_DB_OPT_HEY')
   end
+
 end

data/test/lib/sequelizer/test_gemfile_modifier.rb

@@ -2,13 +2,15 @@ require_relative '../../test_helper'
 require 'sequelizer/gemfile_modifier'
 
 class TestGemfileModifier < Minitest::Test
+
   def setup
     @gm = Sequelizer::GemfileModifier.new
   end
 
-  def test_dies_if_Gemfile_missing
+  def test_dies_if_gemfile_missing
     pn_mock = Minitest::Mock.new
     pn_mock.expect(:exist?, false)
+
     Pathname.stub(:new, pn_mock) do
       assert_raises(RuntimeError) { @gm.modify }
     end
@@ -71,17 +73,16 @@ class TestGemfileModifier < Minitest::Test
   end
 
   private
+
   def standard_pn_mock
     pn_mock = Minitest::Mock.new
     pn_mock.expect(:exist?, true)
   end
 
-  def stub_modifying_methods(obj)
+  def stub_modifying_methods(obj, &)
     obj.stub(:system, nil) do
-      obj.stub(:puts, nil) do
-        yield
-      end
+      obj.stub(:puts, nil, &)
     end
   end
-end
 
+end