mongoid_atomic_votes 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 474842edee2815d2d65750077a75894ac7f67dc0
-  data.tar.gz: 414e249a6a8bd8c9bfb4852381f7d47f6131bdf7
+  metadata.gz: 18279cb81ff240c02a926b21066c461c80dfa500
+  data.tar.gz: 2234359382750bfb52027fff45933ae589df3897
 SHA512:
-  metadata.gz: d7e410e7eb861576dde400586ee450bf7514ce6202a4c14b5aa01b4c2b9b97339cfd6d06cde5006ca21ab6d62f2d9a616bcb76b7a916904cdaf509fa6582b6ad
-  data.tar.gz: 2bbbc2ff81776a89cef0f4878d6bd3ff6f72c7cc6338d97c96c2b8c71cabda3cfb653fe01cf0abc33a049814e0126f2427da34515ebad156ab7aa82b2ad8e875
+  metadata.gz: 5c135a92ae45d11af9af5fcea96d6469c614b982ef7aa5573ef364c21ea8807ff1875556b91880231265e5eb7ebe4bdda5286a9affb4586b8adec514a93bda65
+  data.tar.gz: c8c59df6c14596b8a2efa96041cf68f5bed0071efdc44f051f29b7ed55a40959e99fe1617a4a8560bd88b9e287f1b88be8376dd4a6e58282436c88ba70b9010a

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 .idea
+.gems

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-  - "1.9.3"
   - "2.0.0"
+  - "2.3.0"
 services:
   - mongodb
 script: bundle exec rspec spec

data/Gemfile

@@ -8,5 +8,4 @@ group :test do
   gem 'factory_girl'
   gem 'simplecov', require: false
   gem 'database_cleaner'
-  gem 'pry'
 end

data/lib/mongoid_atomic_votes/atomic_votes.rb

@@ -2,100 +2,160 @@ module Mongoid
   module AtomicVotes
     class << self
       def included(base)
+        define_fields(base)
         define_relations(base)
         define_scopes(base)
+
         base.extend ClassMethods
       end
 
       private
-      def define_relations(base)
+      def define_fields(base)
         base.field :vote_count, type: Integer, default: 0
         base.field :vote_value, type: Float, default: nil
+      end
+
+      def define_relations(base)
         base.embeds_many :votes, class_name: 'Mongoid::AtomicVotes::Vote', as: :atomic_voteable
       end
 
       def define_scopes(base)
-        base.scope :not_voted, -> { base.where(:vote_value.exists => false) }
-        base.scope :voted, -> { base.where(:vote_value.exists => true) }
-        base.scope :voted_by, ->(resource) do
-          base.where('votes.voted_by_id' => resource.id, 'votes.voter_type' => resource.class.name)
-        end
-        base.scope :vote_value_in, ->(range) do
-          base.where(:vote_value.gte => range.begin, :vote_value.lte => range.end)
-        end
-        base.scope :highest_voted, ->(limit=10) { base.order_by(:vote_value.desc).limit(limit) }
+        scopes(base).each { |name, block| base.scope name, block }
+      end
+
+      def scopes(base)
+        {
+            not_voted: -> { base.where(:vote_value.exists => false) },
+            voted: -> { base.where(:vote_value.exists => true) },
+            voted_by: ->(resource) {
+              base.where(
+                  'votes.voted_by_id' => resource.id,
+                  'votes.voter_type' => resource.class.name
+              )
+            },
+            vote_value_in: ->(range) {
+              base.where(
+                  :vote_value.gte => range.begin,
+                  :vote_value.lte => range.end
+              )
+            },
+            highest_voted: ->(limit=10) { base.order_by(:vote_value.desc).limit(limit) }
+        }
       end
     end
 
+    # Creates an embedded vote record and updates number of votes and vote value.
+    #
+    # @param [Int,Float] value vote value
+    # @param [Mongoid::Document] voted_by object from which the vote is done
+    # @return [Boolean] success flag
     def vote(value, voted_by)
       mark = Vote.new(value: value, voted_by_id: voted_by.id, voter_type: voted_by.class.name)
-      return false unless mark.valid?
       add_vote_mark(mark)
     end
 
