active-record-ex 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37b890b128f7b72b6de19f2c1b7f08d7bb6927a0
-  data.tar.gz: 70d54c75898522aa2f00662dc9d915f4d0dbcabd
+  metadata.gz: 003406b4939618a1f44328e1bf84155ea6de693b
+  data.tar.gz: 1bee5be3e16844522ec53f91ab2a05721d231fa8
 SHA512:
-  metadata.gz: f23c5a2c7143fe57912763b45a6be54662f691ab7e378226cddd56f20ba0255ffc293c745bc40f13a76f0b71cc79b9263b6a2999d45a27c9aa9a5ed87bcd5f54
-  data.tar.gz: fb304cfeba050827048fb0ed6eef698eaa719d60af026a0ce49c7d12c194f911f6bff7a47473f8d754c3b0964e82729c84e7d22c977595b5e494d74952232173
+  metadata.gz: c6e1aa0159785dff066465d8d5ae242c373f922313a3d282daa2311638267e094ee0a72f68f77faf6d4a1b02461c82cea2901b07ccbbb1167487c9d1dd2a3d42
+  data.tar.gz: b49112112339eb49f429af039e2baa2e5c15eb8ce2bafe483e79332ed146244409544931e0b46abd4b76b75821b6f8454afb12acd1e78ae6456bb9e88b31d0d2

data/.gitignore

@@ -27,9 +27,9 @@
 
 # for a library or gem, you might want to ignore these files since the code is
 # intended to run in multiple environments; otherwise, check them in:
- Gemfile.lock
- .ruby-version
- .ruby-gemset
+Gemfile.lock
+.ruby-version
+.ruby-gemset
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc

data/.travis.yml

@@ -5,8 +5,15 @@ rvm:
   - 2.0.0
   - 2.1.2
   - 2.2.3
+env:
+  - "RAILS_VERSION=3.2.22.5"
+  - "RAILS_VERSION=4.2.8"
 cache:
   bundler: true
+install:
+  - gem update --system
+  - gem install bundler
+  - bundle install --jobs=3 --retry=3
 branches:
   only:
     - master

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+#### 0.2.2
+
+- Compatibility with Rails 4.x
+
 #### 0.2.1
 
 - Compatibility with more Ruby versions:

data/Gemfile

@@ -2,3 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in active-record-ex.gemspec
 gemspec
+
+rails_version = ENV["RAILS_VERSION"] || '4.2.8'
+
+gem 'activerecord', rails_version
+gem 'activesupport', rails_version
+
+group :test do
+  gem 'testrbl'
+end

data/Rakefile

@@ -2,8 +2,9 @@ require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
-  t.libs.push 'test'
-  t.test_files = FileList['test/**/*_test.rb']
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
 end
 
 desc 'Run tests'

data/active-record-ex.gemspec

@@ -20,10 +20,13 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'test-unit'
   spec.add_development_dependency 'shoulda'
   spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'minitest-rails'
+  spec.add_development_dependency 'test-unit'
 
-  spec.add_runtime_dependency 'activesupport', '~> 3.2'
-  spec.add_runtime_dependency 'activerecord', '~> 3.2'
+  spec.add_runtime_dependency 'activesupport', '>= 3.2'
+  spec.add_runtime_dependency 'activerecord', '>= 3.2'
 end

data/lib/active-record-ex/assoc_ordering.rb

@@ -7,9 +7,14 @@ module ActiveRecordEx
     end
 
     module ClassMethods
-      def has_many(assoc_name, options = {}, &extension)
-        order_field = options.delete(:order_on)
-        super
+      def has_many(assoc_name, scope = nil, options = {}, &extension)
+        order_field = scope.is_a?(Hash) ? scope.delete(:order_on) : options.delete(:order_on)
+        if ActiveRecord::VERSION::MAJOR < 4
+          super(assoc_name, scope || {}, &extension)
+        else
+          super
+        end
+        opts = (scope.is_a?(Hash) ? scope : options)
         return unless order_field
 
         define_model_setter(assoc_name, order_field)

data/lib/active-record-ex/assume_destroy.rb

@@ -1,7 +1,7 @@
 # extends accepts_nested_attributes_for
 # by default, accepts_nested_attributes_for "allow_destroy"s,
 # ie, will destroy associations if explicitly marked by _destroy: true
-# this flips that, causing an association to be destroyed 
+# this flips that, causing an association to be destroyed
 # if it's not included in the updating attrs
 module ActiveRecordEx
   module AssumeDestroy
@@ -18,6 +18,7 @@ module ActiveRecordEx
         super assoc_name, options
 
         return unless assume_destroy
