acts_as_votable 0.5.0 → 0.9.0

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'sqlite3'
 require 'acts_as_votable'
 
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
 ActiveRecord::Schema.define(:version => 1) do
@@ -10,6 +13,7 @@ ActiveRecord::Schema.define(:version => 1) do
 
     t.boolean :vote_flag
     t.string :vote_scope
+    t.integer :vote_weight
 
     t.timestamps
   end
@@ -31,6 +35,10 @@ ActiveRecord::Schema.define(:version => 1) do
     t.string :name
   end
 
+  create_table :votable_voters do |t|
+    t.string :name
+  end
+
   create_table :sti_votables do |t|
     t.string :name
     t.string :type
@@ -51,6 +59,13 @@ ActiveRecord::Schema.define(:version => 1) do
     t.integer :cached_votes_score
     t.integer :cached_votes_up
     t.integer :cached_votes_down
+    t.integer :cached_weighted_score
+
+    t.integer :cached_scoped_test_votes_total
+    t.integer :cached_scoped_test_votes_score
+    t.integer :cached_scoped_test_votes_up
+    t.integer :cached_scoped_test_votes_down
+    t.integer :cached_scoped_weighted_score
   end
 
 end
@@ -69,6 +84,11 @@ class Votable < ActiveRecord::Base
   validates_presence_of :name
 end
 
+class VotableVoter < ActiveRecord::Base
+  acts_as_votable
+  acts_as_voter
+end
+
 class StiVotable < ActiveRecord::Base
   acts_as_votable
 end

data/spec/votable_spec.rb

@@ -2,11 +2,6 @@ require 'acts_as_votable'
 require 'spec_helper'
 
 describe ActsAsVotable::Votable do
-
-  before(:each) do
-    clean_database
-  end
-
   it "should not be votable" do
     NotVotable.should_not be_votable
   end
@@ -15,277 +10,11 @@ describe ActsAsVotable::Votable do
     Votable.should be_votable
   end
 
