low_card_tables 1.0.0

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

@@ -0,0 +1,207 @@
+require 'low_card_tables'
+
+describe LowCardTables::LowCardTable::Base do
+  before :each do
+    @test_class = Class.new
+    @test_class.send(:include, LowCardTables::LowCardTable::Base)
+  end
+
+  it "should make its recipient inherit the low-card policy from LowCardTables" do
+    LowCardTables.low_card_cache_expiration 20
+    @test_class.low_card_cache_expiration.should == 20
+
+    LowCardTables.low_card_cache_expiration 45
+    @test_class.low_card_cache_expiration.should == 45
+  end
+
+  context "with an instance" do
+    before :each do
+      @instance = @test_class.new
+    end
+
+    describe "row-matching" do
+      it "should match columns by hash-indexing, by default" do
+        expect(@instance).to receive(:[]).with('foo').twice.and_return(:bar)
+
+        @instance._low_card_column_matches?(:foo, :bar).should be
+        @instance._low_card_column_matches?(:foo, :baz).should_not be
+      end
+
+      it "should match a hash one-by-one, by calling through to _low_card_column_matches?" do
+        expect(@instance).to receive(:_low_card_column_matches?).with(:foo, :bar).and_return(true)
+        expect(@instance).to receive(:_low_card_column_matches?).with(:baz, :quux).and_return(true)
+
+        @instance._low_card_row_matches_hash?(:foo => :bar, :baz => :quux).should be
+      end
+
+      it "should not match a different hash, by calling through to _low_card_column_matches?" do
+        expect(@instance).to receive(:_low_card_column_matches?).with(:foo, :bar).and_return(false)
+
+        @instance._low_card_row_matches_hash?(:foo => :bar).should_not be
+      end
+
+      it "should always match if the hash contains nothing" do
+        @instance._low_card_row_matches_hash?({ }).should be
+      end
+
+      it "should match a set of hashes, by looking for one that matches, by calling through to _low_card_row_matches_hash?" do
+        h1 = { :foo => :bar, :bar => :baz }
+        h2 = { :a => :b, 'c' => 12345 }
+
+        expect(@instance).to receive(:_low_card_row_matches_hash?).with(h1).and_return(false)
+        expect(@instance).to receive(:_low_card_row_matches_hash?).with(h2).and_return(true)
+
+        @instance._low_card_row_matches_any_hash?([ h1, h2 ]).should be
+      end
+
+      it "should fail to match a set of hashes, by looking for one that matches, by calling through to _low_card_row_matches_hash?" do
+        h1 = { :foo => :bar, :bar => :baz }
+        h2 = { :a => :b, 'c' => 12345 }
+
+        expect(@instance).to receive(:_low_card_row_matches_hash?).with(h1).and_return(false)
+        expect(@instance).to receive(:_low_card_row_matches_hash?).with(h2).and_return(false)
+
+        @instance._low_card_row_matches_any_hash?([ h1, h2 ]).should_not be
+      end
+
+      it "should match blocks by calling them" do
+        block = double("block")
+
+        expect(block).to receive(:call).once.with(@instance).and_return(true)
+        @instance._low_card_row_matches_block?(block).should be
+
+        expect(block).to receive(:call).once.with(@instance).and_return(false)
+        @instance._low_card_row_matches_block?(block).should_not be
+      end
+    end
+  end
+
+  it "should save and return options properly" do
+    @test_class.is_low_card_table(:foo => :bar, :baz => :quux)
+    @test_class.low_card_options.should == { :foo => :bar, :baz => :quux }
+
+    @test_class.low_card_options = { :a => :b, :c => :d }
+    @test_class.low_card_options.should == { :a => :b, :c => :d }
+  end
+
+  it "should declare that it's a low-card table" do
+    @test_class.is_low_card_table?.should be
+  end
+
+  describe "row manager" do
+    it "should create a row manager of the right class, by default" do
+      rm = @test_class._low_card_row_manager
+      @test_class._low_card_row_manager.should be(rm)
+
+      rm.class.should == LowCardTables::LowCardTable::RowManager
+      rm.low_card_model.should be(@test_class)
+    end
+
+    it "should call through to the row manager on #reset_column_information" do
+      mod = Module.new
+      mod.module_eval do
+        def reset_column_information
+          @_reset_column_information_calls ||= 0
+          @_reset_column_information_calls += 1
+          :reset_column_information_return_value
+        end
+
+        def reset_column_information_calls
+          @_reset_column_information_calls
+        end
+      end
+
+      test_class = Class.new
+      test_class.send(:extend, mod)
+      test_class.send(:include, LowCardTables::LowCardTable::Base)
+
+      rm = double("row_manager")
+      allow(test_class).to receive(:_low_card_row_manager).and_return(rm)
+
+      expect(rm).to receive(:column_information_reset!).once
+
+      test_class.reset_column_information.should == :reset_column_information_return_value
+      test_class.reset_column_information_calls.should == 1
+    end
+
+    context "with a mock row manager" do
+      before :each do
+        @rm = double("row_manager")
+        allow(@test_class).to receive(:_low_card_row_manager).and_return(@rm)
+      end
+
+      %w{all_rows row_for_id rows_for_ids rows_matching ids_matching find_ids_for find_or_create_ids_for
+find_rows_for find_or_create_rows_for flush_cache! referring_models collapse_rows_and_update_referrers!
+value_column_names referred_to_by
+ensure_has_unique_index! remove_unique_index!}.each do |method_name|
+        it "should delegate to the row manager for #{method_name}" do
+          expect(@rm).to receive(method_name).once.with(:foo, :bar).and_return(:baz)
+          @test_class.send("low_card_#{method_name}", :foo, :bar).should == :baz
+        end
+      end
+    end
+  end
+
+  context "saving" do
+    before :each do
+      @save_mod = Module.new
+      @save_mod.module_eval do
+        def save(*args)
+          _saves_called << [ :save, args ]
+          :save_return_value
+        end
+
+        def save!(*args)
+          _saves_called << [ :save!, args ]
+          :save_return_value!
+        end
+
+        def _saves_called
+          @_saves_called ||= [ ]
+        end
+      end
+
+      # We need a new class -- because we need to make sure our module gets in there first
+      @test_class = Class.new
+      @test_class.send(:include, @save_mod)
+      @test_class.send(:include, LowCardTables::LowCardTable::Base)
+
+      @test_class.is_low_card_table
+      @test_class.is_low_card_table # ensure that calling it twice doesn't mess anything up
+
+      @instance = @test_class.new
+    end
+
+    it "should refuse to save, by default" do
+      lambda { @instance.save }.should raise_error(LowCardTables::Errors::LowCardCannotSaveAssociatedLowCardObjectsError)
+      @instance._saves_called.length.should == 0
+
+      lambda { @instance.save! }.should raise_error(LowCardTables::Errors::LowCardCannotSaveAssociatedLowCardObjectsError)
+      @instance._saves_called.length.should == 0
+    end
+
+    it "should save, if invoked via #save_low_card_row" do
+      @instance.save_low_card_row(:foo, :bar).should == :save_return_value
+      @instance._saves_called.should == [ [ :save, [ :foo, :bar ] ] ]
+    end
+
+    it "should save, if invoked via #save_low_card_row!" do
+      @instance.save_low_card_row!(:foo, :bar).should == :save_return_value!
+      @instance._saves_called.should == [ [ :save!, [ :foo, :bar ] ] ]
+    end
+
+    it "should not accidentally continue allowing saves if save! blows up" do
+      @save_mod.module_eval do
+        def save!(*args)
+          _saves_called << [ :save!, args ]
+          raise "kaboom"
+        end
+      end
+
+      lambda { @instance.save_low_card_row!(:foo, :bar) }.should raise_error(/kaboom/i)
+      @instance._saves_called.should == [ [ :save!, [ :foo, :bar ] ] ]
+
+      lambda { @instance.save! }.should raise_error(LowCardTables::Errors::LowCardCannotSaveAssociatedLowCardObjectsError)
+    end
+  end
+end