+    # Removes previously added vote.
+    #
+    # @param [Mongoid::Document] voted_by object from which the vote was done
+    # @return [Boolean] success flag
     def retract(voted_by)
       mark = self.votes.find_by(voted_by_id: voted_by.id)
-      return false unless mark
-      remove_vote_mark(mark)
+      mark && remove_vote_mark(mark)
     end
 
+    # Indicates whether the document has votes or not.
+    #
+    # @return [Boolean]
     def has_votes?
       self.vote_count > 0
     end
 
+    # Indicates whether the document has a vote from particular voter object
+    #
+    # @param [Mongoid::Document] voted_by object from which the vote was done
+    # @return [Boolean]
     def voted_by?(voted_by)
       !!self.votes.find_by(voted_by_id: voted_by.id)
-    rescue
+    rescue NoMethodError, Mongoid::Errors::DocumentNotFound
       false
     end
 
     module ClassMethods
+      attr_reader :vote_range
+
+      # Specifies possible vote range which is used vote mark validation later.
+      #
+      # @param [Range] val new vote range, for example: 1..5
+      # @return [Range] vote range, previously passed to a method as a parameter
       def set_vote_range(val)
-        raise 'argument should be a Range' unless val.is_a?(Range)
-        Vote.send(__method__, val)
+        fail ArgumentError.new('argument should be a Range') unless val.is_a?(Range)
+        @vote_range = val
+      end
+
+      # Sets vote range to nil
+      # @return [NilClass] nil
+      def reset_vote_range
+        @vote_range = nil
       end
     end
 
     private
-    def update_votes(mark, retract=false)
-      opts = {
-        '$inc' => { vote_count: retract ? -1 : 1 },
-        '$set' => { vote_value: self.vote_value }
-      }
 
-      if retract
-        opts['$pull'] = { votes: { _id: mark.id } }
+    def update_vote_counters(mark, increment_count_by)
+      self.vote_value = calculate_vote_value(mark.value, increment_count_by)
+      self.vote_count += increment_count_by
+    end
+
+    def calculate_vote_value(value, count)
+      current_vote_count = self.vote_count
+      new_vote_count = current_vote_count + count
+
+      if new_vote_count > 0
+        (current_vote_count * self.vote_value.to_f + value * count) / new_vote_count
       else
-        opts['$push'] = { votes: mark.as_json }
+        nil
       end
+    end
 
-      self.collection.find(_id: self.id).update_one(opts).modified_count > 0
+    def update_votes(query_opts)
+      self.collection.find(_id: self.id).update_one(query_opts).modified_count > 0
     end
 
-    def update_vote_value(mark, retract=false)
-      value, vote_count_diff = [mark.value, 1].map { |v| v * (retract ? -1 : 1) }
-      self.vote_value = if self.vote_count == 1 && retract
-                          nil
-                        else
-                          (self.vote_count * self.vote_value.to_f + value) / (self.vote_count + vote_count_diff)
-                        end
-      self.vote_count += vote_count_diff
+    def vote_options(mark)
+      {
+          '$inc' => { vote_count: 1 },
+          '$set' => { vote_value: self.vote_value },
+          '$push' => { votes: mark.as_json }
+      }
+    end
+
+    def retract_options(mark)
+      {
+          '$inc' => { vote_count: -1 },
+          '$set' => { vote_value: self.vote_value },
+          '$pull' => { votes: { _id: mark.id } }
+      }
     end
 
     def add_vote_mark(mark)
+      mark_is_valid = false
+
       _assigning do
         self.votes << mark
-        update_vote_value(mark)
+        mark_is_valid = mark.valid?
+        mark_is_valid && update_vote_counters(mark, 1)
       end
-      update_votes(mark)
+
+      mark_is_valid && update_votes(vote_options(mark))
     end
 
     def remove_vote_mark(mark)
       _assigning do
-        self.votes.reject! { |v| v.id == mark.id }
-        update_vote_value(mark, true)
+        self.votes.reject! { |vote| vote.id == mark.id }
+        update_vote_counters(mark, -1)
       end
-      update_votes(mark, true)
+
+      update_votes(retract_options(mark))
     end
   end
 end