+
         attrs_name = ("#{assoc_name.to_s}_attributes").to_sym
         setter_name = ("#{attrs_name.to_s}=").to_sym
         unassuming_setter_name = ("#{attrs_name.to_s}_without_assume=").to_sym
@@ -26,7 +27,6 @@ module ActiveRecordEx
         define_method(assuming_setter_name) do |attrs|
           ids = attrs.map { |a| a['id'] || a[:id] }.compact
           assocs = self.send(assoc_name)
-
           dead_assocs = []
           # the ternary's 'cause Arel doesn't do the right thing with an empty array
           dead_assocs = assocs.where('id NOT IN (?)', ids.any? ? ids : '') unless self.new_record?
@@ -35,7 +35,8 @@ module ActiveRecordEx
           attrs = attrs.concat(dead_attrs)
           self.send(unassuming_setter_name, attrs)
         end
-        alias_method_chain setter_name, :assume
+        alias_method unassuming_setter_name, setter_name
+        alias_method setter_name, assuming_setter_name
       end
     end
   end

data/lib/active-record-ex/many_to_many.rb

@@ -26,19 +26,42 @@ module ActiveRecordEx
     end
 
     module ClassMethods
-      def belongs_to(name, options={})
+      def set_scope_and_options(scope, options)
+        if scope.is_a?(Hash)
+          options = scope
+          scope   = nil
+        end
+        [scope, options]
+      end
+
+      def belongs_to(name, scope = nil, options = {})
+        scope, options = set_scope_and_options(scope, options)
         subtypes = options.delete(:subtypes)
-        super
+        if ActiveRecord::VERSION::MAJOR < 4
+          super(name, options)
+        else
+          super
+        end
         define_belongs_assoc(name, options.merge(subtypes: subtypes))
       end
 
-      def has_many(name, options = {}, &extension)
-        super
+      def has_many(name, scope = nil, options = {}, &extension)
+        scope, options = set_scope_and_options(scope, options)
+        if ActiveRecord::VERSION::MAJOR < 4
+          super(name, options, &extension)
+        else
+          super
+        end
         define_has_assoc(name.to_s.singularize, options)
       end
 
-      def has_one(name, options = {}, &extension)
-        super
+      def has_one(name, scope = nil, options = {}, &extension)
+        scope, options = set_scope_and_options(scope, options)
+        if ActiveRecord::VERSION::MAJOR < 4
+          super(name, options, &extension)
+        else
+          super
+        end
         define_has_assoc(name.to_s, options)
       end
 
@@ -74,7 +97,7 @@ module ActiveRecordEx
         method_name = name.pluralize.to_sym
         define_singleton_method(method_name) do
           klass = klass_name.constantize
-          foreign_key = self.arel_table[key_name]
+          foreign_key = ActiveRecord::VERSION::MAJOR < 4 ? self.arel_table[key_name] : self.arel_table[key_name].name
           primary_keys = self.pluck(foreign_key).uniq
           # eg, Account.where(id: ids)
           klass.where(klass.primary_key => primary_keys)
@@ -89,7 +112,7 @@ module ActiveRecordEx
 
           method_name = subtype_klass.to_s.demodulize.underscore.pluralize.to_sym
           define_singleton_method(method_name) do
-            foreign_key = self.arel_table[key_name]
+            foreign_key = ActiveRecord::VERSION::MAJOR < 4 ? self.arel_table[key_name] : self.arel_table[key_name].name
             primary_keys = self.where(type_key => type_val).pluck(foreign_key).uniq
             # eg, Account.where(id: ids)
             subtype_klass.where(subtype_klass.primary_key => primary_keys)
@@ -111,7 +134,7 @@ module ActiveRecordEx
 
         method_name = name.pluralize.to_sym
         define_singleton_method(method_name) do
-          primary_key = self.arel_table[self.primary_key]
+          primary_key = ActiveRecord::VERSION::MAJOR < 4 ? self.arel_table[self.primary_key] : self.arel_table[self.primary_key].name
           foreign_keys = self.pluck(primary_key).uniq
 
           other_klass = klass_name.constantize

data/lib/active-record-ex/polymorphic_build.rb

@@ -7,7 +7,7 @@ module ActiveRecordEx
     def self.included(base)
       base.extend(ClassMethods)
       base.instance_eval do
-        attr_accessible :type
+        attr_accessible :type if respond_to?(:attr_accessible)
 
         class << self
           alias_method_chain :new, :typing

data/lib/active-record-ex/relation_extensions.rb

@@ -29,7 +29,10 @@ module ActiveRecord
 
     def collapsed_where
       values = self.where_values
