low_card_tables 1.0.0

data/spec/low_card_tables/system/queries_system_spec.rb

@@ -0,0 +1,142 @@
+require 'low_card_tables'
+require 'low_card_tables/helpers/database_helper'
+require 'low_card_tables/helpers/system_helpers'
+
+describe "LowCardTables query support" do
+  include LowCardTables::Helpers::SystemHelpers
+
+  def create_user!(name, deleted, deceased, gender, donation_level)
+    out = ::User.new
+    out.name = name
+    out.deleted = deleted
+    out.deceased = deceased
+    out.gender = gender
+    out.donation_level = donation_level
+    out.save!
+    out
+  end
+
+  before :each do
+    @dh = LowCardTables::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+    create_standard_system_spec_models!
+
+    @user1 = create_user!('User1', false, false, 'female', 10)
+    @user2 = create_user!('User2', true, false, 'female', 10)
+    @user3 = create_user!('User3', false, true, 'female', 10)
+    @user4 = create_user!('User4', false, false, 'male', 10)
+    @user5 = create_user!('User5', false, false, 'female', 8)
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  def check_user_ids(users, expected_users)
+    users.to_a.map(&:id).sort.should == expected_users.to_a.map(&:id).sort
+  end
+
+  it "should allow 'where' clauses that use the association name" do
+    check_user_ids(::User.where(:status => { :deleted => false }), [ @user1, @user3, @user4, @user5 ])
+  end
+
+  it "should allow 'where' clauses that use the foreign-key name" do
+    check_user_ids(::User.where(:user_status_id => ::UserStatus.low_card_ids_matching({ :deleted => false })), [ @user1, @user3, @user4, @user5 ])
+  end
+
+  it "should allow 'where' clauses that use delegated properties directly" do
+    check_user_ids(::User.where(:deleted => false), [ @user1, @user3, @user4, @user5 ])
+  end
+
+  it "should allow 'where' clauses that combine low-card and non-low-card properties" do
+    check_user_ids(::User.where(:deleted => false, :name => 'User1'), [ @user1 ])
+    check_user_ids(::User.where(:deleted => false, :name => 'User2'), [ ])
+  end
+
+  it "should allow 'where' clauses that use delegated properties with differently-prefixed names directly" do
+    define_model_class(:User2, :lctables_spec_users) { has_low_card_table :status, :prefix => :foo, :class => ::UserStatus, :foreign_key => :user_status_id }
+
+    lambda { check_user_ids(::User2.where(:deleted => false), [ ]) }.should raise_error(::ActiveRecord::StatementInvalid)
+    check_user_ids(::User2.where(:foo_deleted => false), [ @user1, @user3, @user4, @user5 ])
+  end
+
+  it "should not allow 'where' clauses that use non-delegated properties" do
+    define_model_class(:User3, :lctables_spec_users) { has_low_card_table :status, :delegate => [ :deceased ], :class => ::UserStatus, :foreign_key => :user_status_id }
+
+    lambda { check_user_ids(::User3.where(:deleted => false), [ ]) }.should raise_error(::ActiveRecord::StatementInvalid)
+  end
+
+  it "should compose 'where' clauses correctly" do
+    check_user_ids(::User.where(:deleted => false).where(:gender => 'male'), [ @user4 ])
+  end
+
+  it "should compose delegated and specified clauses correctly" do
+    check_user_ids(::User.where(:deleted => false, :status => { :gender => 'male'}), [ @user4 ])
+  end
+
+  it "should allow using low-card properties in the default scope" do
+    LowCardTables::VersionSupport.define_default_scope(::User, :deleted => false)
+    check_user_ids(::User.all, [ @user1, @user3, @user4, @user5 ])
+  end
+
+  it "should allow using low-card properties in arbitrary scopes and the default scope" do
+    LowCardTables::VersionSupport.define_default_scope(::User, :deleted => false)
+    class ::User < ::ActiveRecord::Base
+      scope :foo, lambda { where(:gender => 'female') }
+      scope :bar, lambda { where(:status => { :deceased => false }) }
+    end
+
+    check_user_ids(::User.all, [ @user1, @user3, @user4, @user5 ])
+    check_user_ids(::User.foo, [ @user1, @user3, @user5 ])
+    check_user_ids(::User.bar, [ @user1, @user4, @user5 ])
+    check_user_ids(::User.foo.bar, [ @user1, @user5 ])
+    check_user_ids(::User.bar.foo, [ @user1, @user5 ])
+  end
+
+  it "should pick up new low-card rows when using a low-card property in a scope" do
+    LowCardTables::VersionSupport.define_default_scope(::User, nil)
+    class ::User < ::ActiveRecord::Base
+      scope :foo, lambda { where(:deceased => false) }
+      scope :bar, lambda { where(:gender => 'female') }
+    end
+
+    check_user_ids(::User.all, [ @user1, @user2, @user3, @user4, @user5 ])
+    check_user_ids(::User.foo, [ @user1, @user2, @user4, @user5 ])
+    check_user_ids(::User.bar, [ @user1, @user2, @user3, @user5 ])
+
+    @user6 = create_user!('User6', false, false, 'female', 7)
+    [ @user1, @user2, @user3, @user4, @user5 ].map(&:user_status_id).include?(@user6.user_status_id).should_not be
+
+    check_user_ids(::User.all, [ @user1, @user2, @user3, @user4, @user5, @user6 ])
+    check_user_ids(::User.foo, [ @user1, @user2, @user4, @user5, @user6 ])
+    check_user_ids(::User.bar, [ @user1, @user2, @user3, @user5, @user6 ])
+  end
+
+  it "should blow up if you constrain on low-card foreign keys in a static scope" do
+    lambda do
+      LowCardTables::VersionSupport.define_default_scope(::User, nil)
+      class ::User < ::ActiveRecord::Base
+        scope :foo, where(:deleted => false)
+      end
+    end.should raise_error(LowCardTables::Errors::LowCardStaticScopeError, /user_status_id/mi)
+
+    lambda do
+      LowCardTables::VersionSupport.define_default_scope(::User, nil)
+      class ::User < ::ActiveRecord::Base
+        scope :foo, where(:user_status_id => ::UserStatus.low_card_ids_matching(:deleted => false))
+      end
+    end.should raise_error(LowCardTables::Errors::LowCardStaticScopeError, /user_status_id/mi)
+  end
+
+
+  it "should not blow up if you constrain on other things in a static scope" do
+    LowCardTables::VersionSupport.define_default_scope(::User, nil)
+    class ::User < ::ActiveRecord::Base
+      scope :foo, where(:name => %w{foo bar})
+    end
+
+    ::User.first.should be
+  end
+end

