counter-cache 0.0.1

data/lib/counter/cache/options_parser.rb

@@ -0,0 +1,69 @@
+module Counter
+  module Cache
+    class OptionsParser < Struct.new(:options)
+      def worker_adapter
+        options[:worker_adapter] || Counter::Cache.configuration.default_worker_adapter
+      end
+
+      def source_object_class_name
+        options[:source_object_class_name]
+      end
+
+      def column
+        options[:column]
+      end
+
+      def relation
+        options[:relation]
+      end
+
+      def relation_class_name
+        options[:relation_class_name]
+      end
+
+      def relation_id
+        options[:relation_id]
+      end
+
+      def method
+        options[:method]
+      end
+
+      def cached?
+        option_or_true options[:cache]
+      end
+
+      def recalculation?
+        option_or_true options[:recalculation]
+      end
+
+      def polymorphic?
+        options[:polymorphic]
+      end
+
+      def if_value
+        options[:if]
+      end
+
+      def wait(source_object)
+        wait = options[:wait]
+        if wait.respond_to?(:call)
+          wait.call(source_object)
+        else
+          wait
+        end
+      end
+
+      def recalculation_delay
+        options[:recalculation_delay] || Counter::Cache.configuration.recalculation_delay
+      end
+
+      protected
+
+      def option_or_true(val)
+        val || val.nil?
+      end
+
+    end
+  end
+end

data/lib/counter/cache/redis.rb

@@ -0,0 +1,40 @@
+module Counter
+  module Cache
+    class Redis
+      def incr(key)
+        with_redis do |redis|
+          redis.incr key
+        end
+      end
+
+      def decr(key)
+        with_redis do |redis|
+          redis.decr(key)
+        end
+      end
+
+      def get(key)
+        with_redis do |redis|
+          redis.get(key)
+        end
+      end
+
+      def del(key)
+        with_redis do |redis|
+          redis.del(key)
+        end
+      end
+
+      private
+
+      def with_redis
+        redis_pool = Counter::Cache.configuration.redis_pool
+        return yield redis_pool unless redis_pool.respond_to?(:with)
+
+        redis_pool.with do |redis|
+          yield redis
+        end
+      end
+    end
+  end
+end

data/lib/counter/cache/version.rb

@@ -0,0 +1,5 @@
+module Counter
+  module Cache
+    VERSION = "0.0.1"
+  end
+end

data/spec/features/counter_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+require 'support/models'
+require 'support/worker_adapter'
+require 'fakeredis'
+
+RSpec.describe "Counting" do
+
+  before do
+    ActiveRecord::Base.silence { CreateModelsForTest.migrate(:up) }
+    Counter::Cache.configure do |c|
+      c.redis_pool = Redis.new
+      c.default_worker_adapter = TestWorkerAdapter.new
+    end
+  end
+
+  after do
+    ActiveRecord::Base.silence { CreateModelsForTest.migrate(:down) }
+  end
+
+  let(:user) { User.create }
+
+  describe '#posts_count' do
+    it 'increments' do
+      expect {
+        user.posts.create
+      }.to change { user.reload.posts_count }.by(1)
+    end
+
+    it 'decrements' do
+      post = user.posts.create
+      expect {
+        post.destroy
+      }.to change { user.reload.posts_count }.by(-1)
+    end
+  end
+
+  describe '#posts_ar_count' do
+    it 'increments' do
+      expect {
+        user.posts.create
+      }.to change { user.reload.posts_ar_count }.by(1)
+    end
+
+    it 'decrements' do
+      post = user.posts.create
+      expect {
+        post.destroy
+      }.to change { user.reload.posts_ar_count }.by(-1)
+    end
+  end
+
+  describe '#polymorphic followers_count' do
+    let(:follower_user) { User.create }
+    it 'increments' do
+      expect {
+        Follow.create(user: follower_user, followee: user)
+      }.to change { user.reload.followers_count }.by(1)
+    end
+
+    it 'decrements' do
+      follow = Follow.create(user: follower_user, followee: user)
+      expect {
+        follow.destroy
+      }.to change { user.reload.followers_count }.by(-1)
+    end
+  end
+
+  describe '#users_i_follow_count' do
+    let(:follower_user) { User.create }
+
+    it 'increments' do
+      expect {
+        Follow.create(user: follower_user, followee: user)
+      }.to change { follower_user.reload.users_i_follow_count }.by(1)
+    end
+
+    it 'decrements' do
+      follow = Follow.create(user: follower_user, followee: user)
+      expect {
+        follow.destroy
+      }.to change { follower_user.reload.users_i_follow_count }.by(-1)
+    end
+  end
+
+  describe '#bogus_followed_count' do
+    let(:follower_user) { User.create }
+
+    it 'eventually recalculates' do
+      expect(user.reload.bogus_followed_count).to_not eq(101)
+      Follow.create(user: follower_user, followee: user)
+      expect(user.reload.bogus_followed_count).to eq(101)
+    end
+  end
+end
+