-      values = [true] if values.empty?
+      # You must pass in 1 instead of True Arel no longer
+      # supports TrueClass
+      # https://github.com/rails/rails/issues/20473
+      values = [1] if values.empty?
       # FIXME: Needs to wrap string literal conditions (e.g., where("id > 1"))
       Arel::Nodes::And.new(values)
     end

data/lib/active-record-ex/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordEx
-  VERSION = '0.2.1'
+  VERSION = '0.2.2'
 end

data/test/schema.rb

@@ -0,0 +1,63 @@
+ActiveRecord::Schema.define do
+  execute('PRAGMA foreign_keys = ON;')
+  create_table 'assumes_destroys' do |t|
+  end
+
+  create_table "destroyees" do |t|
+    t.integer :assumes_destroy_id
+    t.string :name
+  end
+
+  create_table 'parents' do |t|
+  end
+
+  create_table "children" do |t|
+    t.integer :parent_id
+    t.string :foo
+  end
+
+  create_table 'has_manieds' do |t|
+  end
+
+  create_table 'has_ordered_assocs' do |t|
+  end
+
+  create_table 'ordered_assocs' do |t|
+  end
+
+  create_table 'simple_belongs_tos' do |t|
+    t.integer :has_manied_id
+  end
+
+  create_table 'belongs_to_throughs' do |t|
+    t.integer :simple_belongs_to_id
+  end
+
+  create_table 'some_class_names' do |t|
+    t.integer :some_name_id
+    t.integer :has_manied_id
+  end
+
+  create_table 'foreign_keyeds' do |t|
+    t.integer :has_manied
+  end
+  # https://stackoverflow.com/questions/1884818/how-do-i-add-a-foreign-key-to-an-existing-sqlite-3-6-21-table
+  execute("ALTER TABLE foreign_keyeds ADD COLUMN some_foreign_key_id INTEGER REFERENCES has_manieds(id)")
+
+  create_table 'ones' do |t|
+    t.integer :has_manied_id
+  end
+
+  create_table 'aseds' do |t|
+    t.string :some_as_type
+    t.integer :some_as_id
+  end
+
+  create_table 'belongs_tos' do |t|
+    t.integer :has_manied_id
+  end
+
+  create_table 'poly_bases' do |t|
+    t.string :type
+  end
+end

data/test/test_helper.rb

@@ -1,85 +1,30 @@
 require 'active_record'
-require 'test/unit'
+require 'minitest/autorun'
 require 'shoulda'
-require 'mocha'
-
+require 'mocha/mini_test'
 require 'active-record-ex/relation_extensions'
+require 'database_cleaner'
 
-class ActiveSupport::TestCase
-  def db_expects(arel, query, response = nil)
-    response_columns = response.try(:first).try(:keys).try(:map, &:to_s) || []
-    response_rows = response.try(:map, &:values) || []
-    response = ActiveRecord::Result.new(response_columns, response_rows)
-
-    case query.first
-    when /^SELECT/
-      arel.connection.expects(:exec_query).with(*query).returns(response)
-    when /^DELETE/
-      arel.connection.expects(:exec_delete).with(*query).returns(response)
-    end
-  end
-end
-
-# Used as a "dummy" model in tests to avoid using a database connection
-class StubModel < ActiveRecord::Base
-  self.abstract_class = true
-
-  conn = Class.new(ActiveRecord::ConnectionAdapters::AbstractAdapter) do
-    def quote_column_name(name)
-      "`#{name.to_s.gsub('`', '``')}`"
-    end
-
-    def quote_table_name(name)
-      quote_column_name(name).gsub('.', '`.`')
-    end
-
-    def select(sql, name = nil, _ = [])
-      exec_query(sql, name).to_a
-    end
-  end
-
-  visitor = Class.new(Arel::Visitors::ToSql) do
-    def table_exists?(*_)
-      true
-    end
-
-    def column_for(attr)
-      pk = attr == 'id'
-      column = ActiveRecord::ConnectionAdapters::Column.new(attr, nil, pk ? :integer : :string)
-      column.primary = pk
-      column
-    end
-  end
-
-  @@connection = conn.new({})
-  @@connection.visitor = visitor.new(@@connection)
-
-  class << self
-    def connection
-      @@connection
-    end
-
-    def columns; []; end
-
-    def get_primary_key(*_); 'id'; end
-  end
+DatabaseCleaner.strategy = :truncation
 
-  # prevent AR from hitting the DB to get the schema
-  def get_primary_key(*_); 'id'; end
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+puts File.dirname(__FILE__) + '/schema.rb'
+load File.dirname(__FILE__) + '/schema.rb'
 