data/lib/mongoid_atomic_votes/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module AtomicVotes
-    VERSION = '0.2.1'
+    VERSION = '1.0.0'
   end
 end

data/lib/mongoid_atomic_votes/vote.rb

@@ -9,19 +9,9 @@ class Mongoid::AtomicVotes::Vote
   field :voter_type, type: String
 
   validates_presence_of :value, :voted_by_id, :voter_type
-  validates_inclusion_of :value, in: ->(vote) { vote.class.vote_range }, if: ->(vote) { vote.class.vote_range }
+  validates_inclusion_of :value,
+                         in: ->(vote) { vote.atomic_voteable.class.vote_range },
+                         if: ->(vote) { vote.atomic_voteable.class.vote_range }
 
   index({ voted_by_id: 1, mark: 1 }, unique: true, background: true)
-
-  class << self
-    @@vote_range = nil
-
-    def set_vote_range(val)
-      @@vote_range ||= val
-    end
-
-    def vote_range
-      @@vote_range
-    end
-  end
 end

data/spec/factories/factories.rb

@@ -1,9 +1,15 @@
 FactoryGirl.define do
   factory :user do
-    sequence(:login) {|n| "user_#{n}"}
+    sequence(:login) { |n| "user_#{n}" }
   end
 
   factory :post do
-    sequence(:title) {|n| "post_#{n}"}
+    sequence(:title) { |n| "post_#{n}" }
+  end
+
+  factory :vote, class: 'Mongoid::AtomicVotes::Vote' do
+    value { rand(0..10) }
+    sequence(:voted_by_id) { |n| n }
+    voter_type 'User'
   end
 end

