active_sort_order 0.9.4 → 0.9.5

data/test/test_helper.rb

@@ -1,63 +0,0 @@
-#$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-ENV["RAILS_ENV"] = "test"
-
-require "active_sort_order"
-
-begin
-  require 'warning'
-
-  Warning.ignore(
-    %r{mail/parsers/address_lists_parser}, ### Hide mail gem warnings
-  )
-rescue LoadError
-  # Do nothing
-end
-
-### Instantiates Rails
-require File.expand_path("../dummy_app/config/environment.rb",  __FILE__)
-
-require "rails/test_help"
-
-class ActiveSupport::TestCase
-  # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
-  fixtures :all
-end
-
-Rails.backtrace_cleaner.remove_silencers!
-
-require 'minitest/reporters'
-Minitest::Reporters.use!(
-  Minitest::Reporters::DefaultReporter.new,
-  ENV,
-  Minitest.backtrace_filter
-)
-
-require "minitest/autorun"
-
-# Run any available migration
-if ActiveRecord.gem_version >= Gem::Version.new("6.0")
-  ActiveRecord::MigrationContext.new(File.expand_path("dummy_app/db/migrate/", __dir__), ActiveRecord::SchemaMigration).migrate
-elsif ActiveRecord.gem_version >= Gem::Version.new("5.2")
-  ActiveRecord::MigrationContext.new(File.expand_path("dummy_app/db/migrate/", __dir__)).migrate
-else
-  ActiveRecord::Migrator.migrate File.expand_path("dummy_app/db/migrate/", __dir__)
-end
-
-[Post].each do |klass|
-  if defined?(SQLite3)
-    ActiveRecord::Base.connection.execute("DELETE FROM #{klass.table_name};")
-    ActiveRecord::Base.connection.execute("UPDATE `sqlite_sequence` SET `seq` = 0 WHERE `name` = '#{klass.table_name}';")
-  else
-    ActiveRecord::Base.connection.execute("TRUNCATE TABLE #{klass.table_name}")
-  end
-end
-
-DATA = {}.with_indifferent_access
-
-DATA[:posts] = [
-  Post.find_or_create_by!(a: 1, b: 3),
-  Post.find_or_create_by!(a: 2, b: 2),
-  Post.find_or_create_by!(a: 3, b: 2),
-  Post.find_or_create_by!(a: 4, b: 1),
-  Post.find_or_create_by!(a: 5, b: 1),
-].shuffle

data/test/unit/active_sort_order_test.rb

@@ -1,144 +0,0 @@
-require "test_helper"
-
-class ActiveSortOrderTest < ActiveSupport::TestCase
-
-  setup do
-  end
-
-  teardown do
-  end
-
-  def test_exposes_main_module
-    assert ActiveSortOrder.is_a?(Module)
-  end
-
-  def test_exposes_version
-    assert ActiveSortOrder::VERSION
-  end
-
-  def test_base_sort_order_default_value
-    klass = PostWithBaseOrderA
-
-    assert PostWithBaseOrderA.unscoped.sort_order.to_sql.include?("ORDER BY #{klass.base_sort_order}")
-
-    assert PostWithBaseOrderA.unscoped.sort_order(base_sort_order: true).to_sql.include?("ORDER BY #{klass.base_sort_order}")
-  end
-
-  def test_class_base_sort_order_only
-    assert_equal Post.all.count, DATA[:posts].count
-
-    sorted = PostWithBaseOrderA.all.sort_order
-
-    expected = DATA[:posts].sort_by{|item| item.a }
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-
-    sorted = PostWithBaseOrderB.all.sort_order
-
-    expected = DATA[:posts].sort_by{|item| item.b }
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].b, item.b ### use b instead of id as its not unique
-    end
-
-    sorted = PostWithBaseOrderAAndB.all.sort_order
-
-    expected = DATA[:posts].sort_by{|item| [item.a, item.b] }
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-
-    sorted = PostWithBaseOrderBAndA.all.sort_order
-
-    expected = DATA[:posts].sort_by{|item| [item.b, item.a] }
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-  end
-
-  def test_override_base_sort_order_only
-    assert_equal Post.all.count, DATA[:posts].count
-
-    sorted = PostWithBaseOrderA.order(b: :desc).sort_order(base_sort_order: "posts.b ASC")
-
-    expected = DATA[:posts].sort_by{|item| item.b }
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].b, item.b ### use b instead of id as its not unique
-    end
-
-    expected = DATA[:posts].sort_by{|item| item.id }
-
-    ### NIL & FALSE
-    [nil, false].each do |v|
-      sorted = PostWithBaseOrderA.order(id: :asc).sort_order(base_sort_order: v)
-
-      sorted.each_with_index do |item, i|
-        assert_equal expected[i].id, item.id
-      end
-    end
-  end
-
-  def test_sort_only
-    assert_equal Post.all.count, DATA[:posts].count
-
-    expected = DATA[:posts].sort_by{|item| item.a }.reverse
-
-    sorted = PostWithBaseOrderA.all.sort_order(:a, :desc)
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-
-    sorted = PostWithBaseOrderA.all.sort_order("posts.a", "DESC")
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-  end
-
-  def test_base_sort_order_and_sort
-    assert_equal Post.all.count, DATA[:posts].count
-
-    sorted = PostWithBaseOrderA.all.sort_order("posts.a", "DESC")
-
-    expected = DATA[:posts].sort_by{|item| item.a }.reverse
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-
-    sorted = PostWithBaseOrderB.all.sort_order("posts.b", "DESC")
-
-    expected = DATA[:posts].sort_by{|item| item.b }.reverse
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].b, item.b ### use b instead of id as its not unique
-    end
-  end
-
-  def test_sort_on_multiple_fields
-    assert_equal Post.all.count, DATA[:posts].count
-
-    expected = DATA[:posts].sort_by{|item| [item.b, item.a] }
-
-    sorted = PostWithBaseOrderA.all.sort_order([:b, :a], :asc)
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-
-    expected = DATA[:posts].sort_by{|item| [item.b, item.a] }.reverse
-
-    sorted = PostWithBaseOrderA.all.sort_order([:b, :a], :desc)
-
-    sorted.each_with_index do |item, i|
-      assert_equal expected[i].id, item.id
-    end
-  end
-
-end