-  def with_transaction_returning_status; yield; end
-end
+require 'logger'
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+ActiveRecord::Base.logger.level = Logger::ERROR
 
 # SQLCounter is part of ActiveRecord but is not distributed with the gem (used for internal tests only)
 # see https://github.com/rails/rails/blob/3-2-stable/activerecord/test/cases/helper.rb#L59
 module ActiveRecord
   class SQLCounter
     cattr_accessor :ignored_sql
-    self.ignored_sql = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
+    self.ignored_sql = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/i, /^COMMIT/i, /FROM sqlite_master/]
 
     # FIXME: this needs to be refactored so specific database can add their own
     # ignored SQL.  This ignored SQL is for Oracle.
-    ignored_sql.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+    self.ignored_sql.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^INSERT/]
 
     cattr_accessor :log
     self.log = []
@@ -90,6 +35,10 @@ module ActiveRecord
       @ignore   = ignore
     end
 
+    def self.clear_log
+      self.log = []
+    end
+
     def call(name, start, finish, message_id, values)
       sql = values[:sql]
 
@@ -102,3 +51,32 @@ module ActiveRecord
 
   ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
 end
+
+class ActiveSupport::TestCase
+  setup do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with :truncation
+    DatabaseCleaner.start
+  end
+
+  teardown do
+    DatabaseCleaner.clean
+  end
+
+  def assert_no_queries(&block)
+    assert_queries(0, :ignore_none => true, &block)
+  end
+  def assert_queries(num = 1, options = {})
+    ignore_none = options.fetch(:ignore_none) { num == :any }
+    ActiveRecord::SQLCounter.clear_log
+    yield
+  ensure
+    the_log = ActiveRecord::SQLCounter.log
+    if num == :any
+      assert_operator the_log.size, :>=, 1, "1 or more queries expected, but none were executed."
+    else
+      mesg = "#{the_log.size} instead of #{num} queries were executed.#{the_log.size == 0 ? '' : "\nQueries:\n#{the_log.join("\n")}"}"
+      assert_equal num, the_log.size, mesg
+    end
+  end
+end

data/test/unit/assoc_ordering_test.rb

@@ -1,19 +1,19 @@
 require 'test_helper'
 require 'active-record-ex/assoc_ordering'
 
-class OrderedAssoc < StubModel
+class OrderedAssoc < ActiveRecord::Base
   attr_accessor :name
   attr_accessor :order
   attr_accessor :has_orderd_assoc_id
 end
 
-class DestroyableAssoc < StubModel
+class DestroyableAssoc < ActiveRecord::Base
   attr_accessor :name
   attr_accessor :order
   attr_accessor :has_orderd_assoc_id
 end
 
-class HasOrderedAssoc < StubModel
+class HasOrderedAssoc < ActiveRecord::Base
   include ActiveRecordEx::AssocOrdering
 
   has_many :ordered_assocs, order_on: :order

data/test/unit/assume_destroy_test.rb

@@ -1,32 +1,29 @@
 require 'test_helper'
 require 'active-record-ex/assume_destroy'
 
-class AssumeDestroyTest < ActiveRecord::TestCase
-  class AssumesDestroy < StubModel
+class AssumeDestroyTest < ActiveSupport::TestCase
+  class AssumesDestroy < ActiveRecord::Base
     include ActiveRecordEx::AssumeDestroy
 
     has_many :destroyees
     accepts_nested_attributes_for :destroyees,  assume_destroy: true
   end
 
-  class Destroyee < StubModel
+  class Destroyee < ActiveRecord::Base
   end
 
   context 'ActiveRecordEx::AssumeDestroy' do
-    setup do 
-      @subject = AssumesDestroy.new
-      @subject.stubs(:new_record?).returns(false)
+    setup do
+      @subject = AssumesDestroy.create
+      2.times { @subject.destroyees.create }
     end
 
     context 'preconditions in ActiveRecord' do
       should 'DELETE records marked for destruction' do
         attrs = []
-        stub_association_query(@subject, '\'\'', [{'id' => 1}, {'id' => 2}])
-        db_expects(@subject, ['SELECT `destroyees`.* FROM `destroyees`  WHERE `destroyees`.`assumes_destroy_id` IS NULL AND `destroyees`.`id` IN (1, 2)', 'AssumeDestroyTest::Destroyee Load'], [{'id' => 1}, {'id' => 2}])
-        db_expects(@subject.destroyees, ['DELETE FROM `destroyees` WHERE `destroyees`.`id` = ?', 'SQL', [[nil, 1]]])
-        db_expects(@subject.destroyees, ['DELETE FROM `destroyees` WHERE `destroyees`.`id` = ?', 'SQL', [[nil, 2]]])
-
+        assert_equal @subject.destroyees.count, 2
         @subject.update_attributes(destroyees_attributes: attrs)
