acts_as_votable 0.10.0 → 0.11.0

data/spec/shared_example/voter_model.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+shared_examples "a voter_model" do
+  let (:votable_klass) { votable.class }
+
+  it "should be voted on after a voter has voted" do
+    votable.vote_by voter: voter
+    expect(voter.voted_on?(votable)).to be true
+    expect(voter.voted_for?(votable)).to be true
+  end
+
+  it "should not be voted on if a voter has not voted" do
+    expect(voter.voted_on?(votable)).to be false
+  end
+
+  it "should be voted on after a voter has voted under scope" do
+    votable.vote_by voter: voter, vote_scope: "rank"
+    expect(voter.voted_on?(votable, vote_scope: "rank")).to be true
+  end
+
+  it "should not be voted on other scope after a voter has voted under one scope" do
+    votable.vote_by voter: voter, vote_scope: "rank"
+    expect(voter.voted_on?(votable)).to be false
+  end
+
+  it "should be voted as true when a voter has voted true" do
+    votable.vote_by voter: voter
+    expect(voter.voted_as_when_voted_on(votable)).to be true
+    expect(voter.voted_as_when_voted_for(votable)).to be true
+  end
+
+  it "should be voted as true when a voter has voted true under scope" do
+    votable.vote_by voter: voter, vote_scope: "rank"
+    expect(voter.voted_as_when_voted_for(votable, vote_scope: "rank")).to be true
+  end
+
+  it "should be voted as false when a voter has voted false" do
+    votable.vote_by voter: voter, vote: false
+    expect(voter.voted_as_when_voted_for(votable)).to be false
+  end
+
+  it "should be voted as false when a voter has voted false under scope" do
+    votable.vote_by voter: voter, vote: false, vote_scope: "rank"
+    expect(voter.voted_as_when_voted_for(votable, vote_scope: "rank")).to be false
+  end
+
+  it "should be voted as nil when a voter has never voted" do
+    expect(voter.voted_as_when_voting_on(votable)).to be nil
+  end
+
+  it "should be voted as nil when a voter has never voted under the scope" do
+    votable.vote_by voter: voter, vote: false, vote_scope: "rank"
+    expect(voter.voted_as_when_voting_on(votable)).to be nil
+  end
+
+  it "should return true if voter has voted true" do
+    votable.vote_by voter: voter
+    expect(voter.voted_up_on?(votable)).to be true
+  end
+
+  it "should return false if voter has not voted true" do
+    votable.vote_by voter: voter, vote: false
+    expect(voter.voted_up_on?(votable)).to be false
+  end
+
+  it "should return true if the voter has voted false" do
+    votable.vote_by voter: voter, vote: false
+    expect(voter.voted_down_on?(votable)).to be true
+  end
+
+  it "should return false if the voter has not voted false" do
+    votable.vote_by voter: voter, vote: true
+    expect(voter.voted_down_on?(votable)).to be false
+  end
+
+  it "should provide reserve functionality, voter can vote on votable" do
+    voter.vote votable: votable, vote: "bad"
+    expect(voter.voted_as_when_voting_on(votable)).to be false
+  end
+
+  it "should allow the voter to vote up a model" do
+    voter.vote_up_for votable
+    expect(votable.get_up_votes.first.voter).to eq(voter)
+    expect(votable.votes_for.up.first.voter).to eq(voter)
+  end
+
+  it "should allow the voter to vote down a model" do
+    voter.vote_down_for votable
+    expect(votable.get_down_votes.first.voter).to eq(voter)
+    expect(votable.votes_for.down.first.voter).to eq(voter)
+  end
+
+  it "should allow the voter to unvote a model" do
+    voter.vote_up_for votable
+    voter.unvote_for votable
+    expect(votable.find_votes_for.size).to eq(0)
+    expect(votable.votes_for.count).to eq(0)
+  end
+
+  it "should get all of the voters votes" do
+    voter.vote_up_for votable
+    expect(voter.find_votes.size).to eq(1)
+    expect(voter.votes.up.count).to eq(1)
+  end
+
+  it "should get all of the voters up votes" do
+    voter.vote_up_for votable
+    expect(voter.find_up_votes.size).to eq(1)
+    expect(voter.votes.up.count).to eq(1)
+  end
+
+  it "should get all of the voters down votes" do
+    voter.vote_down_for votable
+    expect(voter.find_down_votes.size).to eq(1)
+    expect(voter.votes.down.count).to eq(1)
+  end
+
+  it "should get all of the votes votes for a class" do
+    votable.vote_by voter: voter
+    votable2.vote_by voter: voter, vote: false
+    expect(voter.find_votes_for_class(votable_klass).size).to eq(2)
+    expect(voter.votes.for_type(votable_klass).count).to eq(2)
+  end
+
+  it "should get all of the voters up votes for a class" do
+    votable.vote_by voter: voter
+    votable2.vote_by voter: voter, vote: false
+    expect(voter.find_up_votes_for_class(votable_klass).size).to eq(1)
+    expect(voter.votes.up.for_type(votable_klass).count).to eq(1)
+  end
+
+  it "should get all of the voters down votes for a class" do
+    votable.vote_by voter: voter
+    votable2.vote_by voter: voter, vote: false
+    expect(voter.find_down_votes_for_class(votable_klass).size).to eq(1)
+    expect(voter.votes.down.for_type(votable_klass).count).to eq(1)
+  end
+
+  it "should be contained to instances" do
+    voter.vote votable: votable, vote: false
+    voter2.vote votable: votable
+
+    expect(voter.voted_as_when_voting_on(votable)).to be false
+  end
+
+  describe "#find_voted_items" do
+    it "returns objects that a user has upvoted for" do
+      votable.vote_by voter: voter
+      votable2.vote_by voter: voter2
+      expect(voter.find_voted_items).to include votable
+      expect(voter.find_voted_items.size).to eq(1)
+    end
+
+    it "returns objects that a user has upvoted for, using scope" do
+      votable.vote_by voter: voter, vote_scope: "rank"
+      votable2.vote_by voter: voter2, vote_scope: "rank"
+      expect(voter.find_voted_items(vote_scope: "rank")).to include votable
+      expect(voter.find_voted_items(vote_scope: "rank").size).to eq(1)
+    end
+
+    it "returns objects that a user has downvoted for" do
+      votable.vote_down voter
+      votable2.vote_down voter2
+      expect(voter.find_voted_items).to include votable
+      expect(voter.find_voted_items.size).to eq(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"
+      expect(voter.find_voted_items(vote_scope: "rank")).to include votable
+      expect(voter.find_voted_items(vote_scope: "rank").size).to eq(1)
+    end
+  end
+
+  describe "#find_up_voted_items" do
+    it "returns objects that a user has upvoted for" do
+      votable.vote_by voter: voter
+      votable2.vote_by voter: voter2
+      expect(voter.find_up_voted_items).to include votable
+      expect(voter.find_up_voted_items.size).to eq(1)
+      expect(voter.find_liked_items).to include votable
+      expect(voter.find_liked_items.size).to eq(1)
+    end
+
+    it "returns objects that a user has upvoted for, using scope" do
+      votable.vote_by voter: voter, vote_scope: "rank"
+      votable2.vote_by voter: voter2, vote_scope: "rank"
+      expect(voter.find_up_voted_items(vote_scope: "rank")).to include votable
+      expect(voter.find_up_voted_items(vote_scope: "rank").size).to eq(1)
+    end
+
+    it "does not return objects that a user has downvoted for" do
+      votable.vote_down voter
+      expect(voter.find_up_voted_items.size).to eq(0)
+    end
+
+    it "does not return objects that a user has downvoted for, using scope" do
+      votable.vote_down voter, vote_scope: "rank"
+      expect(voter.find_up_voted_items(vote_scope: "rank").size).to eq(0)
+    end
+  end
+
+  describe "#find_down_voted_items" do
+    it "does not return objects that a user has upvoted for" do
+      votable.vote_by voter: voter
+      expect(voter.find_down_voted_items.size).to eq(0)
+    end
+
+    it "does not return objects that a user has upvoted for, using scope" do
+      votable.vote_by voter: voter, vote_scope: "rank"
+      expect(voter.find_down_voted_items(vote_scope: "rank").size).to eq(0)
+    end
+
+    it "returns objects that a user has downvoted for" do
+      votable.vote_down voter
+      votable2.vote_down voter2
+      expect(voter.find_down_voted_items).to include votable
+      expect(voter.find_down_voted_items.size).to eq(1)
+      expect(voter.find_disliked_items).to include votable
+      expect(voter.find_disliked_items.size).to eq(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"
+      expect(voter.find_down_voted_items(vote_scope: "rank")).to include votable
+      expect(voter.find_down_voted_items(vote_scope: "rank").size).to eq(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_by voter: voter
+      votable2.vote_down voter
+      expect(subject).to include votable
+      expect(subject).to include votable2
+      expect(subject.size).to eq(2)
+    end
+
+    it "does not return objects of a class that a voter has voted for" do
+      votable.vote_by voter: voter2
+      votable2.vote_by voter: voter2
+      expect(subject.size).to eq(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_by voter: voter
+      expect(subject).to include votable
+      expect(subject.size).to eq(1)
+    end
+
+    it "does not return down voted items a voter has voted for" do
+      votable.vote_down voter
+      expect(subject.size).to eq(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_by voter: voter
+      expect(subject.size).to eq(0)
+    end
+
+    it "returns down voted items a voter has voted for" do
+      votable.vote_down voter
+      expect(subject).to include votable
+      expect(subject.size).to eq(1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,15 +1,22 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
-require 'sqlite3'
-require 'acts_as_votable'
+# frozen_string_literal: true
 
-Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+$LOAD_PATH << File.join(File.dirname(__FILE__), "..", "lib")
+require "sqlite3"
+require "simplecov"
+require "acts_as_votable"
+require "factory_girl"
 
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+Dir["./spec/shared_example/**/*.rb"].sort.each { |f| require f }
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
 
-ActiveRecord::Schema.define(:version => 1) do
+SimpleCov.start
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+ActiveRecord::Schema.define(version: 1) do
   create_table :votes do |t|
-    t.references :votable, :polymorphic => true
-    t.references :voter, :polymorphic => true
+    t.references :votable, polymorphic: true
+    t.references :voter, polymorphic: true
 
     t.boolean :vote_flag
     t.string :vote_scope
@@ -61,6 +68,7 @@ ActiveRecord::Schema.define(:version => 1) do
     t.integer :cached_votes_down
     t.integer :cached_weighted_total
     t.integer :cached_weighted_score
+    t.float :cached_weighted_average
 
     t.integer :cached_scoped_test_votes_total
     t.integer :cached_scoped_test_votes_score
@@ -68,6 +76,9 @@ ActiveRecord::Schema.define(:version => 1) do
     t.integer :cached_scoped_test_votes_down
     t.integer :cached_scoped_weighted_total
     t.integer :cached_scoped_weighted_score
+    t.float :cached_scoped_weighted_average
+
+    t.timestamps
   end
 
 end
@@ -78,7 +89,6 @@ class Voter < ActiveRecord::Base
 end
 
 class NotVoter < ActiveRecord::Base
-  
 end
 
 class Votable < ActiveRecord::Base
@@ -102,7 +112,7 @@ class StiNotVotable < ActiveRecord::Base
   validates_presence_of :name
 end
 
-class VotableChildOfStiNotVotable < StiNotVotable
+class ChildOfStiNotVotable < StiNotVotable
   acts_as_votable
 end
 
@@ -114,16 +124,16 @@ class VotableCache < ActiveRecord::Base
   validates_presence_of :name
 end
 
-class ABoringClass
-  def self.hw
-    'hello world'
-  end
+class VotableCacheUpdateAttributes < VotableCache
+  acts_as_votable cacheable_strategy: :update_attributes
 end
 
+class VotableCacheUpdateColumns < VotableCache
+  acts_as_votable cacheable_strategy: :update_columns
+end
 
-def clean_database
-  models = [ActsAsVotable::Vote, Voter, NotVoter, Votable, NotVotable, VotableCache]
-  models.each do |model|
-    ActiveRecord::Base.connection.execute "DELETE FROM #{model.table_name}"
+class ABoringClass
+  def self.hw
+    "hello world"
   end
 end

data/spec/support/factory_girl.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# spec/support/factory_girl.rb
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryGirl.find_definitions
+  end
+end

data/spec/votable_spec.rb

@@ -1,20 +1,21 @@
-require 'acts_as_votable'
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe ActsAsVotable::Votable do
   it "should not be votable" do
-    NotVotable.should_not be_votable
+    expect(NotVotable).not_to be_votable
   end
 
   it "should be votable" do
-    Votable.should be_votable
+    expect(Votable).to be_votable
   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') }
+    let (:voter)         { create(:voter, name: "i can vote!") }
+    let (:voter2)        { create(:voter, name: "a new person") }
+    let (:voter3)        { create(:voter, name: "another person") }
+    let (:votable)       { create(:votable, name: "a voting model") }
+    let (:votable_cache) { create(:votable_cache, name: "voting model with cache") }
   end
 end

data/spec/votable_voter_spec.rb

@@ -1,20 +1,20 @@
-require 'acts_as_votable'
-require 'spec_helper'
+# frozen_string_literal: true
+
+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') }
+    let (:voter)         { create(:votable_voter, name: "i can vote!") }
+    let (:voter2)        { create(:votable_voter, name: "a new person") }
+    let (:voter3)        { create(:voter, name: "another person") }
+    let (:votable)       { create(:votable_voter, name: "a voting model") }
+    let (:votable_cache) { create(:votable_cache, 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') }
+    let (:voter)    { create(:votable_voter, name: "i can vote!") }
+    let (:voter2)   { create(:votable_voter, name: "a new person") }
+    let (:votable)  { create(:votable_voter, name: "a voting model") }
+    let (:votable2) { create(:votable_voter, name: "a 2nd voting model") }
   end
 end

data/spec/voter_spec.rb

@@ -1,21 +1,20 @@
-require 'acts_as_votable'
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe ActsAsVotable::Voter do
+require "spec_helper"
 
+describe ActsAsVotable::Voter do
   it "should not be a voter" do
-    NotVotable.should_not be_votable
+    expect(NotVotable).not_to be_votable
   end
 
   it "should be a voter" do
-    Votable.should be_votable
+    expect(Votable).to be_votable
   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') }
+    let (:voter)    { create(:voter, name: "i can vote!") }
+    let (:voter2)   { create(:voter, name: "a new person") }
+    let (:votable)  { create(:votable, name: "a voting model") }
+    let (:votable2) { create(:votable, name: "a 2nd voting model") }
   end
 end