sequelizer 0.1.4 → 0.1.6

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 = {}, &block)
     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, &block
     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, &block)
     obj.stub(:system, nil) do
-      obj.stub(:puts, nil) do
-        yield
-      end
+      obj.stub(:puts, nil, &block)
     end
   end
-end
 
+end

data/test/lib/sequelizer/test_options.rb

@@ -1,8 +1,8 @@
 require_relative '../../test_helper'
 require 'sequelizer/options'
 
-
 class TestOptions < Minitest::Test
+
   def test_changes_postgresql_adapter_to_postgres
     options = Sequelizer::Options.new(Sequelizer::OptionsHash.new(adapter: 'postgresql'))
 
@@ -30,19 +30,22 @@ class TestOptions < Minitest::Test
   end
 
   def test_prefers_search_path_over_schema_search_path
-    options = Sequelizer::Options.new(Sequelizer::OptionsHash.new(adapter: 'postgres', search_path: 'path', schema_search_path: 'path2'))
+    options = Sequelizer::Options.new(Sequelizer::OptionsHash.new(adapter: 'postgres', search_path: 'path',
+                                                                  schema_search_path: 'path2'))
 
     assert_equal('path', options.search_path)
   end
 
   def test_returns_timeout_as_an_integer_even_if_given_string
-    options = Sequelizer::Options.new({timeout: "30"})
+    options = Sequelizer::Options.new({ timeout: '30' })
+
     assert_equal(30, options.to_hash[:timeout])
   end
 
   def test_returns_a_hash_even_if_given_nil
     Sequelizer::YamlConfig.stub :user_config_path, Pathname.new('/completely/made/up/path/that/does/not/exist') do
       options = Sequelizer::Options.new
+
       assert_equal(1, options.to_hash.length)
       assert_instance_of(Proc, options.to_hash[:after_connect])
     end
@@ -50,6 +53,7 @@ class TestOptions < Minitest::Test
 
   def test_handles_symbolized_search_path
     options = Sequelizer::Options.new(search_path: 'passed', adapter: 'postgres')
+
     assert_equal 'passed', options.search_path
   end
 
@@ -60,19 +64,20 @@ class TestOptions < Minitest::Test
     conny.expect :db, db
     conny.expect :db, db
 
-    procky = Proc.new { |conn| conn.db[:table].to_a }
+    procky = proc { |conn| conn.db[:table].to_a }
 
     options = Sequelizer::Options.new(after_connect: procky)
     options.to_hash[:after_connect].call(conny, :default, db)
 
-    assert_equal(["SELECT * FROM \"table\""], db.sqls)
+    assert_equal(['SELECT * FROM "table"'], db.sqls)
   end
 
   def test_handles_extensions_passed_in
-    options = Sequelizer::Options.new(extension_example_1: 1, extension_example_2: 1, not_an_extension_example: 1)
+    options = Sequelizer::Options.new(extension_example_one: 1, extension_example_two: 1, not_an_extension_example: 1)
+
     assert_equal 1, options.to_hash[:not_an_extension_example]
-    assert options.extensions.include?(:example_1), "Failed to find example_1 in extensions"
-    assert options.extensions.include?(:example_2), "Failed to find example_2 in extensions"
+    assert_includes options.extensions, :example_one, 'Failed to find example_one in extensions'
+    assert_includes options.extensions, :example_two, 'Failed to find example_two in extensions'
   end
-end
 
+end

data/test/lib/sequelizer/test_yaml_config.rb

@@ -1,21 +1,19 @@
 require_relative '../../test_helper'
 require 'sequelizer/yaml_config'
 
-
 class TestYamlConfig < Minitest::Test
+
   def setup
     @yaml_config = Sequelizer::YamlConfig.new
   end
 
-  def with_empty_env
+  def with_empty_env(&)
     env_mock = Minitest::Mock.new
     env_mock.expect :[], nil, ['SEQUELIZER_ENV']
     env_mock.expect :[], nil, ['RAILS_ENV']
     env_mock.expect :[], nil, ['RACK_ENV']
 
-    stub_const(Sequelizer::YamlConfig, :ENV, env_mock) do
-      yield
-    end
+    stub_const(Sequelizer::YamlConfig, :ENV, env_mock, &)
 
     env_mock.verify
   end
@@ -41,7 +39,7 @@ class TestYamlConfig < Minitest::Test
     file_mock = Minitest::Mock.new
     file_mock.expect :exist?, true
     @yaml_config.stub :config_file_path, file_mock do
-      @yaml_config.stub :config, {'development' => { 'adapter' => 'sqlite' }} do
+      @yaml_config.stub :config, { 'development' => { 'adapter' => 'sqlite' } } do
         with_empty_env do
           assert_equal({ 'adapter' => 'sqlite' }, @yaml_config.options)
         end
@@ -51,27 +49,29 @@ class TestYamlConfig < Minitest::Test
   end
 
   def test_options_default_to_empty_hash
-    assert_equal(@yaml_config.options, {})
+    assert_empty(@yaml_config.options)
   end
 
   def test_path_defaults_to_local_config
-    assert_equal(@yaml_config.config_file_path, Pathname.pwd + "config" + "sequelizer.yml")
+    assert_equal(@yaml_config.config_file_path, Pathname.pwd.join('config', 'sequelizer.yml'))
   end
 
   def test_path_can_be_fed_pathanem_from_initialize
-    assert_equal(Sequelizer::YamlConfig.new(Pathname.new("~") + ".config").config_file_path, Pathname.new("~").expand_path + ".config")
+    assert_equal(Sequelizer::YamlConfig.new(Pathname.new('~').join('.config')).config_file_path,
+                 Pathname.new('~').expand_path.join('.config'))
   end
 
   def test_path_can_be_fed_string_from_initialize
-    assert_equal(Sequelizer::YamlConfig.new("~/.config").config_file_path, Pathname.new("~").expand_path + ".config")
+    assert_equal(Sequelizer::YamlConfig.new('~/.config').config_file_path, Pathname.new('~/.config').expand_path)
   end
 
   def test_local_is_current_directory
-    assert_equal(Sequelizer::YamlConfig.local_config.config_file_path, Pathname.pwd + "config" + "sequelizer.yml")
+    assert_equal(Sequelizer::YamlConfig.local_config.config_file_path, Pathname.pwd.join('config', 'sequelizer.yml'))
   end
 
   def test_home_uses_home_directory
-    assert_equal(Sequelizer::YamlConfig.user_config.config_file_path, Pathname.new("~").expand_path + ".config" + "sequelizer" + "database.yml")
+    assert_equal(Sequelizer::YamlConfig.user_config.config_file_path,
+                 Pathname.new(Dir.home).join('.config', 'sequelizer', 'database.yml'))
   end
 
   def test_environment_checks_environment_variables
@@ -79,4 +79,5 @@ class TestYamlConfig < Minitest::Test
       assert_equal 'development', @yaml_config.environment
     end
   end
+
 end