data/spec/lib/counter/cache/active_record_updater_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe Counter::Cache::ActiveRecordUpdater do
+  let(:counter_class) { double }
+  let(:counter) { double }
+  let(:options) { { counter_class: counter_class } }
+  subject { Counter::Cache::ActiveRecordUpdater.new(options) }
+
+  let(:record) { double }
+
+  describe "#after_create" do
+    it "Calls update on counter instance" do
+      expect(counter).to receive(:update).with(:incr)
+      expect(counter_class).to receive(:new).with(record, options).and_return(counter)
+      subject.after_create(record)
+    end
+  end
+
+  describe "#after_destroy" do
+    it "Calls update on counter instance" do
+      expect(counter).to receive(:update).with(:decr)
+      expect(counter_class).to receive(:new).with(record, options).and_return(counter)
+      subject.after_destroy(record)
+    end
+  end
+end

data/spec/lib/counter/cache/buffer_counter/enqueuer_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe Counter::Cache::Counters::BufferCounter::Enqueuer do
+  let(:worker_adapter) { double }
+  let(:options) { double(worker_adapter: worker_adapter,
+                         wait: 10,
+                         column: "boo",
+                         method: "calculate_boo",
+                         cached?: true,
+                         recalculation?: false,
+                         recalculation_delay: 20) }
+
+  let(:source_object_class_name) { "BooUser" }
+  let(:relation_id) { 1 }
+  let(:relation_type) { "Boo" }
+
+  let(:enqueuer) { Counter::Cache::Counters::BufferCounter::Enqueuer.new(options, source_object_class_name, relation_id, relation_type, "SuperCounter") }
+
+  describe '#enqueue' do
+    before do
+      expect(worker_adapter).to receive(:enqueue).with(10,
+                                                       "BooUser",
+                                                       { relation_class_name: "Boo",
+                                                         relation_id: 1,
+                                                         column: "boo",
+                                                         method: "calculate_boo",
+                                                         cache: true,
+                                                         counter: "SuperCounter" })
+    end
+
+    describe 'when recalculation is true' do
+      before do
+        expect(options).to receive(:recalculation?).and_return(true)
+      end
+
+      it "enqueues two jobs" do
+        expect(worker_adapter).to receive(:enqueue).with(20,
+                                                         "BooUser",
+                                                         { relation_class_name: "Boo",
+                                                           relation_id: 1,
+                                                           column: "boo",
+                                                           method: "calculate_boo",
+                                                           cache: false,
+                                                           counter: "SuperCounter" })
+        enqueuer.enqueue!(double)
+      end
+    end
+
+    it 'enqueues one job' do
+      enqueuer.enqueue!(double)
+    end
+  end
+end