data/spec/lib/atomic_votes_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe Post do
+  let!(:users) { FactoryGirl.create_list(:user, 2) }
+  let!(:post) { FactoryGirl.create(:post) }
+
+  it 'has Mongoid::AtomicVotes module' do
+    expect(subject.class.ancestors).to include(Mongoid::AtomicVotes)
+  end
+
+  it { expect(subject).to respond_to(:vote) }
+  it { expect(subject).to respond_to(:retract) }
+  it { expect(subject).to respond_to(:has_votes?) }
+  it { expect(subject).to respond_to(:vote_count) }
+  it { expect(subject).to respond_to(:vote_value) }
+  it { expect(subject).to respond_to(:votes) }
+
+  it { expect(subject.class).to respond_to(:set_vote_range) }
+  it { expect { subject.class.set_vote_range(1) }.to raise_error('argument should be a Range') }
+
+  describe '#votes' do
+    it { expect(post.votes).to be_an_instance_of(Array) }
+  end
+
+  describe 'when does not have votes' do
+    it 'is in not_voted scope' do
+      expect(subject.class.not_voted).to include(post)
+    end
+
+    it 'is not in voted scope' do
+      expect(subject.class.voted).not_to include(post)
+    end
+
+    it 'is not in voted_by scope' do
+      expect(users.all? { |user| subject.class.voted_by(user).include?(post) == false }).to eq(true)
+    end
+
+    it '#vote_count returns 0' do
+      expect(post.vote_count).to eq(0)
+    end
+
+    it '#vote_value returns nil' do
+      expect(post.vote_value).to be_nil
+    end
+
+    it '#votes returns empty array' do
+      expect(post.votes).to eq([])
+    end
+
+    it '#has_votes? returns false' do
+      expect(post.has_votes?).to eq(false)
+    end
+
+    it '#voted_by? returns false for any voter' do
+      expect(users.all? { |user| post.voted_by?(user) == false }).to eq(true)
+    end
+
+    describe '#vote' do
+      let(:votes) { [rand(1..10), rand(1..10)] }
+      let(:expected_vote_value) { votes.sum.to_f / users.size }
+
+      it 'returns true on successfull vote' do
+        expect(users.all? { |user| post.vote(rand(1..10), user) == true }).to eq(true)
+      end
+
+      it 'properly calculates vote value' do
+        users.each_with_index { |user, index| post.vote(votes[index], user) }
+        expect(post.vote_value).to eq(expected_vote_value)
+      end
+
+      it 'properly adds vote' do
+        expect { post.vote(rand(1..10), users.sample) }.to change { post.vote_count }.by(1)
+      end
+
+      it 'persists changes to database' do
+        users.each_with_index { |user, index| post.vote(votes[index], user) }
+
+        db_post = Post.find(post.id)
+        votes_info = [
+          db_post.vote_value,
+          db_post.vote_count,
+          db_post.votes.size
+        ]
+        expect(votes_info).to eq([expected_vote_value, users.size, users.size])
+      end
+    end
+  end
+
+  describe 'when has votes' do
+    before(:each) do
+      users.each { |user| post.vote(rand(1..10), user) }
+    end
+
+    it 'is not in the not_voted scope' do
+      expect(subject.class.not_voted).not_to include(post)
+    end
+
+    it 'is in voted scope' do
+      expect(subject.class.voted).to include(post)
+    end
+
+    it 'is in voted_by scope for each voted user' do
+      expect(users.all? { |user| subject.class.voted_by(user).include?(post) == true }).to eq(true)
+    end
+
+    it '#vote_count returns count of votes' do
+      expect(post.vote_count).to eq(post.votes.size)
+    end
+
+    it '#vote_value returns actual vote value' do
+      expected_vote_value = post.votes.map(&:value).sum.to_f / post.votes.size
+      expect(post.vote_value).to eq(expected_vote_value)
+    end
+
+    describe '#votes' do
+      let(:votes) { post.votes }
+
+      it { expect(votes.class).to eq(Array) }
+      it { expect(votes).not_to be_empty }
+      it { expect(votes.size).to eq(users.size) }
+      it { expect(votes.map(&:voted_by_id)).to match_array(users.map(&:id)) }
+    end
+
+    it '#has_votes? returns true' do
+      expect(post.has_votes?).to eq(true)
+    end
+
+    it '#voted_by? returns true for all voted resource' do
+      expect(users.all? { |user| post.voted_by?(user) == true }).to eq(true)
+    end
+
+    describe '#retract' do
+      it 'returns true on successfull vote retract' do
+        expect(users.all? { |user| post.retract(user) == true }).to eq(true)
+      end
+
+      it 'properly calculates vote value' do
+        user = users.sample
+        retracted_vote_value = post.votes.find_by(voted_by_id: user.id).value
+        expected_vote_value = (post.votes.map(&:value).sum.to_f - retracted_vote_value) / (users.size - 1)
+
+        post.retract(user)
+        expect(post.vote_value).to eq(expected_vote_value)
+      end
+
+      it 'properly decreases vote count' do
+        expect { post.retract(users.sample) }.to change { post.vote_count }.by(-1)
+      end
+
+      it 'persists changes to database' do
+        user = users.sample
+        retracted_vote_value = post.votes.find_by(voted_by_id: user.id).value
+        expected_vote_value = (post.votes.map(&:value).sum.to_f - retracted_vote_value) / (users.size - 1)
+
+        post.retract(user)
+
+        db_post = Post.find(post.id)
+        votes_info = [
+            db_post.vote_value,
+            db_post.vote_count,
+            db_post.votes.size
+        ]
+        expect(votes_info).to eq([expected_vote_value, users.size - 1, users.size - 1])
+      end
+    end
+  end
+
+  describe 'when model has vote_range' do
+    before { Post.set_vote_range(1..5) }
+
+    it 'marks vote as invalid if value is out of range' do
+      post.vote(rand(6..10), users.sample)
+      expect(post.votes.last).not_to be_valid
+    end
+
+    it 'marks post as invalid' do
+      post.vote(rand(6..10), users.sample)
+      expect(post).not_to be_valid
+    end
+
+    it 'has properly filled error messages for invalid vote' do
+      post.vote(rand(6..10), users.sample)
+      expect(post.votes.last.errors.messages[:value].first).to match(/included in the list/)
+    end
+
+    describe '#reset_vote_range' do
+      let(:klass) { post.class }
+
+      it 'sets vote_range to nil' do
+        expect { klass.reset_vote_range }.to change { klass.vote_range }.to(nil)
+      end
+    end
+  end
+end

