acts_as_votable 0.10.0 → 0.13.0

data/lib/generators/acts_as_votable/migration/migration_generator.rb

@@ -1,4 +1,6 @@
-require 'rails/generators/migration'
+# frozen_string_literal: true
+
+require "rails/generators/migration"
 
 module ActsAsVotable
   class MigrationGenerator < Rails::Generators::Base
@@ -11,21 +13,40 @@ module ActsAsVotable
     end
 
     def self.source_root
-      File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+      File.join(File.dirname(__FILE__), "templates", (orm.to_s unless orm.class.eql?(String)))
     end
 
     def self.orm_has_migration?
       [:active_record].include? orm
     end
 
-    def self.next_migration_number(path)
+    def self.next_migration_number(_path)
       Time.now.utc.strftime("%Y%m%d%H%M%S")
     end
 
     def create_migration_file
       if self.class.orm_has_migration?
-        migration_template 'migration.rb', 'db/migrate/acts_as_votable_migration.rb'
+        migration_template "migration.erb", "db/migrate/acts_as_votable_migration.rb", migration_version: migration_version
+      end
+    end
+
+
+    private
+
+    def migration_version
+      if rails5?
+        "[4.2]"
+      elsif rails6?
+        "[6.0]"
       end
     end
+
+    def rails5?
+      Rails.version.start_with? "5"
+    end
+
+    def rails6?
+      Rails.version.start_with? "6"
+    end
   end
 end

data/lib/generators/acts_as_votable/migration/templates/active_record/{migration.rb → migration.erb}

@@ -1,4 +1,4 @@
-class ActsAsVotableMigration < ActiveRecord::Migration
+class ActsAsVotableMigration < ActiveRecord::Migration<%= migration_version %>
   def self.up
     create_table :votes do |t|
 
@@ -12,11 +12,6 @@ class ActsAsVotableMigration < ActiveRecord::Migration
       t.timestamps
     end
 
-    if ActiveRecord::VERSION::MAJOR < 4
-      add_index :votes, [:votable_id, :votable_type]
-      add_index :votes, [:voter_id, :voter_type]
-    end
-
     add_index :votes, [:voter_id, :voter_type, :vote_scope]
     add_index :votes, [:votable_id, :votable_type, :vote_scope]
   end

data/spec/factories/votable.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :votable do
+  end
+end

data/spec/factories/votable_cache.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :votable_cache do
+  end
+end

data/spec/factories/votable_cache_update_attributes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :votable_cache_update do
+  end
+end

data/spec/factories/votable_cache_update_columns.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :votable_cache_update_columns do
+  end
+end

data/spec/factories/votable_child_of_sti_not_votable.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :child_of_sti_not_votable do
+  end
+end

data/spec/factories/votable_child_of_sti_votable.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :child_of_sti_votable do
+  end
+end

data/spec/factories/votable_voter.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :votable_voter do
+  end
+end

data/spec/factories/vote.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :vote, class: ActsAsVotable::Vote do
+  end
+end

data/spec/factories/voter.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :voter do
+  end
+end

data/spec/generators/active_record_generator_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "acts_as_votable"
+require "spec_helper"
+
+require "rails/generators"
+require "generators/acts_as_votable/migration/migration_generator"
+
+module ActsAsVotable
+  describe MigrationGenerator do
+    pending
+  end
+end

data/spec/shared_example/votable_model.rb