data/spec/lib/counter/cache/buffer_counter/key_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe Counter::Cache::Counters::BufferCounter::Key do
+  let(:options) { double(relation_class_name: "Boo", relation: "boo", column: "boos_count", relation_id: nil) }
+  let(:source_object) { double(boo_id: 1) }
+  let(:key) { Counter::Cache::Counters::BufferCounter::Key.new(source_object, options) }
+
+  describe '#to_s' do
+    it 'returns the key with the class, id, and column' do
+      expect(key.to_s).to eq("cc:Bo:1:boos")
+    end
+  end
+end

data/spec/lib/counter/cache/buffer_counter/relation_finder_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe Counter::Cache::Counters::BufferCounter::RelationFinder do
+  let(:options) { double }
+  let(:source_object) { double }
+  let(:finder) { Counter::Cache::Counters::BufferCounter::RelationFinder.new(source_object, options) }
+
+  describe '#relation_class' do
+    context 'when relation_class_name is present' do
+      let(:options) { double(relation_class_name: "Boo") }
+
+      it 'returns the relation_class_name' do
+        expect(finder.relation_class).to eq("Boo")
+      end
+    end
+
+    context 'when polymorphic?' do
+      let(:options) { double(polymorphic?: true, relation: "boo", relation_class_name: nil) }
+      let(:source_object) { double(boo_type: "Boo") }
+
+      it 'asks for the type' do
+        expect(finder.relation_class).to eq("Boo")
+      end
+    end
+
+    context 'no relation_class_name or polymorphic' do
+      let(:options) { double(relation_class_name: nil, polymorphic?: false, relation: "boo") }
+
+      before do
+        reflection = double
+        expect(reflection).to receive_message_chain("class_name.to_s.camelize") { "Boo" }
+        expect(source_object).to receive(:reflections).and_return({:boo => reflection})
+      end
+
+      it 'asks active record for the class name' do
+        expect(finder.relation_class).to eq("Boo")
+      end
+    end
+  end
+
+  describe '#relation_id' do
+    let(:options) { double(relation: "boo", relation_id: nil) }
+    let(:source_object) { double(boo_id: 123) }
+
+    it 'calls relation_id on the source object' do
+      expect(finder.relation_id).to eq(123)
+    end
+  end
+end

data/spec/lib/counter/cache/buffer_counter/saver_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe Counter::Cache::Counters::BufferCounter::Saver do
+  class Boo
+  end
+
+  let(:relation_object) { double(boo_count: 2) }
+  let(:options) { double(relation_class_name: "Boo", relation_id: 1, column: "boo_count", method: nil, source_object_class_name: Boo) }
+  let(:saver) { Counter::Cache::Counters::BufferCounter::Saver.new(options) }
+
+  describe '#save!' do
+    let(:counting_store) { double(get: nil) }
+
+    before do
+      allow(Boo).to receive(:find_by_id).and_return(relation_object)
+      allow(Counter::Cache.configuration).to receive(:counting_data_store).and_return(counting_store)
+    end
+
+    describe "yielding" do
+      let(:counting_store) { double(get: 2) }
+
+      before do
+        allow(options).to receive(:cached?).and_return(true)
+        expect(relation_object).to receive(:boo_count=).with(4)
+        expect(relation_object).to receive(:save!)
+        expect(counting_store).to receive(:del)
+      end
+
+      describe "with block" do
+        it "yields" do
+          expect { |b| saver.save!(&b) }.to yield_with_args(2, 4, relation_object, "boo_count")
+        end
+      end
+    end
+
+    describe 'when cached? is true' do
+      let(:counting_store) { double(get: 2) }
+
+      before do
+        allow(options).to receive(:cached?).and_return(true)
+        expect(counting_store).to receive(:del)
+      end
+
+      it 'saves the value' do
+        expect(relation_object).to receive(:boo_count=).with(4)
+        expect(relation_object).to receive(:save!)
+        saver.save!
+      end
+    end
+
+    describe 'when cached? is false' do
+      before do
+        allow(options).to receive(:cached?).and_return(false)
+      end
+
+      describe 'when method is passed' do
+        before do
+          allow(options).to receive(:method).and_return("call_this_thing")
+          allow(relation_object).to receive(:call_this_thing).and_return(4)
+        end
+
+        it 'saves the value' do
+          expect(relation_object).to receive(:boo_count=).with(4)
+          expect(relation_object).to receive(:save!)
+          saver.save!
+        end
+      end
+
+      describe 'when method is not passed' do
+
+        before do
+          allow(Boo).to receive(:table_name).and_return("boos")
+          allow(relation_object).to receive(:boos).and_return(double(count: 4))
+        end
+
+        it 'saves the value' do
+          expect(relation_object).to receive(:boo_count=).with(4)
+          expect(relation_object).to receive(:save!)
+          saver.save!
+        end
+      end
+    end
+  end
+end