-  describe "voting on a votable object" do
-
-    before(:each) do
-      clean_database
-      @voter = Voter.new(:name => 'i can vote!')
-      @voter.save
-
-      @voter2 = Voter.new(:name => 'a new person')
-      @voter2.save
-
-      @votable = Votable.new(:name => 'a voting model')
-      @votable.save
-    end
-
-    it "should return false when a vote with no voter is saved" do
-      @votable.vote.should be false
-    end
-
-    it "should have one vote when saved" do
-      @votable.vote :voter => @voter, :vote => 'yes'
-      @votable.votes.size.should == 1
-    end
-
-    it "should have one vote when voted on twice by the same person" do
-      @votable.vote :voter => @voter, :vote => 'yes'
-      @votable.vote :voter => @voter, :vote => 'no'
-      @votable.votes.size.should == 1
-    end
-
-    it "should have one scoped vote when voting under an scope" do
-      @votable.vote :voter => @voter, :vote => 'yes', :vote_scope => 'rank'
-      @votable.find_votes(:vote_scope => 'rank').size.should == 1
-    end
-
-    it "should have one vote when voted on twice using scope by the same person" do
-      @votable.vote :voter => @voter, :vote => 'yes', :vote_scope => 'rank'
-      @votable.vote :voter => @voter, :vote => 'no', :vote_scope => 'rank'
-      @votable.find_votes(:vote_scope => 'rank').size.should == 1
-    end
-
-    it "should have two votes when voting on two different scopes by the same person" do
-      @votable.vote :voter => @voter, :vote => 'yes', :vote_scope => 'weekly_rank'
-      @votable.vote :voter => @voter, :vote => 'no', :vote_scope => 'monthly_rank'
-      @votable.votes.size.should == 2
-    end
-
-    it "should be callable with vote_up" do
-      @votable.vote_up @voter
-      @votable.up_votes.first.voter.should == @voter
-    end
-
-    it "should be callable with vote_down" do
-      @votable.vote_down @voter
-      @votable.down_votes.first.voter.should == @voter
-    end
-
-    it "should have 2 votes when voted on once by two different people" do
-      @votable.vote :voter => @voter
-      @votable.vote :voter => @voter2
-      @votable.votes.size.should == 2
-    end
-
-    it "should have one true vote" do
-      @votable.vote :voter => @voter
-      @votable.vote :voter => @voter2, :vote => 'dislike'
-      @votable.up_votes.size.should == 1
-    end
-
-    it "should have 2 false votes" do
-      @votable.vote :voter => @voter, :vote => 'no'
-      @votable.vote :voter => @voter2, :vote => 'dislike'
-      @votable.down_votes.size.should == 2
-    end
-
-    it "should have been voted on by voter2" do
-      @votable.vote :voter => @voter2, :vote => true
-      @votable.find_votes.first.voter.id.should be @voter2.id
-    end
-
-    it "should count the vote as registered if this is the voters first vote" do
-      @votable.vote :voter => @voter
-      @votable.vote_registered?.should 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 :voter => @voter, :vote => true
-      @votable.vote :voter => @voter, :vote => 'yes'
-      @votable.vote_registered?.should be false
-    end
-
-    it "should count the vote as registered if the voter has voted and the vote has changed" do
-      @votable.vote :voter => @voter, :vote => true
-      @votable.vote :voter => @voter, :vote => 'dislike'
-      @votable.vote_registered?.should be true
-    end
-
-    it "should be voted on by voter" do
-      @votable.vote :voter => @voter
-      @votable.voted_on_by?(@voter).should be true
-    end
-
-    it "should unvote a positive vote" do
-      @votable.vote :voter => @voter
-      @votable.unvote :voter => @voter
-      @votable.find_votes.count.should == 0
-    end
-
-    it "should set the votable to unregistered after unvoting" do
-      @votable.vote :voter => @voter
-      @votable.unvote :voter => @voter
-      @votable.vote_registered?.should be false
-    end
-
-    it "should unvote a negative vote" do
-      @votable.vote :voter => @voter, :vote => 'no'
-      @votable.unvote :voter => @voter
-      @votable.find_votes.count.should == 0
-    end
-
-    it "should unvote only the from a single voter" do
-      @votable.vote :voter => @voter
-      @votable.vote :voter => @voter2
-      @votable.unvote :voter => @voter
-      @votable.find_votes.count.should == 1
-    end
-
-    it "should be contained to instances" do
-      votable2 = Votable.new(:name => '2nd votable')
-      votable2.save
-
-      @votable.vote :voter => @voter, :vote => false
-      votable2.vote :voter => @voter, :vote => true
-      votable2.vote :voter => @voter, :vote => true
-
-      @votable.vote_registered?.should be true
-      votable2.vote_registered?.should be false
-    end
-
-    describe "with cached votes" do
-
-      before(:each) do
-        clean_database
-        @voter = Voter.new(:name => 'i can vote!')
-        @voter.save
-
-        @votable = Votable.new(:name => 'a voting model without a cache')
-        @votable.save
-
-        @votable_cache = VotableCache.new(:name => 'voting model with cache')
-        @votable_cache.save
-      end
-
-      it "should not update cached votes if there are no columns" do
-        @votable.vote :voter => @voter
-      end
-
-      it "should update cached total votes if there is a total column" do
-        @votable_cache.cached_votes_total = 50
-        @votable_cache.vote :voter => @voter
-        @votable_cache.cached_votes_total.should == 1
-      end
-
-      it "should update cached total votes when a vote up is removed" do
-        @votable_cache.vote :voter => @voter, :vote => 'true'
-        @votable_cache.unvote :voter => @voter
-        @votable_cache.cached_votes_total.should == 0
-      end
-
-      it "should update cached total votes when a vote down is removed" do
-        @votable_cache.vote :voter => @voter, :vote => 'false'
-        @votable_cache.unvote :voter => @voter
-        @votable_cache.cached_votes_total.should == 0
-      end
-
-      it "should update cached score votes if there is a score column" do
-        @votable_cache.cached_votes_score = 50
-        @votable_cache.vote :voter => @voter
-        @votable_cache.cached_votes_score.should == 1
-        @votable_cache.vote :voter => @voter2, :vote => 'false'
-        @votable_cache.cached_votes_score.should == 0
-        @votable_cache.vote :voter => @voter, :vote => 'false'
-        @votable_cache.cached_votes_score.should == -2
-      end
-
-      it "should update cached score votes when a vote up is removed" do
-        @votable_cache.vote :voter => @voter, :vote => 'true'
-        @votable_cache.cached_votes_score.should == 1
-        @votable_cache.unvote :voter => @voter
-        @votable_cache.cached_votes_score.should == 0
-      end
-
-      it "should update cached score votes when a vote down is removed" do
-        @votable_cache.vote :voter => @voter, :vote => 'false'
-        @votable_cache.cached_votes_score.should == -1
-        @votable_cache.unvote :voter => @voter
-        @votable_cache.cached_votes_score.should == 0
-      end
-
-      it "should update cached up votes if there is an up vote column" do
-        @votable_cache.cached_votes_up = 50
-        @votable_cache.vote :voter => @voter
-        @votable_cache.vote :voter => @voter
-        @votable_cache.cached_votes_up.should == 1
-      end
-
-      it "should update cached down votes if there is a down vote column" do
-        @votable_cache.cached_votes_down = 50
-        @votable_cache.vote :voter => @voter, :vote => 'false'
-        @votable_cache.cached_votes_down.should == 1
-      end
-
-      it "should update cached up votes when a vote up is removed" do
-        @votable_cache.vote :voter => @voter, :vote => 'true'
-        @votable_cache.unvote :voter => @voter
-        @votable_cache.cached_votes_up.should == 0
-      end
-
-      it "should update cached down votes when a vote down is removed" do
-        @votable_cache.vote :voter => @voter, :vote => 'false'
-        @votable_cache.unvote :voter => @voter
-        @votable_cache.cached_votes_down.should == 0
-      end
-
-      it "should select from cached total votes if there a total column" do
-        @votable_cache.vote :voter => @voter
-        @votable_cache.cached_votes_total = 50
-        @votable_cache.count_votes_total.should == 50
-      end
-
-      it "should select from cached up votes if there is an up vote column" do
-        @votable_cache.vote :voter => @voter
-        @votable_cache.cached_votes_up = 50
-        @votable_cache.count_votes_up.should == 50
-      end
-
-      it "should select from cached down votes if there is a down vote column" do
-        @votable_cache.vote :voter => @voter, :vote => 'false'
-        @votable_cache.cached_votes_down = 50
-        @votable_cache.count_votes_down.should == 50
-      end
-
-    end
-
-    describe "sti models" do
-
-      before(:each) do
-        clean_database
-        @voter = Voter.create(:name => 'i can vote!')
-      end
-
-      it "should be able to vote on a votable child of a non votable sti model" do
-        votable = VotableChildOfStiNotVotable.create(:name => 'sti child')
-
-        votable.vote :voter => @voter, :vote => 'yes'
-        votable.votes.size.should == 1
-      end
-
-      it "should not be able to vote on a parent non votable" do
-        StiNotVotable.should_not be_votable
-      end
-
-      it "should be able to vote on a child when its parent is votable" do
-        votable = ChildOfStiVotable.create(:name => 'sti child')
-
-        votable.vote :voter => @voter, :vote => 'yes'
-        votable.votes.size.should == 1
-      end
-
-    end
-
+  it_behaves_like "a votable_model" do
+    # TODO Replace with factories
+    let (:voter) { Voter.create(:name =>'i can vote!') }
+    let (:voter2) { Voter.create(:name => 'a new person') }
+    let (:votable) { Votable.create(:name =>'a voting model') }
+    let (:votable_cache) { VotableCache.create(:name => 'voting model with cache') }
   end