data/spec/low_card_tables/unit/low_card_table/cache_expiration/exponential_cache_expiration_policy_spec.rb

@@ -0,0 +1,128 @@
+require 'low_card_tables'
+require 'active_support/time'
+
+describe LowCardTables::LowCardTable::CacheExpiration::ExponentialCacheExpirationPolicy do
+  def klass
+    LowCardTables::LowCardTable::CacheExpiration::ExponentialCacheExpirationPolicy
+  end
+
+  it "should create itself with default values" do
+    instance = klass.new({ :start_time => Time.now })
+
+    instance.zero_floor.should == 3.minutes
+    instance.min_time.should == 10.seconds
+    instance.exponent.should == 2.0
+    instance.max_time.should == 1.hour
+  end
+
+  it "should prevent specifying invalid values" do
+    lambda { klass.new(:start_time => Time.now, :zero_floor_time => 'foo') }.should raise_error(ArgumentError, /zero_floor_time/i)
+    lambda { klass.new(:start_time => Time.now, :zero_floor_time => -1.0) }.should raise_error(ArgumentError, /zero_floor_time/i)
+
+    lambda { klass.new(:start_time => Time.now, :min_time => 'foo') }.should raise_error(ArgumentError, /min_time/i)
+    lambda { klass.new(:start_time => Time.now, :min_time => -1.0) }.should raise_error(ArgumentError, /min_time/i)
+    lambda { klass.new(:start_time => Time.now, :min_time => 0.0) }.should raise_error(ArgumentError, /min_time/i)
+    lambda { klass.new(:start_time => Time.now, :min_time => 1.0) }.should raise_error(ArgumentError, /min_time/i)
+
+    lambda { klass.new(:start_time => Time.now, :exponent => 'foo') }.should raise_error(ArgumentError, /exponent/i)
+    lambda { klass.new(:start_time => Time.now, :exponent => -1.0) }.should raise_error(ArgumentError, /exponent/i)
+    lambda { klass.new(:start_time => Time.now, :exponent => 0.0) }.should raise_error(ArgumentError, /exponent/i)
+    lambda { klass.new(:start_time => Time.now, :exponent => 1.0) }.should raise_error(ArgumentError, /exponent/i)
+
+    lambda { klass.new(:start_time => Time.now, :max_time => 'foo') }.should raise_error(ArgumentError, /max_time/i)
+    lambda { klass.new(:start_time => Time.now, :max_time => 0.0) }.should raise_error(ArgumentError, /max_time/i)
+    lambda { klass.new(:start_time => Time.now, :max_time => -1.0) }.should raise_error(ArgumentError, /max_time/i)
+    lambda { klass.new(:start_time => Time.now, :min_time => 3.0, :max_time => 2.0) }.should raise_error(ArgumentError, /max_time/i)
+  end
+
+  def with_instance(options = { })
+    @start_time = Time.now
+    @cache_read_at = @start_time
+    @instance = klass.new(options.merge(:start_time => @start_time))
+
+    yield
+  end
+
+  def refill!(time)
+    @cache_read_at = @start_time + time
+  end
+
+  def should_be_stale!(time)
+    @instance.stale?(@cache_read_at, @start_time + time).should be
+  end
+
+  def should_not_be_stale!(time)
+    @instance.stale?(@cache_read_at, @start_time + time).should_not be
+  end
+
+  it "should have a zero floor that's adjustable" do
+    with_instance(:zero_floor_time => 1.0) do
+      should_be_stale!(0.0)
+      should_be_stale!(0.5)
+      should_be_stale!(0.9)
+
+      refill!(1.0)
+      should_not_be_stale!(1.1)
+    end
+
+    with_instance(:zero_floor_time => 0.0) do
+      should_not_be_stale!(0.0)
+
+      refill!(0.5)
+      should_not_be_stale!(0.6)
+    end
+  end
+
+  it "should start an initial period of min_time seconds" do
+    with_instance(:zero_floor_time => 1.0, :min_time => 3.0) do
+      should_be_stale!(1.0)
+      refill!(1.0)
+
+      should_not_be_stale!(1.5)
+      should_not_be_stale!(3.0)
+      should_not_be_stale!(3.9)
+      should_be_stale!(4.1)
+    end
+  end
+
+  it "should exponentially increase according to the exponent" do
+    with_instance(:zero_floor_time => 1.0, :min_time => 3.0, :exponent => 1.5) do
+      # period 1: 1.0 - 4.0 seconds (3.0 duration)
+      refill!(1.0)
+      should_not_be_stale!(3.9)
+
+      # period 2: 4.0 - 8.5 seconds (4.5 duration)
+      refill!(4.0)
+      should_not_be_stale!(4.0)
+      should_not_be_stale!(7.0)
+      should_not_be_stale!(8.4)
+      should_be_stale!(8.5)
+
+      # period 3: 8.5 - 15.25 seconds (6.75 duration)
+      refill!(8.5)
+      should_not_be_stale!(8.5)
+      should_not_be_stale!(12.0)
+      should_not_be_stale!(15.0)
+      should_be_stale!(15.25)
+    end
+  end
+
+  it "should cap out at the max_time" do
+    with_instance(:zero_floor_time => 1.0, :min_time => 5.0, :exponent => 100.0, :max_time => 10.0) do
+      # zero floor: 0.0-1.0
+      # period 1: 1.0-6.0
+      # period 2: 6.0-16.0
+      refill!(6.0)
+
+      should_not_be_stale!(6.0)
+      should_not_be_stale!(15.9)
+      should_be_stale!(16.0)
+
+      # period 3: 16.0-26.0
+      refill!(16.0)
+      should_not_be_stale!(16.0)
+      should_not_be_stale!(25.9)
+      should_be_stale!(26.0)
+    end
+  end
+end

