sequelizer 0.1.6 → 0.3.0

data/test/lib/sequelizer/test_env_config.rb

@@ -1,37 +0,0 @@
-require_relative '../../test_helper'
-require 'sequelizer'
-
-class TestEnvConfig < Minitest::Test
-
-  def setup
-    @env_config = Sequelizer::EnvConfig.new
-  end
-
-  def test_loads_dotenv
-    mock = Minitest::Mock.new
-    stub_const(Sequelizer::EnvConfig, :Dotenv, mock) do
-      mock.expect :load, nil
-      @env_config.options
-      mock.verify
-    end
-  end
-
-  def test_options_default_to_empty_hash
-    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

@@ -1,88 +0,0 @@
-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
-    pn_mock = Minitest::Mock.new
-    pn_mock.expect(:exist?, false)
-
-    Pathname.stub(:new, pn_mock) do
-      assert_raises(RuntimeError) { @gm.modify }
-    end
-    pn_mock.verify
-  end
-
-  def test_quits_if_no_modification_needed
-    opts_mock = Minitest::Mock.new
-    pn_mock = standard_pn_mock
-    opts_mock.expect(:adapter, 'postgres')
-    file_mock = Minitest::Mock.new
-    file_mock.expect(:readlines, ["gem 'pg'"], [pn_mock])
-
-    Pathname.stub(:new, pn_mock) do
-      Sequelizer::Options.stub(:new, opts_mock) do
-        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
-          stub_modifying_methods(@gm) do
-            @gm.modify
-          end
-        end
-      end
-    end
-  end
-
-  def test_quits_if_no_modification_needed2
-    opts_mock = Minitest::Mock.new
-    pn_mock = standard_pn_mock
-    opts_mock.expect(:adapter, 'postgres')
-    file_mock = Minitest::Mock.new
-    file_mock.expect(:readlines, ["gem 'pg' # ADDED BY SEQUELIZER"], [pn_mock])
-
-    Pathname.stub(:new, pn_mock) do
-      Sequelizer::Options.stub(:new, opts_mock) do
-        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
-          stub_modifying_methods(@gm) do
-            @gm.modify
-          end
-        end
-      end
-    end
-  end
-
-  def test_writes_if_modification_needed
-    opts_mock = Minitest::Mock.new
-    pn_mock = standard_pn_mock
-    opts_mock.expect(:adapter, 'postgres')
-    file_mock = Minitest::Mock.new
-    file_mock.expect(:readlines, ['#comment line', "gem 'sqlite3' # ADDED BY SEQUELIZER"], [pn_mock])
-    file_mock.expect(:write, nil, [pn_mock, ['#comment line', "gem 'pg' # ADDED BY SEQUELIZER"].join("\n")])
-
-    Pathname.stub(:new, pn_mock) do
-      Sequelizer::Options.stub(:new, opts_mock) do
-        stub_const(Sequelizer::GemfileModifier, :File, file_mock) do
-          stub_modifying_methods(@gm) do
-            @gm.modify
-          end
-        end
-      end
-    end
-  end
-
-  private
-
-  def standard_pn_mock
-    pn_mock = Minitest::Mock.new
-    pn_mock.expect(:exist?, true)
-  end
-
-  def stub_modifying_methods(obj, &block)
-    obj.stub(:system, nil) do
-      obj.stub(:puts, nil, &block)
-    end
-  end
-
-end

data/test/lib/sequelizer/test_options.rb