@@ -0,0 +1,542 @@
+# frozen_string_literal: true
+
+shared_examples "a votable_model" do
+  it "should return false when a vote with no voter is saved" do
+    expect(votable.vote_by).to be false
+  end
+
+  it "should have one vote when saved" do
+    votable.vote_by voter: voter, vote: "yes"
+    expect(votable.votes_for.size).to eq(1)
+  end
+
+  it "should have one vote when voted on twice by the same person" do
+    votable.vote_by voter: voter, vote: "yes"
+    votable.vote_by voter: voter, vote: "no"
+    expect(votable.votes_for.size).to eq(1)
+  end
+
+  it "should have two votes_for when voted on twice by the same person with duplicate paramenter" do
+    votable.vote_by voter: voter, vote: "yes"
+    votable.vote_by voter: voter, vote: "no", duplicate: true
+    expect(votable.votes_for.size).to eq(2)
+  end
+
+  it "should have one scoped vote when voting under an scope" do
+    votable.vote_by voter: voter, vote: "yes", vote_scope: "rank"
+    expect(votable.find_votes_for(vote_scope: "rank").size).to eq(1)
+  end
+
+  it "should have one vote when voted on twice using scope by the same person" do
+    votable.vote_by voter: voter, vote: "yes", vote_scope: "rank"
+    votable.vote_by voter: voter, vote: "no", vote_scope: "rank"
+    expect(votable.find_votes_for(vote_scope: "rank").size).to eq(1)
+  end
+
+  it "should have two votes_for when voting on two different scopes by the same person" do
+    votable.vote_by voter: voter, vote: "yes", vote_scope: "weekly_rank"
+    votable.vote_by voter: voter, vote: "no", vote_scope: "monthly_rank"
+    expect(votable.votes_for.size).to eq(2)
+  end
+
+  it "should be callable with vote_up" do
+    votable.vote_up voter
+    expect(votable.get_up_votes.first.voter).to eq(voter)
+  end
+
+  it "should be callable with vote_down" do
+    votable.vote_down voter
+    expect(votable.get_down_votes.first.voter).to eq(voter)
+  end
+
+  it "should have 2 votes_for when voted on once by two different people" do
+    votable.vote_by voter: voter
+    votable.vote_by voter: voter2
+    expect(votable.votes_for.size).to eq(2)
+  end
+
+  it "should have one true vote" do
+    votable.vote_by voter: voter
+    votable.vote_by voter: voter2, vote: "dislike"
+    expect(votable.get_up_votes.size).to eq(1)
+  end
+
+  it "should have 2 false votes_for" do
+    votable.vote_by voter: voter, vote: "no"
+    votable.vote_by voter: voter2, vote: "dislike"
+    expect(votable.get_down_votes.size).to eq(2)
+  end
+
+  it "should have been voted on by voter2" do
+    votable.vote_by voter: voter2, vote: true
+    expect(votable.find_votes_for.first.voter.id).to be voter2.id
+  end
+
+  it "should count the vote as registered if this is the voters first vote" do
+    votable.vote_by voter: voter
+    expect(votable.vote_registered?).to be true
+  end
+
+  it "should not count the vote as being registered if that voter has already voted and the vote has not changed" do
+    votable.vote_by voter: voter, vote: true
+    votable.vote_by voter: voter, vote: "yes"
+    expect(votable.vote_registered?).to be false
+  end
+
+  it "should count the vote as registered if the voter has voted and the vote flag has changed" do
+    votable.vote_by voter: voter, vote: true
+    votable.vote_by voter: voter, vote: "dislike"
+    expect(votable.vote_registered?).to be true
+  end
+
+  it "should count the vote as registered if the voter has voted and the vote weight has changed" do
+    votable.vote_by voter: voter, vote: true, vote_weight: 1
+    votable.vote_by voter: voter, vote: true, vote_weight: 2
+    expect(votable.vote_registered?).to be true
+  end
+
+  it "should be voted on by voter" do
+    votable.vote_by voter: voter
+    expect(votable.voted_on_by?(voter)).to be true
+  end
+
+  it "should be able to unvote a voter" do
+    votable.liked_by(voter)
+    votable.unliked_by(voter)
+    expect(votable.voted_on_by?(voter)).to be false
+  end
+
+  it "should be voted up by a voter" do
+    votable.liked_by voter
+    expect(votable.voted_up_by?(voter)).to be true
+  end
+
+  it "should be voted down by a voter" do
+    votable.disliked_by voter
+    expect(votable.voted_down_by?(voter)).to be true
+  end
+
+  it "should unvote a positive vote" do
+    votable.vote_by voter: voter
+    votable.unvote voter: voter
+    expect(votable.find_votes_for.count).to eq(0)
+  end
+
+  it "should set the votable to unregistered after unvoting" do
+    votable.vote_by voter: voter
+    votable.unvote voter: voter
+    expect(votable.vote_registered?).to be false
+  end
+
+  it "should unvote a negative vote" do
+    votable.vote_by voter: voter, vote: "no"
+    votable.unvote voter: voter
+    expect(votable.find_votes_for.count).to eq(0)
+  end
+
+  it "should unvote only the from a single voter" do
+    votable.vote_by voter: voter
+    votable.vote_by voter: voter2
+    votable.unvote voter: voter
+    expect(votable.find_votes_for.count).to eq(1)
+  end
+
+  it "should be contained to instances" do
+    votable2 = build(:votable, name: "2nd votable")
+    votable2.save
+
+    votable.vote_by voter: voter, vote: false
+    votable2.vote_by voter: voter, vote: true
+    votable2.vote_by voter: voter, vote: true
+
+    expect(votable.vote_registered?).to be true
+    expect(votable2.vote_registered?).to be false
+  end
+
+  it "should set default vote weight to 1 if not specified" do
+    votable.upvote_by voter
+    expect(votable.find_votes_for.first.vote_weight).to eq(1)
+  end
+
+  describe "with cached votes_for" do
+    let!(:voter)         { create(:voter, name: "i can vote!") }
+    let!(:votable)       { create(:votable, name: "a voting model without a cache") }
+    let!(:votable_cache) { create(:votable_cache, name: "voting model with cache") }
+
+    it "should not update cached votes_for if there are no columns" do
+      votable.vote_by voter: voter
+    end
+
+    it "should update cached total votes_for if there is a total column" do
+      votable_cache.cached_votes_total = 50
+      votable_cache.vote_by voter: voter
+      expect(votable_cache.cached_votes_total).to eq(1)
+    end
+
+    describe "with ActiveRecord::StaleObjectError" do
+      it "should rollback vote up if cache update fails" do
+        votable_cache.cached_votes_total = 50
+        expect(votable_cache)
+          .to(receive(:update_cached_votes)
+          .and_raise(ActiveRecord::StaleObjectError.new(votable_cache, "update")))
+
+        expect { votable_cache.vote_by voter: voter }.to raise_error ActiveRecord::StaleObjectError
+        expect(votable_cache.cached_votes_total).to eq(50)
+        expect(votable_cache.voted_on_by?(voter)).to be false
+      end
+
+      it "should rollback unvote if cache update fails" do
+        votable_cache.vote_by voter: voter, vote: "true"
+
+        expect(votable_cache)
+          .to(receive(:update_cached_votes)
+          .and_raise(ActiveRecord::StaleObjectError.new(votable_cache, "update")))
+
+        expect { votable_cache.unvote voter: voter }.to raise_error ActiveRecord::StaleObjectError
+
+        expect(votable_cache.cached_votes_total).to eq(1)
+        expect(votable_cache.voted_on_by?(voter)).to be true
+      end
+    end
+
+    it "should update cached total votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true"
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_votes_total).to eq(0)
+    end
+
+    it "should update cached total votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_votes_total).to eq(0)
+    end
+
+    it "should update cached score votes_for if there is a score column" do
+      votable_cache.cached_votes_score = 50
+      votable_cache.vote_by voter: voter
+      expect(votable_cache.cached_votes_score).to eq(1)
+      votable_cache.vote_by voter: voter2, vote: "false"
+      expect(votable_cache.cached_votes_score).to eq(0)
+      votable_cache.vote_by voter: voter, vote: "false"
+      expect(votable_cache.cached_votes_score).to eq(-2)
+    end
+
+    it "should update cached score votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true"
+      expect(votable_cache.cached_votes_score).to eq(1)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_votes_score).to eq(0)
+    end
+
+    it "should update cached score votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      expect(votable_cache.cached_votes_score).to eq(-1)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_votes_score).to eq(0)
+    end
+
+    it "should update cached weighted total if there is a weighted total column" do
+      votable_cache.cached_weighted_total = 50
+      votable_cache.vote_by voter: voter
+      expect(votable_cache.cached_weighted_total).to eq(1)
+      votable_cache.vote_by voter: voter2, vote: "false"
+      expect(votable_cache.cached_weighted_total).to eq(2)
+    end
+
+    it "should update cached weighted total votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_weight: 3
+      expect(votable_cache.cached_weighted_total).to eq(3)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_weighted_total).to eq(0)
+    end
+
+    it "should update cached weighted total votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_weight: 4
+      expect(votable_cache.cached_weighted_total).to eq(4)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_weighted_total).to eq(0)
+    end
+
+    it "should update cached weighted score if there is a weighted score column" do
+      votable_cache.cached_weighted_score = 50
+      votable_cache.vote_by voter: voter, vote_weight: 3
+      expect(votable_cache.cached_weighted_score).to eq(3)
+      votable_cache.vote_by voter: voter2, vote: "false", vote_weight: 5
+      expect(votable_cache.cached_weighted_score).to eq(-2)
+      # voter changes her vote from 3 to 5
+      votable_cache.vote_by voter: voter, vote_weight: 5
+      expect(votable_cache.cached_weighted_score).to eq(0)
+      votable_cache.vote_by voter: voter3, vote_weight: 4
+      expect(votable_cache.cached_weighted_score).to eq(4)
+    end
+
+    it "should update cached weighted score votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_weight: 3
+      expect(votable_cache.cached_weighted_score).to eq(3)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_weighted_score).to eq(0)
+    end
+
+    it "should update cached weighted score votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_weight: 4
+      expect(votable_cache.cached_weighted_score).to eq(-4)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_weighted_score).to eq(0)
+    end
+
+    it "should update cached weighted average if there is a weighted average column" do
+      votable_cache.cached_weighted_average = 50.0
+      votable_cache.vote_by voter: voter, vote: "true", vote_weight: 5
+      expect(votable_cache.cached_weighted_average).to eq(5.0)
+      votable_cache.vote_by voter: voter2, vote: "true", vote_weight: 3
+      expect(votable_cache.cached_weighted_average).to eq(4.0)
+      # voter changes her vote from 5 to 4
+      votable_cache.vote_by voter: voter, vote: "true", vote_weight: 4
+      expect(votable_cache.cached_weighted_average).to eq(3.5)
+      votable_cache.vote_by voter: voter3, vote: "true", vote_weight: 5
+      expect(votable_cache.cached_weighted_average).to eq(4.0)
+    end
+
+    it "should update cached weighted average votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_weight: 5
+      votable_cache.vote_by voter: voter2, vote: "true", vote_weight: 3
+      expect(votable_cache.cached_weighted_average).to eq(4)
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_weighted_average).to eq(3)
+    end
+
+    it "should update cached up votes_for if there is an up vote column" do
+      votable_cache.cached_votes_up = 50
+      votable_cache.vote_by voter: voter
+      votable_cache.vote_by voter: voter
+      expect(votable_cache.cached_votes_up).to eq(1)
+    end
+
+    it "should update cached down votes_for if there is a down vote column" do
+      votable_cache.cached_votes_down = 50
+      votable_cache.vote_by voter: voter, vote: "false"
+      expect(votable_cache.cached_votes_down).to eq(1)
+    end
+
+    it "should update cached up votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true"
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_votes_up).to eq(0)
+    end
+
+    it "should update cached down votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.unvote voter: voter
+      expect(votable_cache.cached_votes_down).to eq(0)
+    end
+
+    it "should select from cached total votes_for if there a total column" do
+      votable_cache.vote_by voter: voter
+      votable_cache.cached_votes_total = 50
+      expect(votable_cache.count_votes_total).to eq(50)
+    end
+
+    it "should select from cached up votes_for if there is an up vote column" do
+      votable_cache.vote_by voter: voter
+      votable_cache.cached_votes_up = 50
+      expect(votable_cache.count_votes_up).to eq(50)
+    end
+
+    it "should select from cached down votes_for if there is a down vote column" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.cached_votes_down = 50
+      expect(votable_cache.count_votes_down).to eq(50)
+    end
+
+    it "should select from cached votes score if there is a votes score column" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.cached_votes_score = 50
+      expect(votable_cache.count_votes_score).to eq(50)
+    end
+
+    it "should select from cached weighted total if there is a weighted total column" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.cached_weighted_total = 50
+      expect(votable_cache.weighted_total).to eq(50)
+    end
+
+    it "should select from cached weighted score if there is a weighted score column" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.cached_weighted_score = 50
+      expect(votable_cache.weighted_score).to eq(50)
+    end
+
+    it "should select from cached weighted average if there is a weighted average column" do
+      votable_cache.vote_by voter: voter, vote: "false"
+      votable_cache.cached_weighted_average = 50
+      expect(votable_cache.weighted_average).to eq(50)
+    end
+
+    it "should update cached total votes_for when voting under an scope" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "rank"
+      expect(votable_cache.cached_votes_total).to eq(1)
+    end
+
+    it "should update cached up votes_for when voting under an scope" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "rank"
+      expect(votable_cache.cached_votes_up).to eq(1)
+    end
+
+    it "should update cached total votes_for when a scoped vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "rank"
+      votable_cache.unvote voter: voter, vote_scope: "rank"
+      expect(votable_cache.cached_votes_total).to eq(0)
+    end
+
+    it "should update cached up votes_for when a scoped vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "rank"
+      votable_cache.unvote voter: voter, vote_scope: "rank"
+      expect(votable_cache.cached_votes_up).to eq(0)
+    end
+
+    it "should update cached down votes_for when downvoting under a scope" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "rank"
+      expect(votable_cache.cached_votes_down).to eq(1)
+    end
+
+    it "should update cached down votes_for when a scoped vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "rank"
+      votable_cache.unvote voter: voter, vote_scope: "rank"
+      expect(votable_cache.cached_votes_down).to eq(0)
+    end
+
+    describe "with acts_as_votable_options" do
+      describe "cacheable_strategy" do
+        let(:updated_at) { 3.days.ago }
+
+        before { votable_cache.vote_by voter: voter }
+
+        context "update" do
+          let(:votable_cache) { create(:votable_cache_update, name: "voting model with cache", updated_at: updated_at) }
+
+          it do
+            expect(votable_cache.cached_votes_total).to eq(1)
+            expect(votable_cache.updated_at.to_i).to_not eq updated_at.to_i
+          end
+        end
+
+        context "update_columns" do
+          let(:votable_cache) { create(:votable_cache_update_columns, name: "voting model with cache", updated_at: updated_at) }
+
+          it do
+            expect(votable_cache.cached_votes_total).to eq(1)
+            expect(votable_cache.updated_at.to_i).to eq updated_at.to_i
+          end
+        end
+      end
+    end
+  end
+
+  describe "with scoped cached votes_for" do
+
+    it "should update cached total votes_for if there is a total column" do
+      votable_cache.cached_scoped_test_votes_total = 50
+      votable_cache.vote_by voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_total).to eq(1)
+    end
+
+    it "should update cached total votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "test"
+      votable_cache.unvote voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_total).to eq(0)
+    end
+
+    it "should update cached total votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "test"
+      votable_cache.unvote voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_total).to eq(0)
+    end
+
+    it "should update cached score votes_for if there is a score column" do
+      votable_cache.cached_scoped_test_votes_score = 50
+      votable_cache.vote_by voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(1)
+      votable_cache.vote_by voter: voter2, vote: "false", vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(0)
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(-2)
+    end
+
+    it "should update cached score votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(1)
+      votable_cache.unvote voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(0)
+    end
+
+    it "should update cached score votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(-1)
+      votable_cache.unvote voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_score).to eq(0)
+    end
+
+    it "should update cached up votes_for if there is an up vote column" do
+      votable_cache.cached_scoped_test_votes_up = 50
+      votable_cache.vote_by voter: voter, vote_scope: "test"
+      votable_cache.vote_by voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_up).to eq(1)
+    end
+
+    it "should update cached down votes_for if there is a down vote column" do
+      votable_cache.cached_scoped_test_votes_down = 50
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_down).to eq(1)
+    end
+
+    it "should update cached up votes_for when a vote up is removed" do
+      votable_cache.vote_by voter: voter, vote: "true", vote_scope: "test"
+      votable_cache.unvote voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_up).to eq(0)
+    end
+
+    it "should update cached down votes_for when a vote down is removed" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "test"
+      votable_cache.unvote voter: voter, vote_scope: "test"
+      expect(votable_cache.cached_scoped_test_votes_down).to eq(0)
+    end
+
+    it "should select from cached total votes_for if there a total column" do
+      votable_cache.vote_by voter: voter, vote_scope: "test"
+      votable_cache.cached_scoped_test_votes_total = 50
+      expect(votable_cache.count_votes_total(false, "test")).to eq(50)
+    end
+
+    it "should select from cached up votes_for if there is an up vote column" do
+      votable_cache.vote_by voter: voter, vote_scope: "test"
+      votable_cache.cached_scoped_test_votes_up = 50
+      expect(votable_cache.count_votes_up(false, "test")).to eq(50)
+    end
+
+    it "should select from cached down votes_for if there is a down vote column" do
+      votable_cache.vote_by voter: voter, vote: "false", vote_scope: "test"
+      votable_cache.cached_scoped_test_votes_down = 50
+      expect(votable_cache.count_votes_down(false, "test")).to eq(50)
+    end
+
+  end
+
+  describe "sti models" do
+    let(:child_sti_not_votable) { create(:child_of_sti_not_votable, name: "sti child") }
+    let(:child_sti_votable)     { create(:child_of_sti_votable, name: "sti child") }
+
+    it "should be able to vote on a votable child of a non votable sti model" do
+      child_sti_not_votable.vote_by voter: voter, vote: "yes"
+      expect(child_sti_not_votable.votes_for.size).to eq(1)
+    end
+
+    it "should not be able to vote on a parent non votable" do
+      expect(StiNotVotable).not_to be_votable
+    end
+
+    it "should be able to vote on a child when its parent is votable" do
+      child_sti_votable.vote_by voter: voter, vote: "yes"
+      expect(child_sti_votable.votes_for.size).to eq(1)
+    end
+  end
+end