data/spec/low_card_tables/system/validations_system_spec.rb

@@ -0,0 +1,88 @@
+require 'low_card_tables'
+require 'low_card_tables/helpers/database_helper'
+require 'low_card_tables/helpers/system_helpers'
+
+describe "LowCardTables validation support" do
+  include LowCardTables::Helpers::SystemHelpers
+
+  before :each do
+    @dh = LowCardTables::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+    create_standard_system_spec_models!
+
+    class ::UserStatus
+      validates :gender, :inclusion => { :in => %w{male female other} }
+    end
+
+    class ::User
+      validates :donation_level, :numericality => { :greater_than_or_equal_to => 0, :less_than_or_equal_to => 10 }
+    end
+
+    @user1 = ::User.new
+    @user1.name = 'User1'
+    @user1.deleted = false
+    @user1.deceased = false
+    @user1.gender = 'female'
+    @user1.donation_level = 3
+    @user1.save!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  it "should allow validations on the low-card table that are enforced" do
+    @user1.gender = 'amazing'
+    e = nil
+
+    begin
+      @user1.save!
+    rescue => x
+      e = x
+    end
+
+    e.should be
+    e.class.should == LowCardTables::Errors::LowCardInvalidLowCardRowsError
+    e.message.should match(/lctables_spec_user_statuses/mi)
+    e.message.should match(/validation/mi)
+    e.message.should match(/gender/mi)
+    e.message.should match(/gender is not included in the list/mi)
+    e.message.should match(/amazing/mi)
+  end
+
+  it "should allow the associated table to validate low-card data" do
+    @user1.donation_level = 40
+    e = nil
+
+    begin
+      @user1.save!
+    rescue => x
+      e = x
+    end
+
+    e.should be
+    e.class.should == ::ActiveRecord::RecordInvalid
+    e.message.should match(/donation level/mi)
+    e.message.should match(/less than or equal to 10/mi)
+  end
+
+  it "should gracefully handle database-level rejection of a new low-card row" do
+    @user1.deleted = nil
+    e = nil
+
+    begin
+      @user1.save!
+    rescue => x
+      e = x
+    end
+
+    e.should be
+    e.class.should == LowCardTables::Errors::LowCardInvalidLowCardRowsError
+    e.message.should match(/lctables_spec_user_statuses/mi)
+    e.message.should match(/gender/mi)
+    e.message.should match(/nil/mi)
+    e.message.should match(/ActiveRecord::StatementInvalid/mi)
+  end
+end