data/test/unit/errors_test.rb

@@ -1,205 +0,0 @@
-require "test_helper"
-
-class ActiveSortOrderTest < ActiveSupport::TestCase
-
-  setup do
-  end
-
-  teardown do
-  end
-  
-  def test_sort_str_errors
-    ### TEST VALID
-    valid = [
-      "foo",
-      :foo,
-      nil,
-      "",
-      [],
-      [:foo],
-    ]
-
-    valid.each do |v|
-      Post.sort_order(v, :asc).limit(1)
-    end
-
-    ### TEST INVALID
-    invalid = [
-      true,
-      false,
-      Object.new,
-    ]
-
-    if RUBY_VERSION.to_f >= 3.0
-      invalid << {}
-    end
-
-    invalid.each do |v|
-      assert_raise ArgumentError do
-        Post.sort_order(v, :asc).limit(1)
-      end
-    end
-
-    assert_raise ArgumentError do
-      Post.sort_order(Object.new, :asc).limit(1)
-    end
-
-    ### TEST UNIQUE CASES
-
-    if RUBY_VERSION.to_f < 3.0
-      ### HASH - this is allowed because its treated as keyword arguments
-      Post.sort_order({}).limit(1)
-
-      assert_raise do
-        Post.sort_order({}, :desc).limit(1)
-      end
-    end
-  end
-
-  def test_sort_direction_errors
-    valid = [
-      "ASC",
-      "DESC",
-      "ASC NULLS FIRST",
-      "ASC NULLS LAST",
-      "DESC NULLS FIRST",
-      "DESC NULLS LAST",
-      nil,
-      "",
-
-      ### NASTY BUT TECHNICALLY ALLOWED BECAUSE OF SANITIZATION TECHNIQUE
-      "ASC   NULLS   FIRST",
-      "   ASC   ",
-      "ASC\n",
-      "ASC\tNULLS\tFirst",
-    ].freeze
-
-    valid.each do |direction|
-      PostWithBaseOrderA.sort_order("x", direction).limit(1)
-
-      if direction
-        direction = direction.try!(:downcase)
-
-        PostWithBaseOrderA.sort_order("x", direction).limit(1)
-
-        direction = direction.try!(:to_sym)
-
-        PostWithBaseOrderA.sort_order("foobar", direction).limit(1)
-      end
-    end
-
-    invalid = [
-      false,
-      true,
-      Object.new,
-      [],
-      'ASCC',
-    ]
-
-    if RUBY_VERSION.to_f >= 3.0
-      invalid << {}
-    end
-
-    invalid.each do |direction|
-      assert_raise ArgumentError do
-        PostWithBaseOrderA.sort_order("foobar", direction).limit(1)
-      end
-    end
-
-    ### TEST UNIQUE CASES
-
-    if RUBY_VERSION.to_f < 3.0
-      ### HASH - this is allowed because its treated as keyword arguments
-      Post.sort_order("foobar", {}).limit(1).to_sql.include?("foobar ASC")
-
-      assert_raise do
-        Post.sort_order("foobar", {}, {}).limit(1)
-      end
-    end
-  end
-
-  def test_argument_base_sort_order_errors
-    assert_not Post.respond_to?(:base_sort_order)
-
-    valid = [
-      nil,
-      true,
-      false,
-      "",
-      "foobar",
-    ]
-
-    valid.each do |v|
-      Post.sort_order(base_sort_order: v).limit(1)
-    end
-
-    invalid = [
-      :foobar,
-      [],
-      {},
-      Object.new,
-    ]
-
-    invalid.each do |v|
-      assert_raise ArgumentError do
-        Post.sort_order(base_sort_order: v).limit(1)
-      end
-    end
-  end
-
-  def test_class_method_base_sort_order_errors
-    klass = PostWithVolatileBaseOrder
-
-    assert klass.respond_to?(:base_sort_order)
-
-    valid = [
-      nil,
-      false,
-      "",
-      "foobar",
-    ]
-
-    valid.each do |v|
-      silence_warnings do
-        klass.define_singleton_method :base_sort_order do
-          v
-        end
-      end
-
-      if v.nil?
-        assert_nil klass.base_sort_order
-      else
-        assert_equal v, klass.base_sort_order
-      end
-
-      klass.sort_order.limit(1)
-    end
-
-    invalid = [
-      true,
-      :foobar,
-      [],
-      {},
-      Object.new,
-    ]
-
-    invalid.each do |v|
-      silence_warnings do
-        klass.define_singleton_method :base_sort_order do
-          v
-        end
-      end
-
-      if v.nil?
-        assert_nil klass.base_sort_order
-      else
-        assert_equal v, klass.base_sort_order
-      end
-
-      assert_raise ArgumentError do
-        klass.sort_order.limit(1)
-      end
-    end
-  end
-
-end