data/spec/low_card_tables/unit/low_card_table/cache_expiration/fixed_cache_expiration_policy_spec.rb

@@ -0,0 +1,25 @@
+require 'low_card_tables'
+
+describe LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy do
+  def klass
+    LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy
+  end
+
+  it "should require a non-negative expiration time" do
+    lambda { klass.new("foo") }.should raise_error(ArgumentError)
+    lambda { klass.new(-1.0) }.should raise_error(ArgumentError)
+  end
+
+  it "should expire at that time" do
+    i = klass.new(1.0)
+
+    i.expiration_time.should == 1.0
+
+    the_time = Time.now - rand(100_000)
+    i.stale?(the_time, the_time).should_not be
+    i.stale?(the_time, the_time + 0.5).should_not be
+    i.stale?(the_time, the_time + 0.99).should_not be
+    i.stale?(the_time, the_time + 1.0).should be
+    i.stale?(the_time, the_time + 15.0).should be
+  end
+end

data/spec/low_card_tables/unit/low_card_table/cache_expiration/has_cache_expiration_policy_spec.rb

@@ -0,0 +1,100 @@
+require 'low_card_tables'
+require 'active_support/time'
+
+describe LowCardTables::LowCardTable::CacheExpiration::HasCacheExpiration do
+  before :each do
+    @test_class = Class.new
+    @test_class.send(:include, LowCardTables::LowCardTable::CacheExpiration::HasCacheExpiration)
+  end
+
+  it "should default to no policy" do
+    @test_class.low_card_cache_expiration.should be_nil
+  end
+
+  it "should allow setting to a no-caching policy" do
+    @test_class.low_card_cache_expiration 0
+    @test_class.low_card_cache_expiration.should == 0
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::NoCachingExpirationPolicy
+  end
+
+  it "should allow setting to a fixed policy" do
+    @test_class.low_card_cache_expiration 15
+    @test_class.low_card_cache_expiration.should == 15
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy
+    @test_class.low_card_cache_expiration_policy_object.expiration_time.should == 15
+  end
+
+  it "should allow setting to an unlimited policy" do
+    @test_class.low_card_cache_expiration :unlimited
+    @test_class.low_card_cache_expiration.should == :unlimited
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::UnlimitedCacheExpirationPolicy
+  end
+
+  it "should allow setting to an exponential policy, with defaults" do
+    @test_class.low_card_cache_expiration :exponential
+    @test_class.low_card_cache_expiration.should == :exponential
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::ExponentialCacheExpirationPolicy
+    @test_class.low_card_cache_expiration_policy_object.zero_floor.should == 3.minutes
+    @test_class.low_card_cache_expiration_policy_object.min_time.should == 10.seconds
+    @test_class.low_card_cache_expiration_policy_object.exponent.should == 2.0
+    @test_class.low_card_cache_expiration_policy_object.max_time.should == 1.hour
+  end
+
+  it "should allow setting to an exponential policy, with overrides" do
+    @test_class.low_card_cache_expiration :exponential, :zero_floor_time => 2.0, :min_time => 3.0, :exponent => 4.0, :max_time => 5.0
+    @test_class.low_card_cache_expiration.should == [ :exponential, { :zero_floor_time => 2.0, :min_time => 3.0, :exponent => 4.0, :max_time => 5.0 } ]
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::ExponentialCacheExpirationPolicy
+    @test_class.low_card_cache_expiration_policy_object.zero_floor.should == 2.0
+    @test_class.low_card_cache_expiration_policy_object.min_time.should == 3.0
+    @test_class.low_card_cache_expiration_policy_object.exponent.should == 4.0
+    @test_class.low_card_cache_expiration_policy_object.max_time.should == 5.0
+  end
+
+  it "should allow changing the policy" do
+    @test_class.low_card_cache_expiration 15
+    @test_class.low_card_cache_expiration.should == 15
+    @test_class.low_card_cache_expiration :unlimited
+    @test_class.low_card_cache_expiration.should == :unlimited
+  end
+
+  it "should not change the policy if there's an exception" do
+    @test_class.low_card_cache_expiration 15
+    @test_class.low_card_cache_expiration.should == 15
+
+    lambda { @test_class.low_card_cache_expiration :exponential, :zero_floor_time => -10.0 }.should raise_error(ArgumentError)
+
+    @test_class.low_card_cache_expiration.should == 15
+  end
+
+  it "should fall back to the inherited class, if there is one" do
+    @parent_class = Class.new
+    @parent_class.send(:include, LowCardTables::LowCardTable::CacheExpiration::HasCacheExpiration)
+
+    @test_class.low_card_cache_policy_inherits_from(@parent_class)
+
+    @test_class.low_card_cache_expiration.should be_nil
+    @test_class.low_card_cache_expiration_policy_object.should be_nil
+
+    @parent_class.low_card_cache_expiration 15
+    @parent_class.low_card_cache_expiration.should == 15
+    @parent_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy
+    @parent_class.low_card_cache_expiration_policy_object.expiration_time.should == 15
+    @test_class.low_card_cache_expiration.should == 15
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy
+    @test_class.low_card_cache_expiration_policy_object.expiration_time.should == 15
+
+    @parent_class.low_card_cache_expiration :exponential
+    @test_class.low_card_cache_expiration.should == :exponential
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::ExponentialCacheExpirationPolicy
+
+    @test_class.low_card_cache_expiration 27
+    @test_class.low_card_cache_expiration.should == 27
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy
+    @test_class.low_card_cache_expiration_policy_object.expiration_time.should == 27
+
+    @parent_class.low_card_cache_expiration 105
+    @test_class.low_card_cache_expiration.should == 27
+    @test_class.low_card_cache_expiration_policy_object.class.should == LowCardTables::LowCardTable::CacheExpiration::FixedCacheExpirationPolicy
+    @test_class.low_card_cache_expiration_policy_object.expiration_time.should == 27
+  end
+end