data/spec/low_card_tables/unit/active_record/base_spec.rb

@@ -0,0 +1,53 @@
+require 'low_card_tables'
+
+describe LowCardTables::ActiveRecord::Base do
+  before :each do
+    @klass = Class.new
+    @klass.send(:include, LowCardTables::ActiveRecord::Base)
+  end
+
+  it "should include LowCardTables::LowCardTable::Base appropriately and respond to #is_low_card_table? appropriately" do
+    @klass.ancestors.include?(LowCardTables::LowCardTable::Base).should_not be
+    @klass.is_low_card_table?.should_not be
+
+    opts = Hash.new
+
+    @klass.is_low_card_table(opts)
+    @klass.is_low_card_table?.should be
+    @klass.ancestors.include?(LowCardTables::LowCardTable::Base).should be
+    @klass.low_card_options.should be(opts)
+
+    # ...and again:
+    opts = Hash.new
+
+    @klass.is_low_card_table(opts)
+    @klass.is_low_card_table?.should be
+    @klass.ancestors.include?(LowCardTables::LowCardTable::Base).should be
+    @klass.low_card_options.should be(opts)
+  end
+
+  it "should include LowCardTables::HasLowCardTable::Base appropriately and respond to #has_any_low_card_tables? appropriately" do
+    @klass.ancestors.include?(LowCardTables::HasLowCardTable::Base).should_not be
+    @klass.has_any_low_card_tables?.should_not be
+
+    name = :foo
+    opts = Hash.new
+
+    mock_associations_manager = double('LowCardAssociationsManager')
+    expect(mock_associations_manager).to receive(:has_low_card_table).with(name, opts).once
+    expect(LowCardTables::HasLowCardTable::LowCardAssociationsManager).to receive(:new).and_return(mock_associations_manager)
+
+    @klass.has_low_card_table(name, opts)
+    @klass.has_any_low_card_tables?.should be
+    @klass.ancestors.include?(LowCardTables::HasLowCardTable::Base).should be
+
+    name = :bar
+    opts = Hash.new
+
+    expect(mock_associations_manager).to receive(:has_low_card_table).with(name, opts).once
+
+    @klass.has_low_card_table(name, opts)
+    @klass.has_any_low_card_tables?.should be
+    @klass.ancestors.include?(LowCardTables::HasLowCardTable::Base).should be
+  end
+end

data/spec/low_card_tables/unit/active_record/migrations_spec.rb