+        assert_equal Destroyee.all, []
       end
     end
 
@@ -34,50 +31,37 @@ class AssumeDestroyTest < ActiveRecord::TestCase
       @subject.stubs(:new_record?).returns(true)
       attrs = [{name: 'one'}]
       expected_attrs = [{name: 'one'}]
-      @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
-
-      # shouldn't even hit the DB
       assert_no_queries { @subject.destroyees_attributes = attrs }
     end
 
     should 'mark all associations for destruction when passed an empty array' do
       attrs = []
-      stub_association_query(@subject, '\'\'', [{'id' => 1}, {'id' => 2}])
-
-      expected_attrs = [{id: 1, _destroy: true}, {id: 2, _destroy: true}]
+      expected_attrs = []
+      @subject.destroyees.each {|d| expected_attrs << {id: d.id, _destroy: true} }
       @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
       @subject.destroyees_attributes = attrs
     end
 
     should 'mark all existing associations for destruction when passed an array of just new' do
       attrs = [{name: 'one'}]
-      stub_association_query(@subject, '\'\'', [{'id' => 1}, {'id' => 2}])
-
-      expected_attrs = [{name: 'one'}, {id: 1, _destroy: true}, {id: 2, _destroy: true}]
+      expected_attrs = attrs.dup
+      @subject.destroyees.each {|d| expected_attrs << {id: d.id, _destroy: true} }
       @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
       @subject.destroyees_attributes = attrs
     end
 
     should 'not mark explicitly passed in associations for destruction' do
       attrs = [{name: 'one'}, {id: 1}]
-      stub_association_query(@subject, '1', [{id: 2}])
-
       expected_attrs = [{name: 'one'}, {id: 1}, {id: 2, _destroy: true}]
       @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
       @subject.destroyees_attributes = attrs
     end
 
-    should 'preserve existing marks for destruction' do 
+    should 'preserve existing marks for destruction' do
       attrs = [{name: 'one'}, {id: 1, _destroy: true}]
-      stub_association_query(@subject, '1', [{id: 2}])
-
       expected_attrs = [{name: 'one'}, {id: 1, _destroy: true}, {id: 2, _destroy: true}]
       @subject.expects(:destroyees_attributes_without_assume=).with(expected_attrs)
       @subject.destroyees_attributes = attrs
     end
   end
-
-  def stub_association_query(subject, id_string, id_response)
-    db_expects(subject, ["SELECT `destroyees`.* FROM `destroyees`  WHERE `destroyees`.`assumes_destroy_id` IS NULL AND (id NOT IN (#{id_string}))", 'AssumeDestroyTest::Destroyee Load'], id_response)
-  end
 end

data/test/unit/many_to_many_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 require 'active-record-ex/many_to_many'
 
 class ManyToManyTest < ActiveSupport::TestCase
-  class HasManied < StubModel
+  class HasManied < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
 
     has_one :one
@@ -14,7 +14,7 @@ class ManyToManyTest < ActiveSupport::TestCase
 
     singularize :ones
   end
-  class SimpleBelongsTo < StubModel
+  class SimpleBelongsTo < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
 
     belongs_to :has_manied
@@ -22,122 +22,112 @@ class ManyToManyTest < ActiveSupport::TestCase
 
     singularize :has_manieds
   end
-  class BelongsToThrough < StubModel
+  class BelongsToThrough < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
 
     belongs_to :has_manied
   end
-  class SomeClassName < StubModel
+  class SomeClassName < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
 
     belongs_to :some_name, class_name: 'ManyToManyTest::HasManied'
   end
-  class ForeignKeyed < StubModel
+  class ForeignKeyed < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
 
     belongs_to :has_manied, foreign_key: :some_foreign_key_id
   end
-  class Ased < StubModel
+  class Ased < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
 
     belongs_to :some_as, polymorphic: true, subtypes: [HasManied]
   end
-  class One < StubModel
+  class One < ActiveRecord::Base
   end
 
   context 'ActiveRecord::ManyToMany' do
     context '#has_one' do
-      setup { @arel = HasManied.scoped }
+      setup do
+        @has_manied = HasManied.create
+        @one = @has_manied.create_one
+      end
+
       should 'handle the simple case correctly' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}])
-        db_expects(@arel, ['SELECT `ones`.* FROM `ones`  WHERE `ones`.`has_manied_id` IN (1)', 'ManyToManyTest::One Load'])
-        @arel.ones.to_a
+        assert_equal HasManied.where('1=1').ones.to_a, [@one]
       end
     end
 
     context '#has_many' do
-      setup { @arel = HasManied.scoped }
+      setup do
+        @has_manied = HasManied.create
+        @simple_belongs_to = @has_manied.simple_belongs_tos.create
+      end
 
       should 'handle the simple case correctly' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