-
-
 end

data/spec/votable_voter_spec.rb

@@ -0,0 +1,20 @@
+require 'acts_as_votable'
+require 'spec_helper'
+
+describe VotableVoter do
+  it_behaves_like "a votable_model" do
+    # TODO Replace with factories
+    let (:voter) { VotableVoter.create(:name => 'i can vote!') }
+    let (:voter2) { VotableVoter.create(:name => 'a new person') }
+    let (:votable) { VotableVoter.create(:name => 'a voting model') }
+    let (:votable_cache) { VotableCache.create(:name => 'voting model with cache') }
+  end
+
+  it_behaves_like "a voter_model" do
+    # TODO Replace with factories
+    let (:voter) { VotableVoter.create(:name => 'i can vote!') }
+    let (:voter2) { VotableVoter.create(:name => 'a new person') }
+    let (:votable) { VotableVoter.create(:name => 'a voting model') }
+    let (:votable2) { VotableVoter.create(:name => 'a 2nd voting model') }
+  end
+end

data/spec/voter_spec.rb

@@ -3,10 +3,6 @@ require 'spec_helper'
 
 describe ActsAsVotable::Voter do
 
-  before(:each) do
-    clean_database
-  end
-
   it "should not be a voter" do
     NotVotable.should_not be_votable
   end