data/spec/lib/vote_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec.describe Mongoid::AtomicVotes::Vote do
+  let(:vote) { FactoryGirl.build(:vote, atomic_voteable: post) }
+  let(:post) { FactoryGirl.create(:post) }
+
+  it { expect(vote).to be_valid }
+
+  it 'is not valid without vote value' do
+    vote.value = nil
+    expect(vote).not_to be_valid
+  end
+
+  it 'is not valid without voted_by_id' do
+    vote.voted_by_id = nil
+    expect(vote).not_to be_valid
+  end
+
+  it 'is not valid without voter type' do
+    vote.voter_type = nil
+    expect(vote).not_to be_valid
+  end
+
+  context 'with vote range' do
+    before do
+      vote.atomic_voteable = post
+      post.class.set_vote_range(2..5)
+    end
+
+    after { post.class.reset_vote_range }
+
+    it 'is valid if value is in range specified in vote_range' do
+      vote.value = rand(post.class.vote_range)
+      expect(vote).to be_valid
+    end
+
+    it 'is not valid if value is out of range specified in vote_range' do
+      vote.value = [1, 6].sample
+      expect(vote).not_to be_valid
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,6 +3,8 @@ MODELS = File.join(File.dirname(__FILE__), 'models')
 require 'rubygems'
 require 'database_cleaner'
 require 'factory_girl'
+require 'mongoid'
+require 'mongoid_atomic_votes'
 require 'simplecov'
 
 SimpleCov.start do
@@ -10,9 +12,6 @@ SimpleCov.start do
   add_filter '/.bundle/'
 end
 
-require 'mongoid'
-require 'mongoid_atomic_votes'
-
 Dir["#{MODELS}/*.rb"].each { |f| require f }
 
 Mongoid.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_atomic_votes
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Hck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-24 00:00:00.000000000 Z
+date: 2016-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -42,8 +42,9 @@ files:
 - lib/mongoid_atomic_votes/version.rb
 - lib/mongoid_atomic_votes/vote.rb
 - mongoid_atomic_votes.gemspec
-- spec/atomic_votes_spec.rb
 - spec/factories/factories.rb
+- spec/lib/atomic_votes_spec.rb
+- spec/lib/vote_spec.rb
 - spec/models/post.rb
 - spec/models/user.rb
 - spec/spec_helper.rb
@@ -66,13 +67,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Atomic votes implementation for mongoid
 test_files:
-- spec/atomic_votes_spec.rb
 - spec/factories/factories.rb
+- spec/lib/atomic_votes_spec.rb
+- spec/lib/vote_spec.rb
 - spec/models/post.rb
 - spec/models/user.rb
 - spec/spec_helper.rb

data/spec/atomic_votes_spec.rb