-        db_expects(@arel, ['SELECT `simple_belongs_tos`.* FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1)', 'ManyToManyTest::SimpleBelongsTo Load'])
-        @arel.simple_belongs_tos.to_a
+        assert_equal HasManied.where('1=1').simple_belongs_tos.to_a, [@simple_belongs_to]
       end
 
       should 'handle the empty base case correctly' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds`  WHERE (1=0)'], [])
-        db_expects(@arel, ['SELECT `simple_belongs_tos`.* FROM `simple_belongs_tos`  WHERE 1=0', 'ManyToManyTest::SimpleBelongsTo Load'])
-        @arel.none.simple_belongs_tos.to_a
+        assert_equal HasManied.where('1=1').none.simple_belongs_tos.to_a, []
       end
 
       should 'handle the multiple base ids case correctly' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}, {id: 2}])
-        db_expects(@arel, ['SELECT `simple_belongs_tos`.* FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1, 2)', 'ManyToManyTest::SimpleBelongsTo Load'])
-        @arel.simple_belongs_tos.to_a
+        second_has_manied = HasManied.create
+        simple_belongs_to = second_has_manied.simple_belongs_tos.create
+        assert_equal HasManied.where('1=1').simple_belongs_tos.to_a, [@simple_belongs_to, simple_belongs_to]
       end
 
       should 'chain queries for has_many through:' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}])
-        db_expects(@arel, ['SELECT `simple_belongs_tos`.`id` FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1)'], [{id: 1}])
-        db_expects(@arel, ['SELECT `belongs_to_throughs`.* FROM `belongs_to_throughs`  WHERE `belongs_to_throughs`.`simple_belongs_to_id` IN (1)', 'ManyToManyTest::BelongsToThrough Load'])
+        belongs_to_through = @simple_belongs_to.belongs_to_throughs.create
 
-        @arel.belongs_to_throughs.to_a
+        assert_equal HasManied.belongs_to_throughs.to_a, [belongs_to_through]
       end
 
       should 'not N+1 has_many through:' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [{id: 1}, {id: 2}])
-        db_expects(@arel, ['SELECT `simple_belongs_tos`.`id` FROM `simple_belongs_tos`  WHERE `simple_belongs_tos`.`has_manied_id` IN (1, 2)'], [{id: 1}, {id: 2}])
-        db_expects(@arel, ['SELECT `belongs_to_throughs`.* FROM `belongs_to_throughs`  WHERE `belongs_to_throughs`.`simple_belongs_to_id` IN (1, 2)', 'ManyToManyTest::BelongsToThrough Load'])
-
-        @arel.belongs_to_throughs.to_a
+        assert_queries(3) do
+          HasManied.where('1=1').belongs_to_throughs.to_a
+        end
       end
 
       should 'use the class name passed in' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
-        db_expects(@arel, ['SELECT `some_class_names`.* FROM `some_class_names`  WHERE `some_class_names`.`has_manied_id` IN (1)', 'ManyToManyTest::SomeClassName Load'])
-        @arel.class_nameds.to_a
+        @has_manied.class_nameds.create
+        assert_equal HasManied.where('1=1').class_nameds.first.class, ManyToManyTest::SomeClassName
       end
 
       should 'use the foreign key passed in' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
-        db_expects(@arel, ['SELECT `foreign_keyeds`.* FROM `foreign_keyeds`  WHERE `foreign_keyeds`.`some_foreign_key_id` IN (1)', 'ManyToManyTest::ForeignKeyed Load'])
-        @arel.foreign_keyeds.to_a
+        foreign_keyed = @has_manied.foreign_keyeds.create
+        assert_equal HasManied.where('1=1').foreign_keyeds.to_a, [foreign_keyed]
       end
 
       should 'use the as passed in' do
-        db_expects(@arel, ['SELECT `has_manieds`.`id` FROM `has_manieds` '], [id: 1])
-        db_expects(@arel, ['SELECT `aseds`.* FROM `aseds`  WHERE `aseds`.`some_as_type` = \'ManyToManyTest::HasManied\' AND `aseds`.`some_as_id` IN (1)', 'ManyToManyTest::Ased Load'])
-        @arel.aseds.to_a
+        ased = @has_manied.aseds.create
+        assert_equal HasManied.where('1=1').aseds.to_a, [ased]
       end
     end
 
     context '#belongs_to' do
       should 'handle the simple case correctly' do
-        @arel = SimpleBelongsTo.scoped
-        db_expects(@arel, ['SELECT `simple_belongs_tos`.`has_manied_id` FROM `simple_belongs_tos` '], [has_manied_id: 1])
-        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
-        @arel.has_manieds.to_a
+        has_manied = HasManied.create
+        sbt = has_manied.simple_belongs_tos.create
+        assert_equal SimpleBelongsTo.where('1=1').has_manieds.to_a, [has_manied]
       end
 
       should 'use the class name passed in' do
-        @arel = SomeClassName.scoped
-        db_expects(@arel, ['SELECT `some_class_names`.`some_name_id` FROM `some_class_names` '], [some_name_id: 1])
-        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
-        @arel.some_names.to_a
+        has_manied = HasManied.create
+        scn = SomeClassName.create(some_name_id: has_manied.id)
+        assert_equal SomeClassName.where('1=1').some_names.to_a, [has_manied]
       end
-      
+
       should 'use the foreign key passed in' do
-        @arel = ForeignKeyed.scoped
-        db_expects(@arel, ['SELECT `foreign_keyeds`.`some_foreign_key_id` FROM `foreign_keyeds` '], [some_foreign_key_id: 1])
-        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
-        @arel.has_manieds.to_a
+        has_manied = HasManied.create
+        foreign_keyed = ForeignKeyed.create(has_manied: has_manied)
+        assert_equal ForeignKeyed.where('1=1').has_manieds.to_a, [has_manied]
       end
 
       should 'handle polymorphic belongs_to' do
-        @arel = Ased.scoped
-        db_expects(@arel, ['SELECT `aseds`.`some_as_id` FROM `aseds`  WHERE `aseds`.`some_as_type` = \'ManyToManyTest::HasManied\''], [some_as_id: 1])
-        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (1)', 'ManyToManyTest::HasManied Load'])
-        @arel.has_manieds.to_a
+        has_manied = HasManied.create
+        ased = Ased.create(some_as: has_manied)
+        assert_equal Ased.where('1=1').has_manieds.to_a, [has_manied]
       end
     end
 
@@ -145,17 +135,15 @@ class ManyToManyTest < ActiveSupport::TestCase
       should 'work for belongs_tos without triggering an extra query' do
         @model = SimpleBelongsTo.new
         @model.stubs(:has_manied_id).returns(42)
-        @arel = HasManied.scoped
-        db_expects(@arel, ['SELECT `has_manieds`.* FROM `has_manieds`  WHERE `has_manieds`.`id` IN (42)', 'ManyToManyTest::HasManied Load'])
-        @model.has_manieds.to_a
+        @arel = HasManied.all
+        assert_queries(1) { @model.has_manieds.to_a }
       end
 
       should 'work for has_ones without triggering an extra query' do
         @model = HasManied.new
         @model.stubs(:id).returns(42)
-        @arel = One.scoped
-        db_expects(@arel, ['SELECT `ones`.* FROM `ones`  WHERE `ones`.`has_manied_id` IN (42)', 'ManyToManyTest::One Load'])
-        @model.ones.to_a
+        @arel = One.all
+        assert_queries(1) {@model.ones.to_a}
       end
     end
   end

data/test/unit/nillable_find_test.rb

@@ -3,54 +3,47 @@ require 'active-record-ex/many_to_many'
 require 'active-record-ex/nillable_find'
 
 class NillableFindTest < ActiveSupport::TestCase
-  class Parent < StubModel
+  class Parent < ActiveRecord::Base
     include ActiveRecordEx::ManyToMany
     include ActiveRecordEx::NillableFind
 
     has_many :children
   end
 
-  class Child < StubModel
+  class Child < ActiveRecord::Base
   end
 
   context 'ActiveRecordEx::NillableFind' do
     context '#nillable_find' do
-      setup { @arel = Parent.scoped }
+      setup do
+        @parent = Parent.where('1=1')
+      end
       # RC == relative complement
       should 'request the RC of the base scope in the parent scope when just passed nil' do
-        # fetch IDs
-        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE `parents`.`id` IS NULL'], [])
-        # fetch outside set
-        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents` '], [{id: 1}, {id: 2}])
-        # disjunct
-        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE ((1=0 OR NOT (`children`.`parent_id` IN (1, 2)) AND `children`.`foo` = \'bar\'))', 'NillableFindTest::Child Load'], [])
-
-        Parent.nillable_find([nil], Child.where(foo: 'bar')).children.all
+        2.times { Parent.create }
+        child = @parent.children.create
+        foo_child = @parent.children.create(foo: 'bar')
+        assert_equal Parent.nillable_find([nil], Child.where(foo: 'bar')).children.all, []
       end
 
       should 'request the disjunct of the RC of base scope in parent scope and all children of non-nil ids' do
         # fetch IDs