@@ -0,0 +1,207 @@
+require 'low_card_tables'
+
+describe LowCardTables::ActiveRecord::Migrations do
+  class MockMigrationClass
+    attr_reader :calls
+
+    def initialize
+      @calls = [ ]
+    end
+
+    %w{add_column remove_column}.each do |method_name|
+      class_eval %{
+  def #{method_name}(*args)
+    record_call(:#{method_name}, args)
+  end}
+    end
+
+    %w{create_table change_table}.each do |method_name|
+      class_eval %{
+  def #{method_name}(*args, &block)
+    record_call(:#{method_name}, args, &block)
+    instance_eval(&block)
+  end}
+    end
+
+    private
+    def record_call(name, args, &block)
+      @calls << { :name => name, :args => args, :block => block }
+    end
+
+    include LowCardTables::ActiveRecord::Migrations
+  end
+
+  before :each do
+    @migration = MockMigrationClass.new
+    @opts = { }
+    @proc = lambda { |*args| }
+  end
+
+  it "should pass through correctly for :create_table" do
+    @migration.create_table(:foo, @opts, &@proc)
+    @migration.calls.should == [ { :name => :create_table, :args => [ :foo, @opts ], :block => @proc } ]
+  end
+
+  context "with mock ::Rails" do
+    before :each do
+      rails_class = Object.new
+      Object.send(:remove_const, :Rails) if Object.const_defined?(:Rails)
+      Object.const_set(:Rails, rails_class)
+
+      application = Object.new
+
+      expect(rails_class).to receive(:application).at_least(:once).and_return(application)
+      expect(application).to receive(:eager_load!).once
+    end
+
+    context "without mock low-card model" do
+      it "should create a temporary low-card model if :low_card => true" do
+        @opts[:low_card] = true
+
+        temp_class = Class.new
+        expect(Class).to receive(:new).once.with(::ActiveRecord::Base).and_return(temp_class).ordered
+        expect(temp_class).to receive(:table_name=).once.with(:foo).ordered
+        expect(temp_class).to receive(:is_low_card_table).once.with().ordered
+        expect(temp_class).to receive(:reset_column_information).once.ordered
+
+        expect(temp_class).to receive(:low_card_remove_unique_index!).once.ordered
+
+        expect(temp_class).to receive(:reset_column_information).at_least(2).times.ordered
+        expect(temp_class).to receive(:low_card_value_column_names).twice.ordered.and_return([ 'x', 'y' ])
+
+        expect(LowCardTables::VersionSupport).to receive(:clear_schema_cache!).once.ordered.with(temp_class)
+
+        expect(temp_class).to receive(:low_card_ensure_has_unique_index!).once.with(true).ordered
+
+        @migration.create_table(:foo, @opts, &@proc)
+        @migration.calls.should == [ { :name => :create_table, :args => [ :foo, { } ], :block => @proc } ]
+      end
+    end
+
+    context "with mock low-card model" do
+      before :each do
+        non_low_card_class = Object.new
+        @low_card_class = Object.new
+
+        expect(non_low_card_class).to receive(:table_name).and_return('bar')
+        expect(@low_card_class).to receive(:table_name).and_return('foo')
+
+        expect(@low_card_class).to receive(:is_low_card_table?).and_return(true)
+        expect(@low_card_class).to receive(:name).at_least(:once).and_return('Whatever')
+
+        expect(::ActiveRecord::Base).to receive(:descendants).and_return([ non_low_card_class, @low_card_class ])
+      end
+
+      %w{add_column remove_column create_table change_table}.each do |method_name|
+        context "#{method_name}" do
+          before :each do
+            @method = method_name.to_sym
+            @args = case @method
+            when :create_table then [ :foo, { :bar => :baz } ]
+            when :change_table then [ :foo ]
+            when :add_column then [ :foo, :bar, :integer, { :null => false } ]
+            when :remove_column then [ :foo, :bar ]
+            else raise "unknown method_name #{method_name.inspect}"
+            end
+
+            @proc = case @method
+            when :create_table, :change_table then lambda { |*args| }
+            else nil
+            end
+          end
+
+          def add_option(args, hash)
+            if args[-1].kind_of?(Hash)
+              args[-1].merge!(hash)
+            else
+              args << hash
+            end
+          end
+
+          def remove_low_card_options(args)
+            out = args.dup
+            if out[-1].kind_of?(Hash)
+              out[-1].delete_if { |k,v| k.to_s =~ /^low_card/ }
+              out.pop if out[-1].size == 0
+            end
+            out
+          end
+
+          it "should call #eager_load, pick up an AR descendant properly, and enforce the index" do
+            expect(@low_card_class).to receive(:low_card_remove_unique_index!).once.ordered
+
+            expect(@low_card_class).to receive(:reset_column_information).at_least(2).times.ordered
+            expect(@low_card_class).to receive(:low_card_value_column_names).twice.ordered.and_return([ 'x', 'y' ])
+
+            expect(LowCardTables::VersionSupport).to receive(:clear_schema_cache!).once.ordered.with(@low_card_class)
+
+            expect(@low_card_class).to receive(:low_card_ensure_has_unique_index!).once.with(true).ordered
+
+            @migration.send(@method, *@args, &@proc)
+            @migration.calls.should == [ { :name => @method, :args => @args, :block => @proc } ]
+          end
+
+          it "should not reinstitute the index if :low_card_collapse_rows => true" do
+            add_option(@args, :low_card_collapse_rows => false)
+
+            expect(@low_card_class).to receive(:low_card_remove_unique_index!).once.ordered
+
+            expect(@low_card_class).to receive(:reset_column_information).at_least(2).times.ordered
+            expect(@low_card_class).to receive(:low_card_value_column_names).twice.ordered.and_return([ 'x', 'y' ])
+
+            expect(LowCardTables::VersionSupport).to receive(:clear_schema_cache!).once.ordered.with(@low_card_class)
+
+            @migration.send(@method, *@args, &@proc)
+
+            expected_args = remove_low_card_options(@args)
+            @migration.calls.should == [ { :name => @method, :args => expected_args, :block => @proc } ]
+          end
+
+          it "should detect removed columns" do
+            add_option(@args, :low_card_foo => :bar)
+
+            expect(@low_card_class).to receive(:low_card_remove_unique_index!).once.ordered
+
+            expect(@low_card_class).to receive(:reset_column_information).at_least(2).times.ordered
+            expect(@low_card_class).to receive(:low_card_value_column_names).once.ordered.and_return([ 'x', 'y' ])
+
+            expect(LowCardTables::VersionSupport).to receive(:clear_schema_cache!).once.ordered.with(@low_card_class)
+
+            expect(@low_card_class).to receive(:low_card_value_column_names).once.ordered.and_return([ 'y' ])
+            expect(@low_card_class).to receive(:low_card_collapse_rows_and_update_referrers!).once.ordered.with(:low_card_foo => :bar)
+
+            expect(@low_card_class).to receive(:low_card_ensure_has_unique_index!).once.with(true).ordered
+
+            @migration.send(@method, *@args, &@proc)
+            expected_args = remove_low_card_options(@args)
+            @migration.calls.should == [ { :name => @method, :args => expected_args, :block => @proc } ]
+          end
+        end
+      end
+
+      it "should not do anything twice if calls are nested" do
+        @opts[:foo] = :bar
+
+        expect(@low_card_class).to receive(:low_card_remove_unique_index!).once.ordered
+
+        expect(@low_card_class).to receive(:reset_column_information).at_least(2).times.ordered
+        expect(@low_card_class).to receive(:low_card_value_column_names).twice.ordered.and_return([ 'x', 'y' ])
+
+        expect(LowCardTables::VersionSupport).to receive(:clear_schema_cache!).once.ordered.with(@low_card_class)
+
+        expect(@low_card_class).to receive(:low_card_ensure_has_unique_index!).once.with(true).ordered
+
+        inner_opts = { :a => :b, :low_card_foo => :bar }
+        @proc = lambda do |*args|
+          remove_column :bar, :baz, inner_opts
+        end
+
+        @migration.create_table(:foo, @opts, &@proc)
+        @migration.calls.should == [
+          { :name => :create_table, :args => [ :foo, { :foo => :bar } ], :block => @proc },
+          { :name => :remove_column, :args => [ :bar, :baz, { :a => :b } ], :block => nil }
+        ]
+      end
+    end
+  end
+end