@@ -1,171 +0,0 @@
-require 'pry'
-require 'spec_helper'
-
-describe Post do
-  before(:each) do
-    @users = FactoryGirl.create_list(:user, 2)
-    @post = FactoryGirl.create(:post)
-  end
-
-  it 'has Mongoid::AtomicVotes module' do
-    expect(subject.class.ancestors).to include(Mongoid::AtomicVotes)
-  end
-
-  it { expect(subject).to respond_to(:vote) }
-  it { expect(subject).to respond_to(:retract) }
-  it { expect(subject).to respond_to(:has_votes?) }
-  it { expect(subject).to respond_to(:vote_count) }
-  it { expect(subject).to respond_to(:vote_value) }
-  it { expect(subject).to respond_to(:votes) }
-
-  it { expect(subject.class).to respond_to(:set_vote_range) }
-  it { expect { subject.class.set_vote_range(1) }.to raise_error('argument should be a Range') }
-
-  describe '#votes' do
-    it 'is array of votes' do
-      expect(@post.votes).to be_an_instance_of(Array)
-    end
-  end
-
-  describe 'when does not have votes' do
-    it 'is in not_voted scope' do
-      expect(subject.class.not_voted).to include(@post)
-    end
-
-    it 'is not in voted scope' do
-      expect(subject.class.voted).not_to include(@post)
-    end
-
-    it 'is not in voted_by scope' do
-      @users.each do |u|
-        expect(subject.class.voted_by(u)).not_to include(@post)
-      end
-    end
-
-    it '#vote_count returns 0' do
-      expect(@post.vote_count).to eq(0)
-    end
-
-    it '#vote_value returns nil' do
-      expect(@post.vote_value).to be_nil
-    end
-
-    it '#votes returns empty array' do
-      expect(@post.votes).to eq([])
-    end
-
-    it '#has_votes? returns false' do
-      expect(@post.vote_count).to eq(0)
-      expect(@post.has_votes?).to be_falsey
-    end
-
-    it '#voted_by? returns false with any resource' do
-      @users.each do |u|
-        expect(@post.voted_by?(u)).to be_falsey
-      end
-    end
-
-    it '#vote returns true on successful vote' do
-      @users.each do |u|
-        expect(@post.vote(rand(1..10), u)).to be_truthy
-      end
-
-      vote_value = @post.votes.map(&:value).sum.to_f/@post.votes.size
-
-      expect(@post.vote_value).to eq(vote_value)
-      expect(@post.vote_count).to eq(@users.size)
-      expect(@post.votes.size).to eq(@users.size)
-
-      Post.find(@post.id).tap do |post|
-        expect(post.vote_value).to eq(vote_value)
-        expect(post.vote_count).to eq(@users.size)
-        expect(post.votes.size).to eq(@users.size)
-      end
-    end
-  end
-
-  describe 'when has votes' do
-    before(:each) do
-      @users.each{|u| @post.vote(rand(1..10), u)}
-    end
-
-    it 'is not in the not_voted scope' do
-      expect(subject.class.not_voted).not_to include(@post)
-    end
-
-    it 'is in voted scope' do
-      expect(subject.class.voted).to include(@post)
-    end
-
-    it 'is in voted_by scope for each voted user' do
-      @users.each do |u|
-        expect(subject.class.voted_by(u)).to include(@post)
-      end
-    end
-
-    it '#vote_count returns count of votes' do
-      expect(@post.vote_count).to eq(@post.votes.size)
-    end
-
-    it '#vote_value returns actual vote value' do
-      vote_value = @post.votes.map(&:value).sum.to_f/@post.votes.size
-      expect(@post.vote_value).to eq(vote_value)
-    end
-
-    it '#votes returns array of vote marks' do
-      @post.votes.tap do |votes|
-        expect(votes.class).to eq(Array)
-        expect(votes).not_to be_empty
-        expect(votes.size).to eq(@users.size)
-        expect(votes.map(&:voted_by_id).sort).to eq(@users.map(&:id).sort)
-      end
-    end
-
-    it '#has_votes? returns true' do
-      expect(@post.vote_count).to eq(@post.votes.size)
-      expect(@post.has_votes?).to be_truthy
-    end
-
-    it '#voted_by? returns true for all voted resource' do
-      @users.each do |u|
-        expect(@post.voted_by?(u)).to be_truthy
-      end
-    end
-
-    it '#retract returns true on successful vote retract' do
-      cnt = @users.size
-
-      @users.each do |u|
-        expect(@post.retract(u)).to be_truthy
-        cnt -= 1
-
-        vote_value = @post.votes.size == 0 ? nil : @post.votes.map(&:value).sum.to_f/@post.votes.size
-
-        expect(@post.vote_value).to eq(vote_value)
-        expect(@post.vote_count).to eq(@post.votes.size)
-        expect(@post.vote_count).to eq(cnt)
-
-        expect(Post.find(@post.id).vote_value).to eq(vote_value)
-        expect(Post.find(@post.id).vote_count).to eq(cnt)
-        Post.find(@post.id).votes.size == cnt
-      end
-    end
-  end
-
-  describe 'when model has vote_range' do
-    before(:each) do
-      Post.send(:set_vote_range, 1..5)
-      @post = FactoryGirl.create(:post)
-    end
-
-    it 'Vote has vote_range set up' do
-      expect(Mongoid::AtomicVotes::Vote.vote_range).to eq((1..5))
-    end
-
-    it 'Vote is not valid if its value is not in specified vote_range' do
-      @vote = Mongoid::AtomicVotes::Vote.new(value: rand(6..10), voted_by_id: @users.first.id, voter_type: @users.first.class.name)
-      expect(@vote).not_to be_valid
-      expect(@vote.errors.messages[:value].first).to match(/included in the list/)
-    end
-  end
-end