-        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE ((`parents`.`id` IN (1) OR `parents`.`id` IS NULL))'], [{id: 1}])
-        # fetch outside set
-        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents` '], [{id: 1}, {id: 2}])
-        # disjunct
-        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE ((`children`.`parent_id` IN (1) OR NOT (`children`.`parent_id` IN (1, 2)) AND `children`.`foo` = \'bar\'))', 'NillableFindTest::Child Load'], [])
-
-        Parent.nillable_find([1, nil], Child.where(foo: 'bar')).children.all
+        2.times { Parent.create }
+        parent = Parent.first
+        child = parent.children.create
+        assert_equal Parent.nillable_find([parent.id, nil], Child.where(foo: 'bar')).children.all.to_a, [child]
       end
 
       should 'request nothing when passed no an empty set of ids' do
-        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE 1=0'], [])
-        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE 1=0', 'NillableFindTest::Child Load'], [])
-
-        Parent.nillable_find([], Child.where(foo: 'bar')).children.all
+        child = Child.create(foo: 'bar')
+        assert_equal Parent.nillable_find([], Child.where(foo: 'bar')).children.all.to_a, []
       end
 
       should 'request as a normal many-to-many when passed only normal ids' do
-        db_expects(@arel, ['SELECT `parents`.`id` FROM `parents`  WHERE `parents`.`id` IN (1)'], [{id: 1}])
-        db_expects(@arel, ['SELECT `children`.* FROM `children`  WHERE `children`.`parent_id` IN (1)', 'NillableFindTest::Child Load'], [])
-
-        Parent.nillable_find([1], Child.where(foo: 'bar')).children.all
+        parent = Parent.create
+        child = parent.children.create
+        foo_child = Child.create(foo: 'bar')
+        assert_equal Parent.nillable_find([parent.id], Child.where(foo: 'bar')).children.all.to_a, [child]
       end
     end
   end

data/test/unit/polymorphic_build_test.rb

@@ -2,7 +2,7 @@ require 'test_helper'
 require 'active-record-ex/polymorphic_build'
 
 class PolymorphicBuildTest < ActiveSupport::TestCase
-  class PolyBase < StubModel
+  class PolyBase < ActiveRecord::Base
     include ActiveRecordEx::PolymorphicBuild
     attr_accessor :type
   end
@@ -22,7 +22,7 @@ class PolymorphicBuildTest < ActiveSupport::TestCase
 
   should 'throw an error if the passed in class is not a subclass' do
     assert_raise(ArgumentError) do
-      PolyBase.new(type: StubModel.to_s)
+      PolyBase.new(type: ActiveRecord::Base.to_s)
     end
   end
 end

data/test/unit/relation_extensions_test.rb

@@ -1,11 +1,11 @@
 require 'test_helper'
 
 class RelationExtensionsTest < ActiveSupport::TestCase
-  class HasManied < StubModel
+  class HasManied < ActiveRecord::Base
     has_many :belongs_tos
   end
 
-  class BelongsTo < StubModel
+  class BelongsTo < ActiveRecord::Base
     belongs_to :has_manied
     attr_accessor :has_manied_id
   end
@@ -49,13 +49,13 @@ class RelationExtensionsTest < ActiveSupport::TestCase
 
     context 'by unconditional' do
       should 'return nothing' do
-        assert_empty BelongsTo.scoped.relative_complement(@hm1.belongs_tos)
+        assert_equal true, BelongsTo.unscoped.relative_complement(@hm1.belongs_tos).empty?
       end
     end
 
     context 'of unconditional' do
       should 'return all belongs_tos' do
-        assert_equal @hm2.belongs_tos.all, @hm1.belongs_tos.relative_complement(BelongsTo.scoped)
+        assert_equal @hm2.belongs_tos.all, @hm1.belongs_tos.relative_complement(BelongsTo.where('1=1'))
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-record-ex
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Arjun Kavi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-02 00:00:00.000000000 Z
+date: 2017-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: test-unit
+  name: shoulda
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -54,7 +54,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: shoulda
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -68,7 +68,49 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -85,28 +127,28 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.2'
 description: A library to make ActiveRecord::Relations even more awesome
@@ -133,6 +175,7 @@ files:
 - lib/active-record-ex/polymorphic_build.rb
 - lib/active-record-ex/relation_extensions.rb
 - lib/active-record-ex/version.rb
+- test/schema.rb
 - test/test_helper.rb
 - test/unit/assoc_ordering_test.rb
 - test/unit/assume_destroy_test.rb
@@ -160,11 +203,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Relation -> Relation methods
 test_files:
+- test/schema.rb
 - test/test_helper.rb
 - test/unit/assoc_ordering_test.rb
 - test/unit/assume_destroy_test.rb