data/spec/lib/counter/cache/buffer_counter/updater_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+RSpec.describe Counter::Cache::Counters::BufferCounter::Updater do
+  let(:options) { double(relation: "boo", relation_class_name: "Boo", column: "boo", relation_id: nil) }
+  let(:source_object) { double(boo_id: 1) }
+  let(:updater) { Counter::Cache::Counters::BufferCounter::Updater.new(source_object, options, "Hello") }
+
+  describe "#update" do
+    describe "when valid" do
+      it "sends direction and enqueues" do
+        expect(updater).to receive(:valid?) { true }
+        expect(updater).to receive(:decr) { true }
+        expect(updater).to receive(:enqueue) { true }
+        updater.update!(:decr)
+      end
+    end
+
+    describe "when invalid" do
+      it "sends direction and enqueues" do
+        expect(updater).to receive(:valid?) { false }
+        expect(updater).to receive(:decr).never
+        expect(updater).to receive(:enqueue).never
+        updater.update!(:decr)
+      end
+    end
+  end
+
+  describe "#enqueue" do
+    it 'constructs and calls enqueue! on the enqueue' do
+      expect(Counter::Cache::Counters::BufferCounter::Enqueuer).to receive(:new).with(options,
+                                                                                      source_object.class.name,
+                                                                                      1,
+                                                                                      "Boo",
+                                                                                      "Hello")
+                                                                                .and_return(double(enqueue!: true))
+      updater.send(:enqueue)
+    end
+  end
+
+  describe "#decr" do
+    it 'calls decr on the redis instance' do
+      expect_any_instance_of(Counter::Cache::Redis).to receive(:decr)
+      updater.send(:decr)
+    end
+  end
+
+  describe "#incr" do
+    it 'calls decr on the redis instance' do
+      expect_any_instance_of(Counter::Cache::Redis).to receive(:incr)
+      updater.send(:incr)
+    end
+  end
+
+  describe "valid?" do
+    describe "With no if value" do
+      let(:options) { double(relation: "boo", if_value: nil, relation_id: nil) }
+
+      describe 'with relation_id' do
+        let(:source_object) { double(boo_id: 123) }
+
+        it 'returns true' do
+          expect(updater.send(:valid?)).to eq(true)
+        end
+      end
+
+      describe 'without relation_id' do
+        let(:source_object) { double(boo_id: nil) }
+
+        it 'returns false' do
+          expect(updater.send(:valid?)).to eq(false)
+        end
+      end
+    end
+
+    describe "With if object" do
+      let(:source_object) { double(boo_id: 123) }
+      let(:options) { double(relation: "boo", if_value: if_value, relation_id: nil) }
+
+      describe 'if value returns false' do
+        let(:if_value) { double(call: true) }
+
+        it 'returns true' do
+          expect(updater.send(:valid?)).to eq(true)
+        end
+      end
+
+      describe 'if value returns true' do
+        let(:if_value) { double(call: false) }
+
+        it 'returns false' do
+          expect(updater.send(:valid?)).to eq(false)
+        end
+      end
+    end
+  end
+end