acts_as_votable 0.10.0 → 0.11.0

data/lib/acts_as_votable/vote.rb

@@ -1,29 +1,27 @@
-require 'acts_as_votable/helpers/words'
+# frozen_string_literal: true
+
+require "acts_as_votable/helpers/words"
 
 module ActsAsVotable
   class Vote < ::ActiveRecord::Base
-
     include Helpers::Words
 
-    if ::ActiveRecord::VERSION::MAJOR < 4
+    if defined?(ProtectedAttributes)
       attr_accessible :votable_id, :votable_type,
         :voter_id, :voter_type,
         :votable, :voter,
         :vote_flag, :vote_scope
     end
 
-    belongs_to :votable, :polymorphic => true
-    belongs_to :voter, :polymorphic => true
+    belongs_to :votable, polymorphic: true
+    belongs_to :voter, polymorphic: true
 
-    scope :up, lambda{ where(:vote_flag => true) }
-    scope :down, lambda{ where(:vote_flag => false) }
-    scope :for_type, lambda{ |klass| where(:votable_type => klass) }
-    scope :by_type,  lambda{ |klass| where(:voter_type => klass) }
+    scope :up, -> { where(vote_flag: true) }
+    scope :down, -> { where(vote_flag: false) }
+    scope :for_type, ->(klass) { where(votable_type: klass.to_s) }
+    scope :by_type, ->(klass) { where(voter_type: klass.to_s) }
 
     validates_presence_of :votable_id
     validates_presence_of :voter_id
-
   end
-
 end
-

data/lib/acts_as_votable/voter.rb

@@ -1,24 +1,24 @@
+# frozen_string_literal: true
+
 module ActsAsVotable
   module Voter
-
     def self.included(base)
-
       # allow user to define these
       aliases = {
-        :vote_up_for    => [:likes, :upvotes, :up_votes],
-        :vote_down_for  => [:dislikes, :downvotes, :down_votes],
-        :unvote_for     => [:unlike, :undislike],
-        :voted_on?      => [:voted_for?],
-        :voted_up_on?   => [:voted_up_for?, :liked?],
-        :voted_down_on? => [:voted_down_for?, :disliked?],
-        :voted_as_when_voting_on => [:voted_as_when_voted_on, :voted_as_when_voting_for, :voted_as_when_voted_for],
-        :find_up_voted_items   => [:find_liked_items],
-        :find_down_voted_items => [:find_disliked_items]
+        vote_up_for: [:likes, :upvotes, :up_votes],
+        vote_down_for: [:dislikes, :downvotes, :down_votes],
+        unvote_for: [:unlike, :undislike],
+        voted_on?: [:voted_for?],
+        voted_up_on?: [:voted_up_for?, :liked?],
+        voted_down_on?: [:voted_down_for?, :disliked?],
+        voted_as_when_voting_on: [:voted_as_when_voted_on, :voted_as_when_voting_for, :voted_as_when_voted_for],
+        find_up_voted_items: [:find_liked_items],
+        find_down_voted_items: [:find_disliked_items]
       }
 
       base.class_eval do
 
-        has_many :votes, :class_name => 'ActsAsVotable::Vote', :as => :voter, :dependent => :destroy do
+        has_many :votes, class_name: "ActsAsVotable::Vote", as: :voter, dependent: :destroy do
           def votables
             includes(:votable).map(&:votable)
           end
@@ -31,74 +31,73 @@ module ActsAsVotable
         end
 
       end
-
     end
 
     # voting
-    def vote args
-      args[:votable].vote_by args.merge({:voter => self})
+    def vote(args)
+      args[:votable].vote_by args.merge(voter: self)
     end
 
-    def vote_up_for model=nil, args={}
-      vote :votable => model, :vote_scope => args[:vote_scope], :vote => true
+    def vote_up_for(model = nil, args = {})
+      vote votable: model, vote_scope: args[:vote_scope], vote: true
     end
 
-    def vote_down_for model=nil, args={}
-      vote :votable => model, :vote_scope => args[:vote_scope], :vote => false
+    def vote_down_for(model = nil, args = {})
+      vote votable: model, vote_scope: args[:vote_scope], vote: false
     end
 
-    def unvote_for model, args={}
-      model.unvote :voter => self, :vote_scope => args[:vote_scope]
+    def unvote_for(model, args = {})
+      model.unvote voter: self, vote_scope: args[:vote_scope]
     end
 
     # results
-    def voted_on? votable, args={}
-      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
-                         :vote_scope => args[:vote_scope])
+    def voted_on?(votable, args = {})
+      votes = find_votes(votable_id: votable.id, votable_type: votable.class.base_class.name,
+                         vote_scope: args[:vote_scope])
       votes.size > 0
     end
 
-    def voted_up_on? votable, args={}
-      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
-                         :vote_scope => args[:vote_scope], :vote_flag => true)
+    def voted_up_on?(votable, args = {})
+      votes = find_votes(votable_id: votable.id, votable_type: votable.class.base_class.name,
+                         vote_scope: args[:vote_scope], vote_flag: true)
       votes.size > 0
     end
 