@@ -1,83 +0,0 @@
-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'))
-
-    assert_equal('postgres', options.adapter)
-    assert_equal('postgres', options.to_hash[:adapter])
-    assert_equal('postgres', options.to_hash['adapter'])
-  end
-
-  def test_finds_search_path_as_search_path
-    options = Sequelizer::Options.new(Sequelizer::OptionsHash.new(adapter: 'postgres', search_path: 'path'))
-
-    assert_equal('path', options.search_path)
-  end
-
-  def test_finds_schema_as_search_path
-    options = Sequelizer::Options.new(Sequelizer::OptionsHash.new(adapter: 'postgres', schema: 'path'))
-
-    assert_equal('path', options.search_path)
-  end
-
-  def test_finds_schema_search_path_as_search_path
-    options = Sequelizer::Options.new(Sequelizer::OptionsHash.new(adapter: 'postgres', schema_search_path: 'path'))
-
-    assert_equal('path', options.search_path)
-  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'))
-
-    assert_equal('path', options.search_path)
-  end
-
-  def test_returns_timeout_as_an_integer_even_if_given_string
-    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
-  end
-
-  def test_handles_symbolized_search_path
-    options = Sequelizer::Options.new(search_path: 'passed', adapter: 'postgres')
-
-    assert_equal 'passed', options.search_path
-  end
-
-  def test_handles_existing_after_connect
-    db = Sequel.mock(host: :postgres)
-    conny = Minitest::Mock.new
-    conny.expect :db, db
-    conny.expect :db, db
-    conny.expect :db, db
-
-    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)
-  end
-
-  def test_handles_extensions_passed_in
-    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_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

data/test/lib/sequelizer/test_yaml_config.rb

@@ -1,83 +0,0 @@
-require_relative '../../test_helper'
-require 'sequelizer/yaml_config'
-
-class TestYamlConfig < Minitest::Test
-
-  def setup
-    @yaml_config = Sequelizer::YamlConfig.new
-  end
-
-  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, &)
-
-    env_mock.verify
-  end
-
-  def test_loads_from_yaml_file_if_present
-    mock = Minitest::Mock.new
-    file_mock = Minitest::Mock.new
-
-    stub_const(Sequelizer::YamlConfig, :File, mock) do
-      mock.expect :read, 'adapter: <%= "sqlite" %>', [file_mock]
-      file_mock.expect :exist?, true
-
-      @yaml_config.stub :config_file_path, file_mock do
-        assert_equal({ 'adapter' => 'sqlite' }, @yaml_config.options)
-      end
-
-      file_mock.verify
-      mock.verify
-    end
-  end
-
-  def test_loads_by_environment_if_present
-    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
-        with_empty_env do
-          assert_equal({ 'adapter' => 'sqlite' }, @yaml_config.options)
-        end
-      end
-    end
-    file_mock.verify
-  end
-
-  def test_options_default_to_empty_hash
-    assert_empty(@yaml_config.options)
-  end
-
-  def test_path_defaults_to_local_config
-    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('~').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('~/.config').expand_path)
-  end
-
-  def test_local_is_current_directory
-    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(Dir.home).join('.config', 'sequelizer', 'database.yml'))
-  end
-
-  def test_environment_checks_environment_variables
-    with_empty_env do
-      assert_equal 'development', @yaml_config.environment
-    end
-  end
-
-end

data/test/test_helper.rb

@@ -1,44 +0,0 @@
-# Disable Rails plugins for Minitest to avoid version conflicts
-ENV['MT_NO_PLUGINS'] = '1'
-
-# SimpleCov must be loaded before application code
-require 'simplecov'
-
-SimpleCov.start do
-  add_filter '/test/'
-  add_filter '/vendor/'
-
-  add_group 'Core', 'lib/sequelizer'
-  add_group 'Sequel Extensions', 'lib/sequel'
-
-  # Temporarily lower minimum coverage to see what we're working with
-  minimum_coverage 70
-  minimum_coverage_by_file 40
-
-  # Generate both HTML and JSON for easier analysis
-  formatter SimpleCov::Formatter::MultiFormatter.new([
-                                                       SimpleCov::Formatter::HTMLFormatter,
-                                                       SimpleCov::Formatter::SimpleFormatter,
-                                                     ])
-end
-
-require 'minitest/autorun'
-require 'sequel'
-
-module Minitest
-  class Test
-
-    def stub_const(klass, const, replace)
-      klass.send(:const_set, const, replace)
-      return unless block_given?
-
-      yield
-      remove_stubbed_const(klass, const)
-    end
-
-    def remove_stubbed_const(klass, const)
-      klass.send(:remove_const, const)
-    end
-
-  end
-end