@@ -15,290 +11,11 @@ describe ActsAsVotable::Voter do
     Votable.should be_votable
   end
 
-  describe "voting by a voter" do
-
-    before(:each) do
-      clean_database
-      @voter = Voter.new(:name => 'i can vote!')
-      @voter.save
-
-      @voter2 = Voter.new(:name => 'a new person')
-      @voter2.save
-
-      @votable = Votable.new(:name => 'a voting model')
-      @votable.save
-
-      @votable2 = Votable.new(:name => 'a 2nd voting model')
-      @votable2.save
-    end
-
-    it "should be voted on after a voter has voted" do
-      @votable.vote :voter => @voter
-      @voter.voted_on?(@votable).should be true
-    end
-
-    it "should not be voted on if a voter has not voted" do
-      @voter.voted_on?(@votable).should be false
-    end
-
-    it "should be voted on after a voter has voted under scope" do
-      @votable.vote :voter => @voter, :vote_scope => 'rank'
-      @voter.voted_on?(@votable, :vote_scope => 'rank').should be true
-    end
-
-    it "should not be voted on other scope after a voter has voted under one scope" do
-      @votable.vote :voter => @voter, :vote_scope => 'rank'
-      @voter.voted_on?(@votable).should be false
-    end
-
-    it "should be voted as true when a voter has voted true" do
-      @votable.vote :voter => @voter
-      @voter.voted_as_when_voted_for(@votable).should be true
-    end
-
-    it "should be voted as true when a voter has voted true under scope" do
-      @votable.vote :voter => @voter, :vote_scope => 'rank'
-      @voter.voted_as_when_voted_for(@votable, :vote_scope => 'rank').should be true
-    end
-
-    it "should be voted as false when a voter has voted false" do
-      @votable.vote :voter => @voter, :vote => false
-      @voter.voted_as_when_voted_for(@votable).should be false
-    end
-
-    it "should be voted as false when a voter has voted false under scope" do
-      @votable.vote :voter => @voter, :vote => false, :vote_scope => 'rank'
-      @voter.voted_as_when_voted_for(@votable, :vote_scope => 'rank').should be false
-    end
-
-    it "should be voted as nil when a voter has never voted" do
-      @voter.voted_as_when_voting_on(@votable).should be nil
-    end
-
-    it "should be voted as nil when a voter has never voted under the scope" do
-      @votable.vote :voter => @voter, :vote => false, :vote_scope => 'rank'
-      @voter.voted_as_when_voting_on(@votable).should be nil
-    end
-
-    it "should return true if voter has voted true" do
-      @votable.vote :voter => @voter
-      @voter.voted_up_on?(@votable).should be true
-    end
-
-    it "should return false if voter has not voted true" do
-      @votable.vote :voter => @voter, :vote => false
-      @voter.voted_up_on?(@votable).should be false
-    end
-
-    it "should return true if the voter has voted false" do
-      @votable.vote :voter => @voter, :vote => false
-      @voter.voted_down_on?(@votable).should be true
-    end
-
-    it "should return false if the voter has not voted false" do
-      @votable.vote :voter => @voter, :vote => true
-      @voter.voted_down_on?(@votable).should be false
-    end
-
-    it "should provide reserve functionality, voter can vote on votable" do
-      @voter.vote :votable => @votable, :vote => 'bad'
-      @voter.voted_as_when_voting_on(@votable).should be false
-    end
-
-    it "should allow the voter to vote up a model" do
-      @voter.vote_up_for @votable
-      @votable.up_votes.first.voter.should == @voter
-      @votable.votes.up.first.voter.should == @voter
-    end
-
-    it "should allow the voter to vote down a model" do
-      @voter.vote_down_for @votable
-      @votable.down_votes.first.voter.should == @voter
-      @votable.votes.down.first.voter.should == @voter
-    end
-
-    it "should allow the voter to unvote a model" do
-      @voter.vote_up_for @votable
-      @voter.unvote_for @votable
-      @votable.find_votes.size.should == 0
-      @votable.votes.count.should == 0
-    end
-
-    it "should get all of the voters votes" do
-      @voter.vote_up_for @votable
-      @voter.find_votes.size.should == 1
-      @voter.votes.up.count.should == 1
-    end
-
-    it "should get all of the voters up votes" do
-      @voter.vote_up_for @votable
-      @voter.find_up_votes.size.should == 1
-      @voter.votes.up.count.should == 1
-    end
-
-    it "should get all of the voters down votes" do
-      @voter.vote_down_for @votable
-      @voter.find_down_votes.size.should == 1
-      @voter.votes.down.count.should == 1
-    end
-
-    it "should get all of the votes votes for a class" do
-      @votable.vote :voter => @voter
-      @votable2.vote :voter => @voter, :vote => false
-      @voter.find_votes_for_class(Votable).size.should == 2
-      @voter.votes.for_type(Votable).count.should == 2
-    end
-
-    it "should get all of the voters up votes for a class" do
-      @votable.vote :voter => @voter
-      @votable2.vote :voter => @voter, :vote => false
-      @voter.find_up_votes_for_class(Votable).size.should == 1
-      @voter.votes.up.for_type(Votable).count.should == 1
-    end
-
-    it "should get all of the voters down votes for a class" do
-      @votable.vote :voter => @voter
-      @votable2.vote :voter => @voter, :vote => false
-      @voter.find_down_votes_for_class(Votable).size.should == 1
-      @voter.votes.down.for_type(Votable).count.should == 1
-    end
-
-    it "should be contained to instances" do
-      @voter.vote :votable => @votable, :vote => false
-      @voter2.vote :votable => @votable
-
-      @voter.voted_as_when_voting_on(@votable).should be false
-    end
-
-    describe '#find_voted_items' do
-      it 'returns objects that a user has upvoted for' do
-        @votable.vote :voter => @voter
-        @votable2.vote :voter => @voter2
-        @voter.find_voted_items.should include @votable
-        @voter.find_voted_items.size.should == 1
-      end
-
-      it 'returns objects that a user has upvoted for, using scope' do
-        @votable.vote :voter => @voter, :vote_scope => 'rank'
-        @votable2.vote :voter => @voter2, :vote_scope => 'rank'
-        @voter.find_voted_items(:vote_scope => 'rank').should include @votable
-        @voter.find_voted_items(:vote_scope => 'rank').size.should == 1
-      end
-
-      it 'returns objects that a user has downvoted for' do
-        @votable.vote_down @voter
-        @votable2.vote_down @voter2
-        @voter.find_voted_items.should include @votable
-        @voter.find_voted_items.size.should == 1
-      end
-
-      it 'returns objects that a user has downvoted for, using scope' do
-        @votable.vote_down @voter, :vote_scope => 'rank'
-        @votable2.vote_down @voter2, :vote_scope => 'rank'
-        @voter.find_voted_items(:vote_scope => 'rank').should include @votable
-        @voter.find_voted_items(:vote_scope => 'rank').size.should == 1
-      end
-    end
-
-    describe '#find_up_voted_items' do
-      it 'returns objects that a user has upvoted for' do
-        @votable.vote :voter => @voter
-        @votable2.vote :voter => @voter2
-        @voter.find_up_voted_items.should include @votable
-        @voter.find_up_voted_items.size.should == 1
-      end
-
-      it 'returns objects that a user has upvoted for, using scope' do
-        @votable.vote :voter => @voter, :vote_scope => 'rank'
-        @votable2.vote :voter => @voter2, :vote_scope => 'rank'
-        @voter.find_up_voted_items(:vote_scope => 'rank').should include @votable
-        @voter.find_up_voted_items(:vote_scope => 'rank').size.should == 1
-      end
-
-      it 'does not return objects that a user has downvoted for' do
-        @votable.vote_down @voter
-        @voter.find_up_voted_items.size.should == 0
-      end
-
-      it 'does not return objects that a user has downvoted for, using scope' do
-        @votable.vote_down @voter, :vote_scope => 'rank'
-        @voter.find_up_voted_items(:vote_scope => 'rank').size.should == 0
-      end
-    end
-
-    describe '#find_down_voted_items' do
-      it 'does not return objects that a user has upvoted for' do
-        @votable.vote :voter => @voter
-        @voter.find_down_voted_items.size.should == 0
-      end
-
-      it 'does not return objects that a user has upvoted for, using scope' do
-        @votable.vote :voter => @voter, :vote_scope => 'rank'
-        @voter.find_down_voted_items(:vote_scope => 'rank').size.should == 0
-      end
-
-      it 'returns objects that a user has downvoted for' do
-        @votable.vote_down @voter
-        @votable2.vote_down @voter2
-        @voter.find_down_voted_items.should include @votable
-        @voter.find_down_voted_items.size.should == 1
-      end
-
-      it 'returns objects that a user has downvoted for, using scope' do
-        @votable.vote_down @voter, :vote_scope => 'rank'
-        @votable2.vote_down @voter2, :vote_scope => 'rank'
-        @voter.find_down_voted_items(:vote_scope => 'rank').should include @votable
-        @voter.find_down_voted_items(:vote_scope => 'rank').size.should == 1
-      end
-
-   end
-
-    describe '#get_voted' do
-      subject { @voter.get_voted(@votable.class) }
-
-      it 'returns objects of a class that a voter has voted for' do
-        @votable.vote :voter => @voter
-        @votable2.vote_down @voter
-        subject.should include @votable
-        subject.should include @votable2
-        subject.size.should == 2
-      end
-
-      it 'does not return objects of a class that a voter has voted for' do
-        @votable.vote :voter => @voter2
-        @votable2.vote :voter => @voter2
-        subject.size.should == 0
-      end
-    end
-
-    describe '#get_up_voted' do
-      subject { @voter.get_up_voted(@votable.class) }
-
-      it 'returns up voted items that a voter has voted for' do
-        @votable.vote :voter => @voter
-        subject.should include @votable
-        subject.size.should == 1
-      end
-
-      it 'does not return down voted items a voter has voted for' do
-        @votable.vote_down @voter
-        subject.size.should == 0
-      end
-    end
-
-    describe '#get_down_voted' do
-      subject { @voter.get_down_voted(@votable.class) }
-
-      it 'does not return up voted items that a voter has voted for' do
-        @votable.vote :voter => @voter
-        subject.size.should == 0
-      end
-
-      it 'returns down voted items a voter has voted for' do
-        @votable.vote_down @voter
-        subject.should include @votable
-        subject.size.should == 1
-      end
-    end
+  it_behaves_like "a voter_model" do
+    # TODO Replace with factories
+    let (:voter) { Voter.create(:name => 'i can vote!') }
+    let (:voter2) { Voter.create(:name => 'a new person') }
+    let (:votable) { Votable.create(:name => 'a voting model') }
+    let (:votable2) { Votable.create(:name => 'a 2nd voting model') }
   end
 end