-    def voted_down_on? votable, args={}
-      votes = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
-                         :vote_scope => args[:vote_scope], :vote_flag => false)
+    def voted_down_on?(votable, args = {})
+      votes = find_votes(votable_id: votable.id, votable_type: votable.class.base_class.name,
+                         vote_scope: args[:vote_scope], vote_flag: false)
       votes.size > 0
     end
 
-    def voted_as_when_voting_on votable, args={}
-      vote = find_votes(:votable_id => votable.id, :votable_type => votable.class.base_class.name,
-                         :vote_scope => args[:vote_scope]).select(:vote_flag).last
+    def voted_as_when_voting_on(votable, args = {})
+      vote = find_votes(votable_id: votable.id, votable_type: votable.class.base_class.name,
+                         vote_scope: args[:vote_scope]).select(:vote_flag).last
       return nil unless vote
       return vote.vote_flag
     end
 
-    def find_votes extra_conditions = {}
+    def find_votes(extra_conditions = {})
       votes.where(extra_conditions)
     end
 
-    def find_up_votes args={}
-      find_votes :vote_flag => true, :vote_scope => args[:vote_scope]
+    def find_up_votes(args = {})
+      find_votes vote_flag: true, vote_scope: args[:vote_scope]
     end
 
-    def find_down_votes args={}
-      find_votes :vote_flag => false, :vote_scope => args[:vote_scope]
+    def find_down_votes(args = {})
+      find_votes vote_flag: false, vote_scope: args[:vote_scope]
     end
 
-    def find_votes_for_class klass, extra_conditions = {}
-      find_votes extra_conditions.merge({:votable_type => klass.name})
+    def find_votes_for_class(klass, extra_conditions = {})
+      find_votes extra_conditions.merge(votable_type: klass.name)
     end
 
-    def find_up_votes_for_class klass, args={}
-      find_votes_for_class klass, :vote_flag => true, :vote_scope => args[:vote_scope]
+    def find_up_votes_for_class(klass, args = {})
+      find_votes_for_class klass, vote_flag: true, vote_scope: args[:vote_scope]
     end
 
-    def find_down_votes_for_class klass, args={}
-      find_votes_for_class klass, :vote_flag => false, :vote_scope => args[:vote_scope]
+    def find_down_votes_for_class(klass, args = {})
+      find_votes_for_class klass, vote_flag: false, vote_scope: args[:vote_scope]
     end
 
     # Including polymporphic relations for eager loading
@@ -106,28 +105,28 @@ module ActsAsVotable
       ActsAsVotable::Vote.includes(:votable)
     end
 
-    def find_voted_items extra_conditions = {}
-      options = extra_conditions.merge :voter_id => id, :voter_type => self.class.base_class.name
+    def find_voted_items(extra_conditions = {})
+      options = extra_conditions.merge voter_id: id, voter_type: self.class.base_class.name
       include_objects.where(options).collect(&:votable)
     end
 
-    def find_up_voted_items extra_conditions = {}
-      find_voted_items extra_conditions.merge(:vote_flag => true)
+    def find_up_voted_items(extra_conditions = {})
+      find_voted_items extra_conditions.merge(vote_flag: true)
     end
 
-    def find_down_voted_items extra_conditions = {}
-      find_voted_items extra_conditions.merge(:vote_flag => false)
+    def find_down_voted_items(extra_conditions = {})
+      find_voted_items extra_conditions.merge(vote_flag: false)
     end
 
-    def get_voted klass, extra_conditions = {}
+    def get_voted(klass, extra_conditions = {})
       klass.joins(:votes_for).merge find_votes(extra_conditions)
     end
 
-    def get_up_voted klass
+    def get_up_voted(klass)
       klass.joins(:votes_for).merge find_up_votes
     end
 
-    def get_down_voted klass
+    def get_down_voted(klass)
       klass.joins(:votes_for).merge find_down_votes
     end
   end

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,34 @@ 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.rb", "db/migrate/acts_as_votable_migration.rb", migration_version: migration_version
+      end
+    end
+
+
+    private
+
+    def migration_version
+      if rails5?
+        "[4.2]"
       end
     end
+
+    def rails5?
+      Rails.version.start_with? "5"
+    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
+
+FactoryGirl.define do
+  factory :votable do
+  end
+end

data/spec/factories/votable_cache.rb

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

data/spec/factories/votable_cache_update_attributes.rb

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

data/spec/factories/votable_cache_update_columns.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryGirl.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
+
+FactoryGirl.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
+
+FactoryGirl.define do
+  factory :child_of_sti_votable do
+  end
+end

data/spec/factories/votable_voter.rb

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

data/spec/factories/vote.rb

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

data/spec/factories/voter.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+FactoryGirl.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,506 @@
+# 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 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
+
+    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_attributes" do
+          let(:votable_cache) { create(:votable_cache_update_attributes, 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_not eq updated_at
+          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 eq updated_at
+          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